static void
test_html (const char *datadir, const char *input, const char *output, guint32 citation)
{
guint32 flags = GMIME_FILTER_HTML_CONVERT_NL | GMIME_FILTER_HTML_CONVERT_SPACES |
GMIME_FILTER_HTML_CONVERT_URLS | GMIME_FILTER_HTML_CONVERT_ADDRESSES;
const char *what = "GMimeFilterHtml", *mode;
GByteArray *expected, *actual;
GMimeStream *stream;
GMimeFilter *filter;
char *path;
switch (citation) {
case GMIME_FILTER_HTML_BLOCKQUOTE_CITATION: mode = "blockquote"; break;
case GMIME_FILTER_HTML_MARK_CITATION: mode = "mark"; break;
case GMIME_FILTER_HTML_CITE: mode = "cite"; break;
default: mode = "none"; break;
}
testsuite_check ("%s (%s %s)", what, input, mode);
actual = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (actual);
g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE);
filter = g_mime_filter_html_new (flags | citation, 0x008888);
path = g_build_filename (datadir, input, NULL);
pump_data_through_filter (filter, path, stream, TRUE, TRUE);
g_mime_filter_reset (filter);
g_object_unref (stream);
g_object_unref (filter);
g_free (path);
path = g_build_filename (datadir, output, NULL);
expected = read_all_bytes (path, TRUE);
g_free (path);
if (actual->len != expected->len) {
testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u",
what, expected->len, actual->len);
stream = g_mime_stream_fs_open (output, O_WRONLY | O_CREAT, 0644, NULL);
g_mime_stream_write (stream, (const char *) actual->data, actual->len);
g_mime_stream_flush (stream);
g_object_unref (stream);
goto error;
}
if (memcmp (actual->data, expected->data, actual->len) != 0) {
testsuite_check_failed ("%s failed: stream contents do not match", what);
goto error;
}
testsuite_check_passed ();
error:
g_byte_array_free (expected, TRUE);
g_byte_array_free (actual, TRUE);
}
void UcXmlParserTest::testSimpleParsing()
{
void* pD = NULL;
int nLen = read_all_bytes("..\\..\\..\\test\\test_pages\\lp_navi.xml", &pD);
pXmlParser_m->parseData((const char*)pD, nLen, true);
free_all_bytes(pD);
}
bool load_image(flow_c * c, char * checksum, struct flow_bitmap_bgra ** ref, void * bitmap_owner)
{
char filename[2048];
if (!create_relative_path(c, false, filename, 2048, "/visuals/%s.png", checksum)) {
FLOW_add_to_callstack(c);
return false;
}
struct flow_job * job = flow_job_create(c);
if (job == NULL) {
FLOW_error_return(c);
}
size_t bytes_count;
uint8_t * bytes = read_all_bytes(c, &bytes_count, filename);
if (bytes == NULL) {
FLOW_error_return(c);
}
struct flow_io * input = flow_io_create_from_memory(c, flow_io_mode_read_seekable, bytes, bytes_count, job, NULL);
if (input == NULL) {
FLOW_error_return(c);
}
if (!flow_job_add_io(c, job, input, 0, FLOW_INPUT)) {
FLOW_error_return(c);
}
struct flow_graph * g = flow_graph_create(c, 10, 10, 200, 2.0);
if (g == NULL) {
FLOW_add_to_callstack(c);
return false;
}
int32_t last;
last = flow_node_create_decoder(c, &g, -1, 0);
last = flow_node_create_bitmap_bgra_reference(c, &g, last, ref);
if (flow_context_has_error(c)) {
FLOW_add_to_callstack(c);
return false;
}
if (!flow_job_execute(c, job, &g)) {
FLOW_add_to_callstack(c);
return false;
}
// Let the bitmap last longer than the job
if (!flow_set_owner(c, *ref, bitmap_owner)) {
FLOW_add_to_callstack(c);
return false;
}
if (!flow_job_destroy(c, job)) {
FLOW_error_return(c);
}
FLOW_free(c, bytes);
return true;
}
static void
test_gzip (const char *datadir, const char *filename)
{
char *name = g_strdup_printf ("%s.gz", filename);
char *path = g_build_filename (datadir, filename, NULL);
const char *what = "GMimeFilterGzip::zip";
GByteArray *actual, *expected;
GMimeStream *stream;
GMimeFilter *filter;
testsuite_check ("%s", what);
actual = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (actual);
g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE);
filter = g_mime_filter_gzip_new (GMIME_FILTER_GZIP_MODE_ZIP, 9);
g_mime_filter_gzip_set_filename ((GMimeFilterGZip *) filter, filename);
g_mime_filter_gzip_set_comment ((GMimeFilterGZip *) filter, "This is a comment.");
pump_data_through_filter (filter, path, stream, TRUE, TRUE);
g_mime_filter_reset (filter);
g_object_unref (stream);
g_object_unref (filter);
g_free (path);
path = g_build_filename (datadir, name, NULL);
expected = read_all_bytes (path, FALSE);
g_free (name);
g_free (path);
if (actual->len != 1233 && (actual->len != expected->len || memcmp (actual->data, expected->data, actual->len) != 0)) {
if (actual->len != expected->len)
testsuite_check_failed ("%s failed: streams are not the same length: %u", what, actual->len);
else
testsuite_check_failed ("%s failed: streams do not match", what);
name = g_strdup_printf ("%s.1.gz", filename);
path = g_build_filename (datadir, name, NULL);
g_free (name);
stream = g_mime_stream_fs_open (path, O_WRONLY | O_CREAT | O_TRUNC, 0644, NULL);
g_free (path);
g_mime_stream_write (stream, (const char *) actual->data, actual->len);
g_mime_stream_flush (stream);
g_object_unref (stream);
} else {
testsuite_check_passed ();
}
g_byte_array_free (expected, TRUE);
g_byte_array_free (actual, TRUE);
}
static void
test_charset_conversion (const char *datadir, const char *base, const char *from, const char *to)
{
const char *what = "GMimeFilterCharset";
GByteArray *actual, *expected;
GMimeStream *stream;
GMimeFilter *filter;
char *path, *name;
testsuite_check ("%s (%s %s -> %s)", what, base, from, to);
actual = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (actual);
g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE);
filter = g_mime_filter_charset_new (from, to);
name = g_strdup_printf ("%s.%s.txt", base, from);
path = g_build_filename (datadir, name, NULL);
pump_data_through_filter (filter, path, stream, TRUE, TRUE);
g_mime_filter_reset (filter);
g_object_unref (stream);
g_object_unref (filter);
g_free (path);
g_free (name);
name = g_strdup_printf ("%s.%s.txt", base, to);
path = g_build_filename (datadir, name, NULL);
expected = read_all_bytes (path, TRUE);
g_free (path);
g_free (name);
if (actual->len != expected->len) {
testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u",
what, expected->len, actual->len);
goto error;
}
if (memcmp (actual->data, expected->data, actual->len) != 0) {
testsuite_check_failed ("%s failed: stream contents do not match", what);
goto error;
}
testsuite_check_passed ();
error:
g_byte_array_free (expected, TRUE);
g_byte_array_free (actual, TRUE);
}
static void
test_enriched (const char *datadir, const char *input, const char *output)
{
const char *what = "GMimeFilterEnriched";
GByteArray *actual, *expected;
GMimeStream *stream;
GMimeFilter *filter;
char *path;
testsuite_check ("%s (%s)", what, input);
actual = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (actual);
g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE);
filter = g_mime_filter_enriched_new (0);
path = g_build_filename (datadir, input, NULL);
pump_data_through_filter (filter, path, stream, TRUE, TRUE);
g_mime_filter_reset (filter);
g_object_unref (stream);
g_object_unref (filter);
g_free (path);
path = g_build_filename (datadir, output, NULL);
expected = read_all_bytes (path, TRUE);
g_free (path);
if (actual->len != expected->len) {
testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u",
what, expected->len, actual->len);
printf ("enriched: -->%.*s<--\n", (int) actual->len, (char *) actual->data);
goto error;
}
if (memcmp (actual->data, expected->data, actual->len) != 0) {
testsuite_check_failed ("%s failed: stream contents do not match", what);
goto error;
}
testsuite_check_passed ();
error:
g_byte_array_free (expected, TRUE);
g_byte_array_free (actual, TRUE);
}
static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
{
unsigned char status, BT_CAP[8];
static enum bt_states last_printed = BT_STATE_PRINTME;
int i;
status = BT_STATUS;
bt->nonzero_status |= status;
if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
STATE2TXT,
STATUS2TXT,
bt->timeout,
time);
last_printed = bt->state;
}
/*
* Commands that time out may still (eventually) provide a response.
* This stale response will get in the way of a new response so remove
* it if possible (hopefully during IDLE). Even if it comes up later
* it will be rejected by its (now-forgotten) seq number.
*/
if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) {
drain_BMC2HOST(bt);
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
}
if ((bt->state != BT_STATE_IDLE) &&
(bt->state < BT_STATE_PRINTME)) {
/* check timeout */
bt->timeout -= time;
if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
return error_recovery(bt,
status,
IPMI_TIMEOUT_ERR);
}
switch (bt->state) {
/*
* Idle state first checks for asynchronous messages from another
* channel, then does some opportunistic housekeeping.
*/
case BT_STATE_IDLE:
if (status & BT_SMS_ATN) {
BT_CONTROL(BT_SMS_ATN); /* clear it */
return SI_SM_ATTN;
}
if (status & BT_H_BUSY) /* clear a leftover H_BUSY */
BT_CONTROL(BT_H_BUSY);
/* Read BT capabilities if it hasn't been done yet */
if (!bt->BT_CAP_outreqs)
BT_STATE_CHANGE(BT_STATE_CAPABILITIES_BEGIN,
SI_SM_CALL_WITHOUT_DELAY);
bt->timeout = bt->BT_CAP_req2rsp;
BT_SI_SM_RETURN(SI_SM_IDLE);
case BT_STATE_XACTION_START:
if (status & (BT_B_BUSY | BT_H2B_ATN))
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
if (BT_STATUS & BT_H_BUSY)
BT_CONTROL(BT_H_BUSY); /* force clear */
BT_STATE_CHANGE(BT_STATE_WRITE_BYTES,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_WRITE_BYTES:
if (status & BT_H_BUSY)
BT_CONTROL(BT_H_BUSY); /* clear */
BT_CONTROL(BT_CLR_WR_PTR);
write_all_bytes(bt);
BT_CONTROL(BT_H2B_ATN); /* can clear too fast to catch */
BT_STATE_CHANGE(BT_STATE_WRITE_CONSUME,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_WRITE_CONSUME:
if (status & (BT_B_BUSY | BT_H2B_ATN))
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
BT_STATE_CHANGE(BT_STATE_READ_WAIT,
SI_SM_CALL_WITHOUT_DELAY);
/* Spinning hard can suppress B2H_ATN and force a timeout */
case BT_STATE_READ_WAIT:
if (!(status & BT_B2H_ATN))
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
BT_CONTROL(BT_H_BUSY); /* set */
/*
* Uncached, ordered writes should just proceeed serially but
* some BMCs don't clear B2H_ATN with one hit. Fast-path a
* workaround without too much penalty to the general case.
*/
BT_CONTROL(BT_B2H_ATN); /* clear it to ACK the BMC */
BT_STATE_CHANGE(BT_STATE_CLEAR_B2H,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_CLEAR_B2H:
if (status & BT_B2H_ATN) {
/* keep hitting it */
BT_CONTROL(BT_B2H_ATN);
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
}
BT_STATE_CHANGE(BT_STATE_READ_BYTES,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_READ_BYTES:
if (!(status & BT_H_BUSY))
/* check in case of retry */
BT_CONTROL(BT_H_BUSY);
BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */
i = read_all_bytes(bt); /* true == packet seq match */
BT_CONTROL(BT_H_BUSY); /* NOW clear */
if (!i) /* Not my message */
BT_STATE_CHANGE(BT_STATE_READ_WAIT,
SI_SM_CALL_WITHOUT_DELAY);
bt->state = bt->complete;
return bt->state == BT_STATE_IDLE ? /* where to next? */
SI_SM_TRANSACTION_COMPLETE : /* normal */
SI_SM_CALL_WITHOUT_DELAY; /* Startup magic */
case BT_STATE_LONG_BUSY: /* For example: after FW update */
if (!(status & BT_B_BUSY)) {
reset_flags(bt); /* next state is now IDLE */
bt_init_data(bt, bt->io);
}
return SI_SM_CALL_WITH_DELAY; /* No repeat printing */
case BT_STATE_RESET1:
reset_flags(bt);
drain_BMC2HOST(bt);
BT_STATE_CHANGE(BT_STATE_RESET2,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_RESET2: /* Send a soft reset */
BT_CONTROL(BT_CLR_WR_PTR);
HOST2BMC(3); /* number of bytes following */
HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */
HOST2BMC(42); /* Sequence number */
HOST2BMC(3); /* Cmd == Soft reset */
BT_CONTROL(BT_H2B_ATN);
bt->timeout = BT_RESET_DELAY * 1000000;
BT_STATE_CHANGE(BT_STATE_RESET3,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_RESET3: /* Hold off everything for a bit */
if (bt->timeout > 0)
return SI_SM_CALL_WITH_DELAY;
drain_BMC2HOST(bt);
BT_STATE_CHANGE(BT_STATE_RESTART,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_RESTART: /* don't reset retries or seq! */
bt->read_count = 0;
bt->nonzero_status = 0;
bt->timeout = bt->BT_CAP_req2rsp;
BT_STATE_CHANGE(BT_STATE_XACTION_START,
SI_SM_CALL_WITH_DELAY);
/*
* Get BT Capabilities, using timing of upper level state machine.
* Set outreqs to prevent infinite loop on timeout.
*/
case BT_STATE_CAPABILITIES_BEGIN:
bt->BT_CAP_outreqs = 1;
{
unsigned char GetBT_CAP[] = { 0x18, 0x36 };
bt->state = BT_STATE_IDLE;
bt_start_transaction(bt, GetBT_CAP, sizeof(GetBT_CAP));
}
bt->complete = BT_STATE_CAPABILITIES_END;
BT_STATE_CHANGE(BT_STATE_XACTION_START,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_CAPABILITIES_END:
i = bt_get_result(bt, BT_CAP, sizeof(BT_CAP));
bt_init_data(bt, bt->io);
if ((i == 8) && !BT_CAP[2]) {
bt->BT_CAP_outreqs = BT_CAP[3];
bt->BT_CAP_req2rsp = BT_CAP[6] * 1000000;
bt->BT_CAP_retries = BT_CAP[7];
} else
printk(KERN_WARNING "IPMI BT: using default values\n");
if (!bt->BT_CAP_outreqs)
bt->BT_CAP_outreqs = 1;
printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n",
bt->BT_CAP_req2rsp / 1000000L, bt->BT_CAP_retries);
bt->timeout = bt->BT_CAP_req2rsp;
return SI_SM_CALL_WITHOUT_DELAY;
default: /* should never occur */
return error_recovery(bt,
status,
IPMI_ERR_UNSPECIFIED);
}
return SI_SM_CALL_WITH_DELAY;
}
static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
{
unsigned char status;
char buf[40]; /* For getting status */
int i;
status = BT_STATUS;
bt->nonzero_status |= status;
if ((bt_debug & BT_DEBUG_STATES) && (bt->state != bt->last_state))
printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
STATE2TXT,
STATUS2TXT(buf),
bt->timeout,
time);
bt->last_state = bt->state;
if (bt->state == BT_STATE_HOSED) return SI_SM_HOSED;
if (bt->state != BT_STATE_IDLE) { /* do timeout test */
/* Certain states, on error conditions, can lock up a CPU
because they are effectively in an infinite loop with
CALL_WITHOUT_DELAY (right back here with time == 0).
Prevent infinite lockup by ALWAYS decrementing timeout. */
/* FIXME: bt_event is sometimes called with time > BT_NORMAL_TIMEOUT
(noticed in ipmi_smic_sm.c January 2004) */
if ((time <= 0) || (time >= BT_NORMAL_TIMEOUT)) time = 100;
bt->timeout -= time;
if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1)) {
error_recovery(bt, "timed out");
return SI_SM_CALL_WITHOUT_DELAY;
}
}
switch (bt->state) {
case BT_STATE_IDLE: /* check for asynchronous messages */
if (status & BT_SMS_ATN) {
BT_CONTROL(BT_SMS_ATN); /* clear it */
return SI_SM_ATTN;
}
return SI_SM_IDLE;
case BT_STATE_XACTION_START:
if (status & BT_H_BUSY) {
BT_CONTROL(BT_H_BUSY);
break;
}
if (status & BT_B2H_ATN) break;
bt->state = BT_STATE_WRITE_BYTES;
return SI_SM_CALL_WITHOUT_DELAY; /* for logging */
case BT_STATE_WRITE_BYTES:
if (status & (BT_B_BUSY | BT_H2B_ATN)) break;
BT_CONTROL(BT_CLR_WR_PTR);
write_all_bytes(bt);
BT_CONTROL(BT_H2B_ATN); /* clears too fast to catch? */
bt->state = BT_STATE_WRITE_CONSUME;
return SI_SM_CALL_WITHOUT_DELAY; /* it MIGHT sail through */
case BT_STATE_WRITE_CONSUME: /* BMCs usually blow right thru here */
if (status & (BT_H2B_ATN | BT_B_BUSY)) break;
bt->state = BT_STATE_B2H_WAIT;
/* fall through with status */
/* Stay in BT_STATE_B2H_WAIT until a packet matches. However, spinning
hard here, constantly reading status, seems to hold off the
generation of B2H_ATN so ALWAYS return CALL_WITH_DELAY. */
case BT_STATE_B2H_WAIT:
if (!(status & BT_B2H_ATN)) break;
/* Assume ordered, uncached writes: no need to wait */
if (!(status & BT_H_BUSY)) BT_CONTROL(BT_H_BUSY); /* set */
BT_CONTROL(BT_B2H_ATN); /* clear it, ACK to the BMC */
BT_CONTROL(BT_CLR_RD_PTR); /* reset the queue */
i = read_all_bytes(bt);
BT_CONTROL(BT_H_BUSY); /* clear */
if (!i) break; /* Try this state again */
bt->state = BT_STATE_READ_END;
return SI_SM_CALL_WITHOUT_DELAY; /* for logging */
case BT_STATE_READ_END:
/* I could wait on BT_H_BUSY to go clear for a truly clean
exit. However, this is already done in XACTION_START
and the (possible) extra loop/status/possible wait affects
performance. So, as long as it works, just ignore H_BUSY */
#ifdef MAKE_THIS_TRUE_IF_NECESSARY
if (status & BT_H_BUSY) break;
#endif
bt->seq++;
bt->state = BT_STATE_IDLE;
return SI_SM_TRANSACTION_COMPLETE;
case BT_STATE_RESET1:
reset_flags(bt);
bt->timeout = BT_RESET_DELAY;
bt->state = BT_STATE_RESET2;
break;
case BT_STATE_RESET2: /* Send a soft reset */
BT_CONTROL(BT_CLR_WR_PTR);
HOST2BMC(3); /* number of bytes following */
HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */
HOST2BMC(42); /* Sequence number */
HOST2BMC(3); /* Cmd == Soft reset */
BT_CONTROL(BT_H2B_ATN);
bt->state = BT_STATE_RESET3;
break;
case BT_STATE_RESET3:
if (bt->timeout > 0) return SI_SM_CALL_WITH_DELAY;
bt->state = BT_STATE_RESTART; /* printk in debug modes */
break;
case BT_STATE_RESTART: /* don't reset retries! */
bt->write_data[2] = ++bt->seq;
bt->read_count = 0;
bt->nonzero_status = 0;
bt->timeout = BT_NORMAL_TIMEOUT;
bt->state = BT_STATE_XACTION_START;
break;
default: /* HOSED is supposed to be caught much earlier */
error_recovery(bt, "internal logic error");
break;
}
return SI_SM_CALL_WITH_DELAY;
}
static void
test_gunzip (const char *datadir, const char *filename)
{
char *name = g_strdup_printf ("%s.gz", filename);
char *path = g_build_filename (datadir, name, NULL);
const char *what = "GMimeFilterGzip::unzip";
GByteArray *actual, *expected;
GMimeStream *stream;
GMimeFilter *filter;
const char *value;
testsuite_check ("%s", what);
actual = g_byte_array_new ();
stream = g_mime_stream_mem_new_with_byte_array (actual);
g_mime_stream_mem_set_owner ((GMimeStreamMem *) stream, FALSE);
filter = g_mime_filter_gzip_new (GMIME_FILTER_GZIP_MODE_UNZIP, 9);
pump_data_through_filter (filter, path, stream, FALSE, TRUE);
g_object_unref (stream);
g_free (path);
g_free (name);
path = g_build_filename (datadir, filename, NULL);
expected = read_all_bytes (path, TRUE);
g_free (path);
if (actual->len != expected->len) {
testsuite_check_failed ("%s failed: stream lengths do not match: expected=%u; actual=%u",
what, expected->len, actual->len);
goto error;
}
if (memcmp (actual->data, expected->data, actual->len) != 0) {
testsuite_check_failed ("%s failed: stream contents do not match", what);
goto error;
}
value = g_mime_filter_gzip_get_filename ((GMimeFilterGZip *) filter);
if (!value || strcmp (value, filename) != 0) {
testsuite_check_failed ("%s failed: filename does not match: %s", what, value);
goto error;
}
value = g_mime_filter_gzip_get_comment ((GMimeFilterGZip *) filter);
if (!value || strcmp (value, "This is a comment.") != 0) {
testsuite_check_failed ("%s failed: comment does not match: %s", what, value);
goto error;
}
testsuite_check_passed ();
error:
g_byte_array_free (expected, TRUE);
g_byte_array_free (actual, TRUE);
g_mime_filter_reset (filter);
g_object_unref (filter);
}