static void node_image(xml_data_node *node, messtest_command_type_t command)
{
xml_attribute_node *attr_node;
int preload;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = command;
/* 'preload' attribute */
attr_node = xml_get_attribute(node, "preload");
preload = attr_node ? atoi(attr_node->value) : 0;
if (preload)
new_command.command_type = (messtest_command_type_t) (new_command.command_type + 2);
/* 'filename' attribute */
attr_node = xml_get_attribute(node, "filename");
new_command.u.image_args.filename = attr_node ? attr_node->value : NULL;
/* 'tag', 'type', 'slot' attributes */
if (!get_device_identity_tags(node, &new_command.u.image_args.device_ident))
return;
/* 'format' attribute */
attr_node = xml_get_attribute(node, "format");
new_command.u.image_args.format = attr_node ? attr_node->value : NULL;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_imageverify(xml_data_node *node)
{
void *new_buffer;
mess_pile pile;
/* <imageverify> - verifies that an image contains specific data */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_VERIFY_IMAGE;
/* 'tag', 'type', 'slot' attributes */
if (!get_device_identity_tags(node, &new_command.u.verify_args.device_ident))
return;
pile_init(&pile);
messtest_get_data(node, &pile);
new_buffer = pool_malloc_lib(command_pool, pile_size(&pile));
memcpy(new_buffer, pile_getptr(&pile), pile_size(&pile));
new_command.u.verify_args.verify_data = new_buffer;
new_command.u.verify_args.verify_data_size = pile_size(&pile);
pile_delete(&pile);
if (!append_command())
{
error_outofmemory();
return;
}
}
static void command_end_handler(const void *buffer, size_t size)
{
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_checkfile(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
const char *filename;
const char *fork;
filter_getinfoproc filter;
imgtool_stream *stream = NULL;
UINT64 stream_sz;
const void *stream_ptr;
mess_pile pile;
if (!state->m_partition)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "Partition not loaded");
goto done;
}
get_file_params(node, &filename, &fork, &filter);
if (!filename)
goto done;
stream = stream_open_mem(NULL, 0);
if (!stream)
{
state->m_failed = 1;
error_outofmemory();
goto done;
}
err = imgtool_partition_read_file(state->m_partition, filename, fork, stream, filter);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
goto done;
}
pile_init(&pile);
messtest_get_data(node, &pile);
stream_ptr = stream_getptr(stream);
stream_sz = stream_size(stream);
if ((pile_size(&pile) != stream_sz) || (memcmp(stream_ptr, pile_getptr(&pile), pile_size(&pile))))
{
report_message(MSG_FAILURE, "Failed file verification");
goto done;
}
pile_delete(&pile);
done:
if (stream != NULL)
stream_close(stream);
}
static void node_image(xml_data_node *node, messtest_command_type_t command)
{
xml_attribute_node *attr_node;
const char *s2;
int preload, device_type;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = command;
/* 'preload' attribute */
attr_node = xml_get_attribute(node, "preload");
preload = attr_node ? atoi(attr_node->value) : 0;
if (preload)
new_command.command_type += 2;
/* 'filename' attribute */
attr_node = xml_get_attribute(node, "filename");
new_command.u.image_args.filename = attr_node ? attr_node->value : NULL;
/* 'type' attribute */
attr_node = xml_get_attribute(node, "type");
if (!attr_node)
{
error_missingattribute("type");
return;
}
s2 = attr_node->value;
device_type = device_typeid(s2);
if (device_type < 0)
{
error_baddevicetype(s2);
return;
}
new_command.u.image_args.device_type = device_type;
/* 'slot' attribute */
attr_node = xml_get_attribute(node, "slot");
new_command.u.image_args.device_slot = attr_node ? atoi(attr_node->value) : 0;
/* 'format' attribute */
format_index = 0;
attr_node = xml_get_attribute(node, "format");
new_command.u.image_args.format = attr_node ? attr_node->value : NULL;
/* 'tag' attribute */
attr_node = xml_get_attribute(node, "tag");
new_command.u.image_args.device_tag = attr_node ? attr_node->value : NULL;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_putfile(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
const char *filename;
const char *fork;
filter_getinfoproc filter;
imgtool_stream *stream = NULL;
mess_pile pile;
if (state->m_partition == NULL)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "Partition not loaded");
goto done;
}
get_file_params(node, &filename, &fork, &filter);
if (filename == NULL)
goto done;
pile_init(&pile);
messtest_get_data(node, &pile);
stream = stream_open_mem(NULL, 0);
if (stream == NULL)
{
state->m_failed = 1;
error_outofmemory();
goto done;
}
stream_write(stream, pile_getptr(&pile), pile_size(&pile));
stream_seek(stream, 0, SEEK_SET);
pile_delete(&pile);
err = imgtool_partition_write_file(state->m_partition, filename, fork, stream, NULL, filter);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
goto done;
}
if (VERBOSE_FILECHAIN)
{
char buf[1024];
err = imgtool_partition_get_chain_string(state->m_partition, filename, buf, ARRAY_LENGTH(buf));
if (err == IMGTOOLERR_SUCCESS)
report_message(MSG_INFO, "Filechain '%s': %s", filename, buf);
}
done:
if (stream != NULL)
stream_close(stream);
}
static void node_memverify(xml_data_node *node)
{
xml_attribute_node *attr_node;
const char *s1;
const char *s2;
const char *s3;
int region;
void *new_buffer;
mess_pile pile;
/* <memverify> - verifies that a range of memory contains specific data */
attr_node = xml_get_attribute(node, "start");
s1 = attr_node ? attr_node->value : NULL;
if (!s1)
{
error_missingattribute("start");
return;
}
attr_node = xml_get_attribute(node, "end");
s2 = attr_node ? attr_node->value : NULL;
if (!s2)
s2 = "0";
attr_node = xml_get_attribute(node, "region");
s3 = attr_node ? attr_node->value : NULL;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_VERIFY_MEMORY;
new_command.u.verify_args.start = parse_offset(s1);
new_command.u.verify_args.end = parse_offset(s2);
if (s3)
{
region = memory_region_from_string(s3);
if (region == REGION_INVALID)
error_invalidmemregion(s3);
new_command.u.verify_args.mem_region = region;
}
pile_init(&pile);
messtest_get_data(node, &pile);
new_buffer = pool_malloc(&command_pool, pile_size(&pile));
memcpy(new_buffer, pile_getptr(&pile), pile_size(&pile));
new_command.u.verify_args.verify_data = new_buffer;
new_command.u.verify_args.verify_data_size = pile_size(&pile);
pile_delete(&pile);
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_rawinput(xml_data_node *node)
{
/* <rawinput> - inputs raw data into a system */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_RAWINPUT;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_hard_reset(xml_data_node *node)
{
/* <hardreset> - perform a hard reset */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_HARD_RESET;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_checkblank(xml_data_node *node)
{
/* <checkblank> - checks to see if the screen is blank */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_CHECKBLANK;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_screenshot(xml_data_node *node)
{
/* <screenshot> - dumps a screenshot */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_SCREENSHOT;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_trace(xml_data_node *node)
{
/* <trace> - emit a trace file */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_TRACE;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void verify_end_handler(const void *buffer, size_t size)
{
void *new_buffer;
new_buffer = pool_malloc(&command_pool, size);
memcpy(new_buffer, buffer, size);
new_command.u.verify_args.verify_data = new_buffer;
new_command.u.verify_args.verify_data_size = size;
command_end_handler(NULL, 0);
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_input(xml_data_node *node)
{
/* <input> - inputs natural keyboard data into a system */
xml_attribute_node *attr_node;
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_INPUT;
attr_node = xml_get_attribute(node, "rate");
new_command.u.input_args.rate = atof(attr_node->value);
new_command.u.input_args.input_chars = node->value;
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_imageverify(xml_data_node *node)
{
xml_attribute_node *attr_node;
const char *s;
iodevice_t device_type;
void *new_buffer;
mess_pile pile;
/* <imageverify> - verifies that an image contains specific data */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_VERIFY_IMAGE;
/* 'type' attribute */
attr_node = xml_get_attribute(node, "type");
s = attr_node ? attr_node->value : NULL;
if (!s)
{
error_missingattribute("type");
return;
}
device_type = device_typeid(s);
if (device_type < 0)
{
error_baddevicetype(s);
return;
}
new_command.u.verify_args.device_type = device_type;
pile_init(&pile);
messtest_get_data(node, &pile);
new_buffer = pool_malloc(&command_pool, pile_size(&pile));
memcpy(new_buffer, pile_getptr(&pile), pile_size(&pile));
new_command.u.verify_args.verify_data = new_buffer;
new_command.u.verify_args.verify_data_size = pile_size(&pile);
pile_delete(&pile);
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_wait(xml_data_node *node)
{
xml_attribute_node *attr_node;
attr_node = xml_get_attribute(node, "time");
if (!attr_node)
{
error_missingattribute("time");
return;
}
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_WAIT;
new_command.u.wait_time = mame_time_to_double(parse_time(attr_node->value));
if (!append_command())
{
error_outofmemory();
return;
}
}
static void node_switch(xml_data_node *node)
{
xml_attribute_node *attr_node;
const char *s1;
const char *s2;
/* <switch> - switches a DIP switch/config setting */
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_SWITCH;
/* 'name' attribute */
attr_node = xml_get_attribute(node, "name");
if (!attr_node)
{
error_missingattribute("name");
return;
}
s1 = attr_node->value;
/* 'value' attribute */
attr_node = xml_get_attribute(node, "value");
if (!attr_node)
{
error_missingattribute("value");
return;
}
s2 = attr_node->value;
new_command.u.switch_args.name = s1;
new_command.u.switch_args.value = s2;
if (!append_command())
{
error_outofmemory();
return;
}
}
void node_testmess(xml_data_node *node)
{
xml_data_node *child_node;
xml_attribute_node *attr_node;
int result;
pile_init(&command_pile);
pool_init(&command_pool);
memset(&new_command, 0, sizeof(new_command));
command_count = 0;
/* 'driver' attribute */
attr_node = xml_get_attribute(node, "driver");
if (!attr_node)
{
error_missingattribute("driver");
return;
}
current_testcase.driver = attr_node->value;
/* 'name' attribute */
attr_node = xml_get_attribute(node, "name");
current_testcase.name = attr_node ? attr_node->value : current_testcase.driver;
/* 'ramsize' attribute */
attr_node = xml_get_attribute(node, "ramsize");
current_testcase.ram = attr_node ? ram_parse_string(attr_node->value) : 0;
/* 'wavwrite' attribute */
attr_node = xml_get_attribute(node, "wavwrite");
current_testcase.wavwrite = attr_node && (atoi(attr_node->value) != 0);
/* report the beginning of the test case */
report_testcase_begin(current_testcase.name);
current_testcase.commands = NULL;
for (child_node = node->child; child_node; child_node = child_node->next)
{
if (!strcmp(child_node->name, "wait"))
node_wait(child_node);
else if (!strcmp(child_node->name, "input"))
node_input(child_node);
else if (!strcmp(child_node->name, "rawinput"))
node_rawinput(child_node);
else if (!strcmp(child_node->name, "switch"))
node_switch(child_node);
else if (!strcmp(child_node->name, "screenshot"))
node_screenshot(child_node);
else if (!strcmp(child_node->name, "checkblank"))
node_checkblank(child_node);
else if (!strcmp(child_node->name, "imagecreate"))
node_imagecreate(child_node);
else if (!strcmp(child_node->name, "imageload"))
node_imageload(child_node);
else if (!strcmp(child_node->name, "memverify"))
node_memverify(child_node);
else if (!strcmp(child_node->name, "imageverify"))
node_imageverify(child_node);
else if (!strcmp(child_node->name, "trace"))
node_trace(child_node);
}
memset(&new_command, 0, sizeof(new_command));
new_command.command_type = MESSTEST_COMMAND_END;
if (!append_command())
{
error_outofmemory();
return;
}
result = run_test(0, NULL);
report_testcase_ran(result);
pile_delete(&command_pile);
pool_exit(&command_pool);
}
