static void command_image_loadcreate(running_machine &machine)
{
device_image_interface *image;
const char *filename;
const char *format_name;
char buf[128];
const char *file_extensions;
astring *filepath;
int success;
const game_driver *gamedrv;
const image_device_format *format = NULL;
/* look up the image slot */
image = find_device_by_identity(machine, ¤t_command->u.image_args.device_ident);
if (image == NULL)
return;
file_extensions = image->image_config().file_extensions();
/* is an image format specified? */
format_name = current_command->u.image_args.format;
if (format_name != NULL)
{
if (current_command->command_type != MESSTEST_COMMAND_IMAGE_CREATE)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Cannot specify format unless creating");
return;
}
/* look up the format name */
format = image->device_get_named_creatable_format(format_name);
if (format == NULL)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Unknown device format '%s'", format_name);
return;
}
}
/* figure out the filename */
filename = current_command->u.image_args.filename;
if (!filename)
{
snprintf(buf, ARRAY_LENGTH(buf), "%s.%s",
current_testcase.name, file_extensions);
//osd_get_temp_filename(buf, ARRAY_LENGTH(buf), buf);
filename = buf;
}
success = FALSE;
for (gamedrv = machine.system(); !success && gamedrv; gamedrv = driver_get_compatible(gamedrv))
{
/* assemble the full path */
filepath = assemble_software_path(astring_alloc(), gamedrv, filename);
/* actually create or load the image */
switch(current_command->command_type)
{
case MESSTEST_COMMAND_IMAGE_CREATE:
success = (image->create(astring_c(filepath), format, NULL) == IMAGE_INIT_PASS);
break;
case MESSTEST_COMMAND_IMAGE_LOAD:
success = (image->load(astring_c(filepath)) == IMAGE_INIT_PASS);
break;
default:
fatalerror("Unexpected error");
break;
}
astring_free(filepath);
}
if (!success)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Failed to load/create image '%s': %s", filename, image->error());
return;
}
}
static void command_image_loadcreate(void)
{
mess_image *image;
int device_type;
int device_slot;
const char *device_tag;
int i, format_index = 0;
const char *filename;
const char *format;
char buf[128];
const struct IODevice *dev;
const char *file_extensions;
char *filepath;
int success;
const game_driver *gamedrv;
device_slot = current_command->u.image_args.device_slot;
device_type = current_command->u.image_args.device_type;
device_tag = current_command->u.image_args.device_tag;
/* look up the image slot */
if (device_tag)
image = image_from_devtag_and_index(device_tag, device_slot);
else
image = image_from_devtype_and_index(device_type, device_slot);
if (!image)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Image slot '%s %i' does not exist",
device_typename(device_type), device_slot);
return;
}
dev = image_device(image);
file_extensions = dev->file_extensions;
/* is an image format specified? */
format = current_command->u.image_args.format;
if (format)
{
if (current_command->command_type != MESSTEST_COMMAND_IMAGE_CREATE)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Cannot specify format unless creating");
return;
}
if (!dev->createimage_options)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Cannot specify format for device");
return;
}
for (i = 0; dev->createimage_options[i].name; i++)
{
if (!strcmp(format, dev->createimage_options[i].name))
break;
}
if (!dev->createimage_options[i].name)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Unknown device '%s'", format);
return;
}
format_index = i;
file_extensions = dev->createimage_options[i].extensions;
}
/* figure out the filename */
filename = current_command->u.image_args.filename;
if (!filename)
{
snprintf(buf, sizeof(buf) / sizeof(buf[0]), "%s.%s",
current_testcase.name, file_extensions);
osd_get_temp_filename(buf, ARRAY_LENGTH(buf), buf);
filename = buf;
}
success = FALSE;
for (gamedrv = Machine->gamedrv; !success && gamedrv; gamedrv = mess_next_compatible_driver(gamedrv))
{
/* assemble the full path */
filepath = assemble_software_path(gamedrv, filename);
/* actually create or load the image */
switch(current_command->command_type)
{
case MESSTEST_COMMAND_IMAGE_CREATE:
success = (image_create(image, filepath, format_index, NULL) == INIT_PASS);
break;
case MESSTEST_COMMAND_IMAGE_LOAD:
success = (image_load(image, filepath) == INIT_PASS);
break;
default:
fatalerror("Unexpected error");
break;
}
free(filepath);
}
if (!success)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Failed to load/create image '%s': %s", filename, image_error(image));
return;
}
}
static messtest_result_t run_test(int flags, messtest_results *results)
{
const game_driver *driver;
messtest_result_t rc;
clock_t begin_time;
double real_run_time;
astring *fullpath = NULL;
const char *device_opt;
const char *fake_argv[2];
core_options *opts;
/* lookup driver */
driver = driver_get_name(current_testcase.driver);
/* cannot find driver? */
if (driver == NULL)
{
report_message(MSG_FAILURE, "Cannot find driver '%s'", current_testcase.driver);
return MESSTEST_RESULT_STARTFAILURE;
}
/* prepare testing state */
current_command = current_testcase.commands;
state = STATE_READY;
test_flags = flags;
screenshot_num = 0;
runtime_hash = 0;
had_failure = FALSE;
//videoram = NULL;
//videoram_size = 0;
/* set up options */
opts = mame_options_init(win_mess_opts);
options_set_string(opts, OPTION_GAMENAME, driver->name, OPTION_PRIORITY_CMDLINE);
if( current_testcase.bios )
options_set_string(opts, OPTION_BIOS, current_testcase.bios, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_SKIP_GAMEINFO, TRUE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_THROTTLE, FALSE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_DEBUG, FALSE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_DEBUG_INTERNAL, FALSE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_WRITECONFIG, FALSE, OPTION_PRIORITY_CMDLINE);
if (current_testcase.ram != 0)
{
options_set_int(opts, OPTION_RAMSIZE, current_testcase.ram, OPTION_PRIORITY_CMDLINE);
}
/* ugh... hideous ugly fake arguments */
fake_argv[0] = "MESSTEST";
fake_argv[1] = driver->name;
options_parse_command_line(opts, ARRAY_LENGTH(fake_argv), (char **) fake_argv, OPTION_PRIORITY_CMDLINE,TRUE);
/* preload any needed images */
while(current_command->command_type == MESSTEST_COMMAND_IMAGE_PRELOAD)
{
/* get the path */
fullpath = assemble_software_path(astring_alloc(), driver, current_command->u.image_args.filename);
/* get the option name */
device_opt = device_config_image_interface::device_typename(current_command->u.image_args.device_ident.type);
/* set the option */
options_set_string(opts, device_opt, astring_c(fullpath), OPTION_PRIORITY_CMDLINE);
/* cleanup */
astring_free(fullpath);
fullpath = NULL;
/* next command */
current_command++;
}
/* perform the test */
report_message(MSG_INFO, "Beginning test (driver '%s')", current_testcase.driver);
begin_time = clock();
mame_set_output_channel(OUTPUT_CHANNEL_ERROR, messtest_output_error, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_WARNING, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_INFO, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_DEBUG, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_LOG, mame_null_output_callback, NULL, NULL, NULL);
test_osd_interface osd;
mame_execute(osd, opts);
real_run_time = ((double) (clock() - begin_time)) / CLOCKS_PER_SEC;
/* what happened? */
switch(state)
{
case STATE_ABORTED:
report_message(MSG_FAILURE, "Test aborted");
rc = MESSTEST_RESULT_RUNTIMEFAILURE;
break;
case STATE_DONE:
if (had_failure)
{
report_message(MSG_FAILURE, "Test failed (real time %.2f; emu time %.2f [%i%%])",
real_run_time, final_time.as_double(), (int) ((final_time.as_double() / real_run_time) * 100));
rc = MESSTEST_RESULT_RUNTIMEFAILURE;
}
else
{
report_message(MSG_INFO, "Test succeeded (real time %.2f; emu time %.2f [%i%%])",
real_run_time, final_time.as_double(), (int) ((final_time.as_double() / real_run_time) * 100));
rc = MESSTEST_RESULT_SUCCESS;
}
break;
default:
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Abnormal termination");
rc = MESSTEST_RESULT_STARTFAILURE;
break;
}
if (results)
{
results->rc = rc;
results->runtime_hash = runtime_hash;
}
options_free(opts);
return rc;
}
static messtest_result_t run_test(int flags, struct messtest_results *results)
{
int driver_num;
messtest_result_t rc;
clock_t begin_time;
double real_run_time;
char *fullpath = NULL;
/* lookup driver */
for (driver_num = 0; drivers[driver_num]; driver_num++)
{
if (!mame_stricmp(current_testcase.driver, drivers[driver_num]->name))
break;
}
/* cannot find driver? */
if (!drivers[driver_num])
{
report_message(MSG_FAILURE, "Cannot find driver '%s'", current_testcase.driver);
return MESSTEST_RESULT_STARTFAILURE;
}
/* prepare testing state */
current_command = current_testcase.commands;
state = STATE_READY;
test_flags = flags;
screenshot_num = 0;
runtime_hash = 0;
had_failure = FALSE;
seen_first_update = FALSE;
videoram = NULL;
videoram_size = 0;
dirtybuffer = NULL;
/* set up options */
memset(&options, 0, sizeof(options));
options.skip_disclaimer = 1;
options.skip_gameinfo = 1;
options.skip_warnings = 1;
options.disable_normal_ui = 1;
options.ram = current_testcase.ram;
options.samplerate = 44100;
options.mame_debug = 1;
options.brightness = 1.0;
options.contrast = 1.0;
options.gamma = 1.0;
/* preload any needed images */
while(current_command->command_type == MESSTEST_COMMAND_IMAGE_PRELOAD)
{
fullpath = assemble_software_path(drivers[driver_num], current_command->u.image_args.filename);
options.image_files[options.image_count].name = fullpath;
options.image_files[options.image_count].device_type = current_command->u.image_args.device_type;
options.image_files[options.image_count].device_index = -1;
options.image_count++;
current_command++;
}
/* perform the test */
report_message(MSG_INFO, "Beginning test (driver '%s')", current_testcase.driver);
begin_time = clock();
mame_set_output_channel(OUTPUT_CHANNEL_ERROR, messtest_output_error, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_WARNING, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_INFO, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_DEBUG, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_LOG, mame_null_output_callback, NULL, NULL, NULL);
run_game(driver_num);
real_run_time = ((double) (clock() - begin_time)) / CLOCKS_PER_SEC;
/* what happened? */
switch(state)
{
case STATE_ABORTED:
report_message(MSG_FAILURE, "Test aborted");
rc = MESSTEST_RESULT_RUNTIMEFAILURE;
break;
case STATE_DONE:
if (had_failure)
{
report_message(MSG_FAILURE, "Test failed (real time %.2f; emu time %.2f [%i%%])",
real_run_time, final_time, (int) ((final_time / real_run_time) * 100));
rc = MESSTEST_RESULT_RUNTIMEFAILURE;
}
else
{
report_message(MSG_INFO, "Test succeeded (real time %.2f; emu time %.2f [%i%%])",
real_run_time, final_time, (int) ((final_time / real_run_time) * 100));
rc = MESSTEST_RESULT_SUCCESS;
}
break;
default:
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Abnormal termination");
rc = MESSTEST_RESULT_STARTFAILURE;
break;
}
if (results)
{
results->rc = rc;
results->runtime_hash = runtime_hash;
}
if (fullpath)
free(fullpath);
return rc;
}
