00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include <stdio.h>
00027 #include <stdlib.h>
00028 #include <getopt.h>
00029 #include <errno.h>
00030 #include <string.h>
00031
00032 #include <libxml/xmlreader.h>
00033 #include <libxml/xmlschemas.h>
00034
00035 #include "testrunnerlite.h"
00036 #include "testdefinitiondatatypes.h"
00037 #include "testdefinitionparser.h"
00038 #include "log.h"
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 LOCAL td_parser_callbacks *cbs;
00066 LOCAL xmlTextReaderPtr reader;
00067 LOCAL xmlSchemaParserCtxtPtr schema_context = NULL;
00068 LOCAL xmlSchemaPtr schema = NULL;
00069 LOCAL td_td *current_td;
00070 LOCAL td_suite *current_suite;
00071 LOCAL td_set *current_set;
00072 LOCAL int parsing_level = 0;
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084 LOCAL int td_parse_gen_attribs (td_gen_attribs *,td_gen_attribs *);
00085
00086 LOCAL int td_parse_td (void);
00087
00088 LOCAL int td_parse_suite (void);
00089
00090 LOCAL int td_parse_steps (xmlListPtr, const char *);
00091
00092 LOCAL td_step *td_parse_step (int manual_default);
00093
00094 LOCAL int td_parse_case (td_set *s);
00095
00096 LOCAL int td_parse_environments(xmlListPtr);
00097
00098 LOCAL int td_parse_gets(xmlListPtr);
00099
00100 LOCAL int td_parse_set ();
00101
00102 LOCAL int td_parse_hwiddetect ();
00103
00104
00105
00106
00107
00108
00109
00110 LOCAL int td_parse_gen_attribs (td_gen_attribs *attr,
00111 td_gen_attribs *defaults)
00112 {
00113 const xmlChar *name;
00114
00115 if (defaults) {
00116 attr->timeout = defaults->timeout;
00117 attr->manual = defaults->manual;
00118 attr->insignificant = defaults->insignificant;
00119 if (defaults->requirement)
00120 attr->requirement = xmlStrdup(defaults->requirement);
00121 if (defaults->level)
00122 attr->level = xmlStrdup(defaults->level);
00123 if (defaults->type)
00124 attr->type = xmlStrdup(defaults->type);
00125 if (defaults->hwid)
00126 attr->hwid = xmlStrdup(defaults->hwid);
00127 if (defaults->component)
00128 attr->component = xmlStrdup(defaults->component);
00129 if (defaults->feature)
00130 attr->feature = xmlStrdup(defaults->feature);
00131 if (defaults->domain)
00132 attr->domain = xmlStrdup(defaults->domain);
00133 }
00134
00135 while (xmlTextReaderMoveToNextAttribute(reader)) {
00136 name = xmlTextReaderConstName(reader);
00137 if (!xmlStrcmp (name, BAD_CAST "name")) {
00138 attr->name = xmlTextReaderValue(reader);
00139 continue;
00140 }
00141 if (!xmlStrcmp (name, BAD_CAST "timeout")) {
00142 attr->timeout = strtoul((char *)
00143 xmlTextReaderConstValue(reader),
00144 NULL, 10);
00145 continue;
00146 }
00147 if (!xmlStrcmp (name, BAD_CAST "description")) {
00148 attr->description = xmlTextReaderValue(reader);
00149 continue;
00150 }
00151 if (!xmlStrcmp (name, BAD_CAST "requirement")) {
00152 if (attr->requirement) free (attr->requirement);
00153 attr->requirement = xmlTextReaderValue(reader);
00154 continue;
00155 }
00156 if (!xmlStrcmp (name, BAD_CAST "type")) {
00157 if (attr->type) free (attr->type);
00158 attr->type = xmlTextReaderValue(reader);
00159 continue;
00160 }
00161 if (!xmlStrcmp (name, BAD_CAST "level")) {
00162 if (attr->level) free (attr->level);
00163 attr->level = xmlTextReaderValue(reader);
00164 continue;
00165 }
00166 if (!xmlStrcmp (name, BAD_CAST "domain")) {
00167 if (attr->domain) free (attr->domain);
00168 attr->domain = xmlTextReaderValue(reader);
00169 continue;
00170 }
00171 if (!xmlStrcmp (name, BAD_CAST "feature")) {
00172 if (attr->feature) free (attr->feature);
00173 attr->feature = xmlTextReaderValue(reader);
00174 continue;
00175 }
00176 if (!xmlStrcmp (name, BAD_CAST "component")) {
00177 if (attr->component) free (attr->component);
00178 attr->component = xmlTextReaderValue(reader);
00179 continue;
00180 }
00181 if (!xmlStrcmp (name, BAD_CAST "manual")) {
00182 attr->manual = !xmlStrcmp (xmlTextReaderConstValue
00183 (reader), BAD_CAST "true");
00184 continue;
00185 }
00186 if (!xmlStrcmp (name, BAD_CAST "insignificant")) {
00187 attr->insignificant =
00188 !xmlStrcmp (xmlTextReaderConstValue (reader),
00189 BAD_CAST "true");
00190 continue;
00191 }
00192 if (!xmlStrcmp (name, BAD_CAST "hwid")) {
00193 if (attr->hwid)
00194 free (attr->hwid);
00195 attr->hwid = xmlTextReaderValue(reader);
00196 continue;
00197 }
00198 }
00199 xmlTextReaderMoveToElement (reader);
00200
00201 return 0;
00202 }
00203
00207 LOCAL td_step *td_parse_step(int manual_default)
00208 {
00209 const xmlChar *name;
00210 td_step *step = NULL;
00211 xmlNodePtr node;
00212 int ret;
00213
00214 step = td_step_create();
00215 step->manual = manual_default;
00216
00217 while (xmlTextReaderMoveToNextAttribute(reader)) {
00218 name = xmlTextReaderConstName(reader);
00219 if (!xmlStrcmp (name, BAD_CAST "expected_result")) {
00220 step->expected_result =
00221 strtoul((char *)xmlTextReaderConstValue(reader),
00222 NULL, 10);
00223 step->has_expected_result = 1;
00224
00225 continue;
00226 }
00227 if (!xmlStrcmp (name, BAD_CAST "manual")) {
00228 step->manual = !xmlStrcmp (xmlTextReaderConstValue
00229 (reader), BAD_CAST "true");
00230 continue;
00231 }
00232 }
00233
00234 do {
00235 ret = xmlTextReaderRead(reader);
00236 if (!ret) {
00237 LOG_MSG (LOG_ERR, "%s:%s: ReaderRead() fail\n",
00238 PROGNAME, __FUNCTION__);
00239
00240 goto ERROUT;
00241 }
00242 name = xmlTextReaderConstName(reader);
00243 if (!name) {
00244 LOG_MSG (LOG_ERR, "%s: ReaderName() fail\n",
00245 PROGNAME);
00246 goto ERROUT;
00247 }
00248
00249 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT) {
00250 if (step->step)
00251 step->step = xmlStrcat
00252 (step->step,
00253 xmlTextReaderReadString (reader));
00254 else
00255 step->step = xmlTextReaderReadString (reader);
00256 }
00257
00258 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_CDATA) {
00259 node = xmlTextReaderCurrentNode (reader);
00260 if (step->step)
00261 step->step = xmlStrcat
00262 (step->step,
00263 node->content);
00264 else
00265 step->step = xmlStrdup(node->content);
00266
00267 }
00268
00269 } while (!(xmlTextReaderNodeType(reader) ==
00270 XML_READER_TYPE_END_ELEMENT &&
00271 !xmlStrcmp (name, BAD_CAST "step")));
00272
00273 return step;
00274 ERROUT:
00275 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00276 PROGNAME, __FUNCTION__);
00277 free (step);
00278
00279 return NULL;
00280 }
00281
00287 LOCAL int td_parse_steps(xmlListPtr list, const char *tag)
00288 {
00289 const xmlChar *name;
00290 td_steps *steps = NULL;
00291 td_step *step = NULL;
00292 int ret;
00293
00294 steps = td_steps_create();
00295
00296 if (!steps) {
00297 goto ERROUT;
00298 }
00299
00300 if (xmlTextReaderMoveToAttribute (reader, BAD_CAST "timeout") == 1) {
00301 steps->timeout = strtoul((char *)
00302 xmlTextReaderConstValue(reader),
00303 NULL, 10);
00304 }
00305
00306 do {
00307 ret = xmlTextReaderRead(reader);
00308 if (!ret) {
00309 LOG_MSG (LOG_ERR, "%s: ReaderRead() fail\n",
00310 PROGNAME);
00311 goto ERROUT;
00312 }
00313
00314 name = xmlTextReaderConstName(reader);
00315 if (!name) {
00316 LOG_MSG (LOG_ERR, "%s: ReaderName() fail\n",
00317 PROGNAME);
00318 goto ERROUT;
00319 }
00320
00321 if (xmlTextReaderNodeType(reader) ==
00322 XML_READER_TYPE_ELEMENT &&
00323 !xmlStrcmp (name, BAD_CAST "step")) {
00324 step = td_parse_step (current_set->gen.manual);
00325 if (!step)
00326 goto ERROUT;
00327 if (xmlListAppend (steps->steps, step)) {
00328 LOG_MSG (LOG_ERR, "%s: list insert failed\n",
00329 PROGNAME);
00330 goto ERROUT;
00331 }
00332 }
00333 } while (!(xmlTextReaderNodeType(reader) ==
00334 XML_READER_TYPE_END_ELEMENT &&
00335 !xmlStrcmp (name, BAD_CAST tag)));
00336
00337 xmlListAppend (list, steps);
00338
00339 return 0;
00340 ERROUT:
00341 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00342 PROGNAME, __FUNCTION__);
00343 xmlListDelete (steps->steps);
00344 free(steps);
00345 return 1;
00346 }
00347
00352 LOCAL int td_parse_case(td_set *s)
00353 {
00354 const xmlChar *name;
00355 td_step *step = NULL;
00356 td_case *c = NULL;
00357 int ret;
00358
00359 c = td_case_create();
00360 if (!c)
00361 goto ERROUT;
00362
00363 if (td_parse_gen_attribs (&c->gen, &s->gen))
00364 goto ERROUT;
00365
00366 if (xmlTextReaderMoveToAttribute (reader,
00367 BAD_CAST "subfeature") == 1) {
00368 c->subfeature = xmlTextReaderValue(reader);
00369 }
00370
00371 if (xmlTextReaderMoveToAttribute (reader,
00372 BAD_CAST "bugzilla_id") == 1) {
00373 c->bugzilla_id = xmlTextReaderValue(reader);
00374 }
00375 if (xmlTextReaderMoveToAttribute (reader,
00376 BAD_CAST "TC_ID") == 1) {
00377 c->tc_id = xmlTextReaderValue(reader);
00378 }
00379 if (xmlTextReaderMoveToAttribute (reader,
00380 BAD_CAST "state") == 1) {
00381 c->state = xmlTextReaderValue(reader);
00382 }
00383
00384 xmlTextReaderMoveToElement (reader);
00385 if (xmlTextReaderIsEmptyElement (reader))
00386 goto OK_OUT;
00387
00388 do {
00389 ret = xmlTextReaderRead(reader);
00390 if (!ret) {
00391 goto ERROUT;
00392 }
00393 name = xmlTextReaderConstName(reader);
00394 if (!name) {
00395 LOG_MSG (LOG_ERR, "%s: ReaderName() fail\n",
00396 PROGNAME);
00397 goto ERROUT;
00398 }
00399 if (xmlTextReaderNodeType(reader) ==
00400 XML_READER_TYPE_ELEMENT &&
00401 !xmlStrcmp (name, BAD_CAST "step")) {
00402 step = td_parse_step (c->gen.manual);
00403 if (!step)
00404 goto ERROUT;
00405 if (xmlListAppend (c->steps, step)) {
00406 LOG_MSG (LOG_ERR, "%s: list insert failed\n",
00407 PROGNAME);
00408 goto ERROUT;
00409 }
00410 }
00411 if (xmlTextReaderNodeType(reader) ==
00412 XML_READER_TYPE_ELEMENT &&
00413 !xmlStrcmp (name, BAD_CAST "description")) {
00414 c->description = xmlTextReaderReadString(reader);
00415 }
00416
00417
00418 } while (!(xmlTextReaderNodeType(reader) ==
00419 XML_READER_TYPE_END_ELEMENT &&
00420 !xmlStrcmp (name, BAD_CAST "case")));
00421 OK_OUT:
00422 xmlListAppend (s->cases, c);
00423
00424 return 0;
00425 ERROUT:
00426 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00427 PROGNAME, __FUNCTION__);
00428 xmlListDelete (c->steps);
00429 if (c->gen.name) free (c->gen.name);
00430 if (c->gen.description) free (c->gen.description);
00431 free (c);
00432 return 1;
00433 }
00434
00439 LOCAL int td_parse_environments(xmlListPtr list)
00440 {
00441 int ret;
00442 const xmlChar *name;
00443 xmlChar *value;
00444
00445 do {
00446 ret = xmlTextReaderRead(reader);
00447 if (!ret) {
00448 LOG_MSG (LOG_ERR, "%s:%s: ReaderRead() fail\n",
00449 PROGNAME, __FUNCTION__);
00450
00451 goto ERROUT;
00452 }
00453
00454 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
00455 name = xmlTextReaderConstName(reader);
00456 if (!name) {
00457 LOG_MSG (LOG_ERR, "%s:%s: ReaderName() "
00458 "fail\n",
00459 PROGNAME, __FUNCTION__);
00460 goto ERROUT;
00461 }
00462 }
00463
00464 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT) {
00465 value = xmlTextReaderReadString (reader);
00466 if (!xmlStrcmp (value, BAD_CAST "false")) {
00467 xmlListRemoveAll (list, (void *)name);
00468 }
00469 free (value);
00470 }
00471 } while (!(xmlTextReaderNodeType(reader) ==
00472 XML_READER_TYPE_END_ELEMENT &&
00473 !xmlStrcmp (xmlTextReaderConstName(reader),
00474 BAD_CAST "environments")));
00475
00476 return 0;
00477 ERROUT:
00478 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00479 PROGNAME, __FUNCTION__);
00480 return 1;
00481 }
00482
00487 LOCAL int td_parse_gets(xmlListPtr list)
00488 {
00489 int ret;
00490 int delete_after = 0;
00491 td_file *file;
00492
00493 do {
00494
00495 ret = xmlTextReaderRead(reader);
00496 if (!ret) {
00497 LOG_MSG (LOG_ERR, "%s:%s: ReaderRead() fail\n",
00498 PROGNAME, __FUNCTION__);
00499
00500 goto ERROUT;
00501 }
00502
00503 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT &&
00504 xmlTextReaderMoveToNextAttribute(reader) == 1) {
00505 delete_after = !xmlStrcmp (xmlTextReaderConstValue
00506 (reader),
00507 BAD_CAST "true");
00508 }
00509
00510
00511 if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT) {
00512 file = (td_file *)malloc (sizeof (td_file));
00513 file->filename = xmlTextReaderReadString (reader);
00514 file->delete_after = delete_after;
00515 delete_after = 0;
00516 if (xmlListAppend (list, file)) {
00517 LOG_MSG (LOG_ERR,
00518 "%s:%s list insert failed\n",
00519 PROGNAME, __FUNCTION__);
00520 goto ERROUT;
00521 }
00522
00523 }
00524 } while (!(xmlTextReaderNodeType(reader) ==
00525 XML_READER_TYPE_END_ELEMENT &&
00526 !xmlStrcmp (xmlTextReaderConstName(reader),
00527 BAD_CAST "get")));
00528
00529 return 0;
00530 ERROUT:
00531 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00532 PROGNAME, __FUNCTION__);
00533 return 1;
00534 }
00535
00539 LOCAL int td_parse_suite ()
00540 {
00541 td_suite *s;
00542
00543
00544 if (!cbs->test_suite)
00545 return 1;
00546
00547 s = td_suite_create();
00548 if (!s) return 1;
00549
00550 current_suite = s;
00551
00552 td_parse_gen_attribs (&s->gen, NULL);
00553
00554 cbs->test_suite(s);
00555
00556 if (xmlTextReaderIsEmptyElement (reader)) {
00557 parsing_level--;
00558 cbs->test_suite_end(s);
00559 }
00560 return 0;
00561 }
00562
00566 LOCAL int td_parse_set ()
00567 {
00568 int ret = 0;
00569 td_set *s;
00570 const xmlChar *name;
00571 xmlReaderTypes type;
00572
00573
00574 if (!cbs->test_set)
00575 return 1;
00576 s = td_set_create ();
00577 current_set = s;
00578
00579 if (td_parse_gen_attribs(&s->gen, ¤t_suite->gen))
00580 goto ERROUT;
00581
00582 if (xmlTextReaderIsEmptyElement (reader))
00583 goto OKOUT;
00584
00585 do {
00586 ret = xmlTextReaderRead(reader);
00587 if (!ret)
00588 goto OKOUT;
00589 name = xmlTextReaderConstName(reader);
00590 type = xmlTextReaderNodeType(reader);
00591 if (!name) {
00592 LOG_MSG (LOG_ERR, "%s: ReaderName() fail\n",
00593 PROGNAME);
00594 goto ERROUT;
00595 }
00596
00597 if (!xmlStrcmp (name, BAD_CAST "pre_steps"))
00598 ret = !td_parse_steps(s->pre_steps, "pre_steps");
00599 if (!xmlStrcmp (name, BAD_CAST "post_steps"))
00600 ret = !td_parse_steps(s->post_steps, "post_steps");
00601 if (!xmlStrcmp (name, BAD_CAST "case"))
00602 ret = !td_parse_case(s);
00603 if (!xmlStrcmp (name, BAD_CAST "environments"))
00604 ret = !td_parse_environments(s->environments);
00605 if (!xmlStrcmp (name, BAD_CAST "get"))
00606 ret = !td_parse_gets(s->gets);
00607 if (!xmlStrcmp (name, BAD_CAST "description") &&
00608 type == XML_READER_TYPE_ELEMENT) {
00609 s->description =
00610 xmlTextReaderReadString (reader);
00611 }
00612 if (!ret)
00613 goto ERROUT;
00614 } while (!(xmlTextReaderNodeType(reader) ==
00615 XML_READER_TYPE_END_ELEMENT &&
00616 !xmlStrcmp (name, BAD_CAST "set")));
00617 OKOUT:
00618 cbs->test_set(s);
00619
00620 return 0;
00621 ERROUT:
00622 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00623 PROGNAME, __FUNCTION__);
00624
00625 return 1;
00626 }
00627
00631 LOCAL int td_parse_td ()
00632 {
00633 td_td *td;
00634 const xmlChar *name;
00635
00636 td = td_td_create();
00637 if (!td)
00638 return 1;
00639
00640 parsing_level++;
00641 while (xmlTextReaderMoveToNextAttribute(reader)) {
00642 name = xmlTextReaderConstName(reader);
00643 if (!xmlStrcmp (name, BAD_CAST "version")) {
00644 td->version = xmlTextReaderValue(reader);
00645 continue;
00646 }
00647 }
00648 current_td = td;
00649
00650 if (cbs->test_td)
00651 cbs->test_td(td);
00652
00653 return 0;
00654 }
00655
00659 LOCAL int td_parse_hwiddetect ()
00660 {
00661 int ret;
00662 const xmlChar *name;
00663
00664 do {
00665 if (xmlTextReaderHasValue(reader) > 0) {
00666 current_td->hw_detector = xmlTextReaderValue(reader);
00667 LOG_MSG (LOG_INFO, "HW ID dectector command: %s",
00668 current_td->hw_detector);
00669 }
00670 ret = xmlTextReaderRead(reader);
00671 name = xmlTextReaderConstName(reader);
00672 }
00673 while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT &&
00674 xmlStrcmp (name, BAD_CAST "hwiddetect"));
00675
00676
00677 if (cbs->test_hwiddetect) {
00678 cbs->test_hwiddetect();
00679 }
00680
00681 return 0;
00682 }
00683
00684
00685
00686
00691 int parse_test_definition (testrunner_lite_options *opts)
00692 {
00693 int ret = TESTRUNNER_LITE_XML_PARSE_FAIL;
00694 xmlDocPtr doc = NULL;
00695 xmlParserCtxtPtr ctxt = NULL;
00696 xmlSchemaPtr sch = NULL;
00697 xmlSchemaValidCtxtPtr valid_ctxt = NULL;
00698 xmlSchemaParserCtxtPtr schema_ctxt = NULL;
00699
00700 xmlSubstituteEntitiesDefault(1);
00701
00702
00703
00704
00705 ctxt = xmlNewParserCtxt();
00706 if (ctxt == NULL) {
00707 LOG_MSG (LOG_ERR, "%s: Failed to allocate parser context\n",
00708 PROGNAME);
00709 goto out;
00710 }
00711
00712 doc = xmlCtxtReadFile(ctxt, opts->input_filename, NULL, XML_PARSE_NOENT);
00713 if (doc == NULL) {
00714 LOG_MSG (LOG_ERR, "%s: Failed to parse %s\n", PROGNAME,
00715 opts->input_filename);
00716 goto out;
00717 } else if (!ctxt->valid) {
00718 LOG_MSG (LOG_ERR, "%s: Failed to validate %s\n", PROGNAME,
00719 opts->input_filename);
00720 xmlFreeDoc(doc);
00721 doc = NULL;
00722 goto out;
00723 }
00724
00725 if (opts->disable_schema) {
00726 ret = 0;
00727 goto out;
00728 }
00729
00730
00731
00732 if (opts->semantic_schema)
00733 schema_ctxt = xmlSchemaNewParserCtxt("/usr/share/test-definition/"
00734 "testdefinition-tm_terms.xsd");
00735 else
00736 schema_ctxt = xmlSchemaNewParserCtxt("/usr/share/test-definition/"
00737 "testdefinition-syntax.xsd");
00738
00739 if (schema_ctxt == NULL) {
00740 LOG_MSG (LOG_ERR, "%s: Failed to allocate schema context\n",
00741 PROGNAME);
00742 goto out;
00743 }
00744
00745 sch = xmlSchemaParse(schema_ctxt);
00746 if (sch == NULL) {
00747 LOG_MSG (LOG_ERR, "%s: Failed to parse schema\n",
00748 PROGNAME);
00749 goto out;
00750 }
00751
00752 valid_ctxt = xmlSchemaNewValidCtxt(sch);
00753 if (valid_ctxt == NULL) {
00754 LOG_MSG (LOG_ERR, "%s: Failed to create schema validation "
00755 "context\n", PROGNAME);
00756 goto out;
00757
00758 }
00759
00760 ret = xmlSchemaValidateDoc(valid_ctxt, doc);
00761 if (ret)
00762 ret = TESTRUNNER_LITE_XML_VALIDATION_FAIL;
00763 out:
00764
00765
00766
00767 if (doc) xmlFreeDoc(doc);
00768 if (ctxt) xmlFreeParserCtxt(ctxt);
00769 if (sch) xmlSchemaFree(sch);
00770 if (valid_ctxt) xmlSchemaFreeValidCtxt(valid_ctxt);
00771 if (schema_ctxt) xmlSchemaFreeParserCtxt(schema_ctxt);
00772
00773 return ret;
00774 }
00775
00780 int td_reader_init (testrunner_lite_options *opts)
00781 {
00782
00783 reader = xmlNewTextReaderFilename(opts->input_filename);
00784 if (!reader) {
00785 LOG_MSG (LOG_ERR, "%s: failed to create xml reader for %s\n",
00786 PROGNAME, opts->input_filename);
00787
00788 }
00789
00790 if (opts->disable_schema)
00791 return 0;
00792
00793 if (opts->semantic_schema)
00794 schema_context = xmlSchemaNewParserCtxt
00795 ("/usr/share/test-definition/"
00796 "testdefinition-tm_terms.xsd");
00797 else
00798 schema_context = xmlSchemaNewParserCtxt
00799 ("/usr/share/test-definition/"
00800 "testdefinition-syntax.xsd");
00801 if (schema_context == NULL) {
00802 LOG_MSG (LOG_ERR, "%s: Failed to allocate schema context\n",
00803 PROGNAME);
00804 goto err_out;
00805 }
00806
00807 schema = xmlSchemaParse(schema_context);
00808 if (schema == NULL) {
00809 LOG_MSG (LOG_ERR, "%s: Failed to parse schema\n",
00810 PROGNAME);
00811 goto err_out;
00812 }
00813
00814 if (xmlTextReaderSetSchema (reader, schema)) {
00815 LOG_MSG (LOG_ERR, "%s: Failed to set schema for xml reader\n",
00816 PROGNAME);
00817 goto err_out;
00818 }
00819
00820
00821 return 0;
00822 err_out:
00823 LOG_MSG (LOG_ERR, "%s:%s: Exiting with error\n",
00824 PROGNAME, __FUNCTION__);
00825 td_reader_close ();
00826 return 1;
00827
00828 }
00829
00832 void td_reader_close ()
00833 {
00834 if (reader) xmlFreeTextReader (reader);
00835 if (schema) xmlSchemaFree(schema);
00836 if (schema_context) xmlSchemaFreeParserCtxt(schema_context);
00837 }
00838
00842 int td_next_node (void) {
00843 int ret;
00844 const xmlChar *name = NULL;
00845 xmlReaderTypes type;
00846
00847 ret = xmlTextReaderRead(reader);
00848
00849 if (!ret)
00850 return !ret;
00851
00852 name = xmlTextReaderConstName(reader);
00853 type = xmlTextReaderNodeType(reader);
00854
00855 if (!name)
00856 return 1;
00857
00858 if (!xmlStrcmp (name, BAD_CAST "testdefinition")) {
00859 if (type == XML_READER_TYPE_ELEMENT) {
00860 return td_parse_td();
00861 }
00862 else if (type == XML_READER_TYPE_END_ELEMENT) {
00863 parsing_level--;
00864 if (cbs->test_td_end)
00865 cbs->test_td_end();
00866 return 0;
00867 }
00868 }
00869
00870 if (!xmlStrcmp (name, BAD_CAST "hwiddetect")) {
00871 if (type == XML_READER_TYPE_ELEMENT) {
00872 return td_parse_hwiddetect();
00873 }
00874 }
00875
00876 if (!xmlStrcmp (name, BAD_CAST "description") &&
00877 type == XML_READER_TYPE_ELEMENT) {
00878 switch (parsing_level) {
00879 case 1:
00880 current_td->description =
00881 xmlTextReaderReadString (reader);
00882 break;
00883 case 2:
00884 current_suite->description =
00885 xmlTextReaderReadString (reader);
00886 break;
00887 default:
00888 LOG_MSG (LOG_ERR, "run time error, "
00889 "invalid parsing level %d", parsing_level);
00890 return 1;
00891 }
00892 return 0;
00893 }
00894
00895 if (!xmlStrcmp (name, BAD_CAST "suite")) {
00896 if (type == XML_READER_TYPE_ELEMENT) {
00897 parsing_level ++;
00898 return td_parse_suite();
00899 }
00900 else if (type == XML_READER_TYPE_END_ELEMENT) {
00901 parsing_level --;
00902 if (cbs->test_suite_end) cbs->test_suite_end();
00903 return 0;
00904 }
00905 }
00906
00907 if (!xmlStrcmp (name, BAD_CAST "set") &&
00908 type == XML_READER_TYPE_ELEMENT)
00909 return td_parse_set();
00910
00911 return !ret;
00912 }
00913
00917 int td_register_callbacks(td_parser_callbacks *pcbs)
00918 {
00919 cbs = pcbs;
00920
00921 return 0;
00922 }
00923
00924
00925
00926
00927
00928
00929
