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 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_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;
}
}
/**
* @brief Starts a document (libxml2 compatibility function)
* @param writer EXI stream returned by xmlNewTextWriterMemory or xmlNewTextWriterFilename
* @param version unused
* @param encoding unused
* @param standalone unused
* @return 0 if success, -1 else
*/
static int xmlTextWriterStartDocument(EXIStream *stream, char *p1, char *p2, char *p3) {
pile_init ();
PRINT ("serialize.startDocument\n");
if (serialize.startDocument(stream))
return -1;
if (g_schemaPtr) {
//printf ("SD schemaPtr\n");
/*
String ns = { "http://uri.etsi.org/m2m", 23 };
String pfx = { "m2m", 3 };
errorCode err = serialize.namespaceDeclaration(stream, ns, pfx, 1);
printf ("namespaceDeclaration ret=%d\n", err);
*/
}
return 0;
}
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;
}
}
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);
}
/**
* Entrée d'une commande (STDIN) et retour d'une réponse appropriée (STDOUT).
* Retourne -1 lors d'une demande de quitter le programme, ou 0 si on continue.
*
* Invite l'utilisateur à entrer des commandes au format postfixe (ex: 3 2 + 5 * =a).
*/
int traitement_commande() {
printf("> ");
char* entree = entreeDynamique(stdin);
if(entree == NULL) {
printf("Pas assez de mémoire pour allouer l'entrée.\n");
return 0;
}
if(strcmp(entree, "\0") == 0) {
// Si l'utilisateur quitte ou entre une ligne vide.
free(entree);
return -1;
}
// Les différentes parties sont séparées par des espaces.
char* partie = strtok(entree, " ");
// Pile des commandes entrées, une fois exécutées.
pile* commandes = malloc(sizeof(pile));
if(commandes == NULL) {
printf("Entrée invalide. La mémoire maximale a été dépassée.\n");
free(entree);
return 0;
}
pile_init(commandes);
do {
if(strcmp(partie, "+") == 0 || strcmp(partie, "-") == 0 || strcmp(partie, "*") == 0) {
if(pile_count(commandes) >= 2) {
num* r;
num* b = pile_pop(commandes);
num* a = pile_pop(commandes);
if(strcmp(partie, "+") == 0) {
r = addition(a, b, a->positif, b->positif);
} else if(strcmp(partie, "-") == 0) {
r = soustraction(a, b, a->positif, b->positif);
} else if(strcmp(partie, "*") == 0) {
r = multiplication(a, b);
}
if(r == NULL) {
printf("Mauvais calcul !\n");
superFree(a);
superFree(b);
free(entree);
free(commandes);
return 0;
}
pile_push(commandes, r);
} else {
printf("Erreur: il manque une entree pour faire une operation !\n");
free(entree);
free(commandes);
return 0;
}
} else if(partie[0] == '=' && strlen(partie) == 2 && partie[1] >= 'a' && partie[1] <= 'z') {
// Assignation de variable, on assigne et on continue comme si de rien n'était.
if(pile_count(commandes) > 0) {
variables[(int) partie[1] % 32] = pile_peek(commandes);
} else {
printf("Que voulez-vous assigner ? Il manque quelque chose...\n");
free(entree);
free(commandes);
return 0;
}
} else if(strlen(partie) == 1 && partie[0] >= 'a' && partie[0] <= 'z') {
// Variable, on met sa valeur dans la pile d'opérations.
if(variables[(int) partie[0] % 32] != NULL) {
pile_push(commandes, variables[(int) partie[0] % 32]);
} else {
printf("La variable '%c' n'est pas encore définie.\n", partie[0]);
free(commandes);
free(entree);
return 0;
}
} else {
int est_un_nombre = 1;
int i = 0;
while(i < strlen(partie)) {
if(partie[i] < '0' || partie[i] > '9') {
est_un_nombre = 0;
break;
}
i++;
}
if(est_un_nombre == 1) {
// Valeur, on la met dans un nombre à précision infinie et on met sa référence dans la pile.
num* valeur = malloc(sizeof(num));
if(valeur == NULL) {
printf("Entrée invalide. La mémoire maximale a été dépassée.\n");
free(entree);
free(commandes);
return 0;
}
strToBigNum(partie, valeur);
pile_push(commandes, valeur);
} else {
// Caractère non-valide.
printf("Les éléments doivent tous être des variables (a-z, minuscule), des opérateurs ou bien des valeurs positives entières.\n");
return 0;
}
}
} while(partie = strtok(NULL, " "));
if(partie != NULL) {
free(partie);
}
if(entree != NULL) {
free(entree);
}
if(pile_count(commandes) == 1) {
printNum(pile_pop(commandes));
} else {
printf("Erreur de syntaxe, veuillez completer vos calculs !\n");
}
free(commandes->data);
free(commandes);
return 0;
}
int messtest(const struct messtest_options *opts, int *test_count, int *failure_count)
{
char saved_directory[1024];
FILE *file;
int result = -1;
char *script_directory;
xml_parse_options parse_options;
xml_parse_error parse_error;
xml_data_node *root_node;
xml_data_node *tests_node;
mess_pile pile;
const char *xml;
size_t sz;
char buf[256];
*test_count = 0;
*failure_count = 0;
pile_init(&pile);
/* open the script file */
file = fopen(opts->script_filename, "r");
if (!file)
{
fprintf(stderr, "%s: Cannot open file\n", opts->script_filename);
goto done;
}
/* read the file */
while(!feof(file))
{
sz = fread(buf, 1, sizeof(buf), file);
pile_write(&pile, buf, sz);
}
pile_writebyte(&pile, '\0', 1);
xml = (const char *) pile_getptr(&pile);
/* save the current working directory, and change to the test directory */
saved_directory[0] = '\0';
if (!opts->preserve_directory)
{
script_directory = osd_dirname(opts->script_filename);
if (script_directory)
{
osd_getcurdir(saved_directory, sizeof(saved_directory) / sizeof(saved_directory[0]));
osd_setcurdir(script_directory);
free(script_directory);
}
}
/* set up parse options */
memset(&parse_options, 0, sizeof(parse_options));
parse_options.init_parser = parse_init;
parse_options.flags = XML_PARSE_FLAG_WHITESPACE_SIGNIFICANT;
parse_options.error = &parse_error;
/* do the parse */
root_node = xml_string_read(xml, &parse_options);
if (!root_node)
{
fprintf(stderr, "%s:%d:%d: %s\n",
opts->script_filename,
parse_error.error_line,
parse_error.error_column,
parse_error.error_message);
goto done;
}
/* find the tests node */
tests_node = xml_get_sibling(root_node->child, "tests");
if (!tests_node)
goto done;
node_tests(tests_node, test_count, failure_count);
result = 0;
done:
/* restore the directory */
if (saved_directory[0])
osd_setcurdir(saved_directory);
pile_delete(&pile);
return result;
}
void node_testzippath(xml_data_node *node)
{
xml_attribute_node *attr_node;
xml_data_node *first_child_node;
xml_data_node *child_node;
const char *path;
const char *plus;
astring *apath = NULL;
zippath_directory *directory = NULL;
const osd_directory_entry *dirent;
const char *type_string;
file_error err;
UINT64 size;
mess_pile pile;
core_file *file = NULL;
pile_init(&pile);
/* name the test case */
report_testcase_begin("zippath");
/* retrieve path */
attr_node = xml_get_attribute(node, "path");
path = (attr_node != NULL) ? attr_node->value : "";
/* retrieve 'plus' - for testing zippath_combine */
attr_node = xml_get_attribute(node, "plus");
if (attr_node != NULL)
{
plus = attr_node->value;
apath = zippath_combine(astring_alloc(), path, plus);
report_message(MSG_INFO, "Testing ZIP Path '%s' + '%s' ==> '%s'", path, plus, astring_c(apath));
}
else
{
apath = astring_cpyc(astring_alloc(), path);
report_message(MSG_INFO, "Testing ZIP Path '%s'", astring_c(apath));
}
/* try doing a file compare */
messtest_get_data(node, &pile);
if (pile_size(&pile) > 0)
{
err = zippath_fopen(astring_c(apath), OPEN_FLAG_READ, &file, NULL);
if (err != FILERR_NONE)
{
report_message(MSG_FAILURE, "Error %d opening file", (int) err);
goto done;
}
if (pile_size(&pile) != core_fsize(file))
{
report_message(MSG_FAILURE, "Expected file to be of length %d, instead got %d", (int) pile_size(&pile), (int) core_fsize(file));
goto done;
}
if (memcmp(pile_getptr(&pile), core_fbuffer(file), pile_size(&pile)))
{
report_message(MSG_FAILURE, "File sizes match, but contents do not");
goto done;
}
}
/* try doing a directory listing */
first_child_node = xml_get_sibling(node->child, "entry");
if (first_child_node != NULL)
{
err = zippath_opendir(astring_c(apath), &directory);
if (err != FILERR_NONE)
{
report_message(MSG_FAILURE, "Error %d opening directory", (int) err);
goto done;
}
/* read each directory entry */
while((dirent = zippath_readdir(directory)) != NULL)
{
/* find it in the list */
for (child_node = first_child_node; child_node != NULL; child_node = xml_get_sibling(child_node->next, "entry"))
{
attr_node = xml_get_attribute(child_node, "name");
if ((attr_node != NULL) && !strcmp(attr_node->value, dirent->name))
break;
}
/* did we find the node? */
if (child_node != NULL)
{
/* check dirent type */
attr_node = xml_get_attribute(child_node, "type");
if (attr_node != NULL)
{
type_string = dir_entry_type_string(dirent->type);
if (mame_stricmp(attr_node->value, type_string))
report_message(MSG_FAILURE, "Expected '%s' to be '%s', but instead got '%s'", dirent->name, attr_node->value, type_string);
}
/* check size */
attr_node = xml_get_attribute(child_node, "size");
if (attr_node != NULL)
{
size = atoi(attr_node->value);
if (size != dirent->size)
report_message(MSG_FAILURE, "Expected '%s' to be of size '%ld', but instead got '%ld'", dirent->name, (long) size, (long) dirent->size);
}
}
else
{
report_message(MSG_FAILURE, "Unexpected directory entry '%s'", dirent->name);
}
}
}
done:
pile_delete(&pile);
if (apath != NULL)
astring_free(apath);
if (file != NULL)
core_fclose(file);
if (directory != NULL)
zippath_closedir(directory);
}