gentest.py

   1 #!/usr/bin/python -u
   2 #
   3 # generate a tester program for the API
   4 #
   5 import sys
   6 import os
   7 import string
   8 try:
   9     import libxml2
  10 except:
  11     print "libxml2 python bindings not available, skipping testapi.c generation"
  12     sys.exit(0)
  13
  14 if len(sys.argv) > 1:
  15     srcPref = sys.argv[1] + '/'
  16 else:
  17     srcPref = ''
  18
  19 #
  20 # Modules we want to skip in API test
  21 #
  22 skipped_modules = [ "SAX", "xlink", "threads", "globals",
  23   "xmlmemory", "xmlversion", "xmlexports",
  24   #deprecated
  25   "DOCBparser",
  26 ]
  27
  28 #
  29 # defines for each module
  30 #
  31 modules_defines = {
  32     "HTMLparser": "LIBXML_HTML_ENABLED",
  33     "catalog": "LIBXML_CATALOG_ENABLED",
  34     "xmlreader": "LIBXML_READER_ENABLED",
  35     "relaxng": "LIBXML_SCHEMAS_ENABLED",
  36     "schemasInternals": "LIBXML_SCHEMAS_ENABLED",
  37     "xmlschemas": "LIBXML_SCHEMAS_ENABLED",
  38     "xmlschemastypes": "LIBXML_SCHEMAS_ENABLED",
  39     "xpath": "LIBXML_XPATH_ENABLED",
  40     "xpathInternals": "LIBXML_XPATH_ENABLED",
  41     "xinclude": "LIBXML_XINCLUDE_ENABLED",
  42     "xpointer": "LIBXML_XPTR_ENABLED",
  43     "xmlregexp" : "LIBXML_REGEXP_ENABLED",
  44     "xmlautomata" : "LIBXML_AUTOMATA_ENABLED",
  45     "xmlsave" : "LIBXML_OUTPUT_ENABLED",
  46     "DOCBparser" : "LIBXML_DOCB_ENABLED",
  47     "xmlmodule" : "LIBXML_MODULES_ENABLED",
  48     "pattern" : "LIBXML_PATTERN_ENABLED",
  49     "schematron" : "LIBXML_SCHEMATRON_ENABLED",
  50 }
  51
  52 #
  53 # defines for specific functions
  54 #
  55 function_defines = {
  56     "htmlDefaultSAXHandlerInit": "LIBXML_HTML_ENABLED",
  57     "xmlSAX2EndElement" : "LIBXML_SAX1_ENABLED",
  58     "xmlSAX2StartElement" : "LIBXML_SAX1_ENABLED",
  59     "xmlSAXDefaultVersion" : "LIBXML_SAX1_ENABLED",
  60     "UTF8Toisolat1" : "LIBXML_OUTPUT_ENABLED",
  61     "xmlCleanupPredefinedEntities": "LIBXML_LEGACY_ENABLED",
  62     "xmlInitializePredefinedEntities": "LIBXML_LEGACY_ENABLED",
  63     "xmlSetFeature": "LIBXML_LEGACY_ENABLED",
  64     "xmlGetFeature": "LIBXML_LEGACY_ENABLED",
  65     "xmlGetFeaturesList": "LIBXML_LEGACY_ENABLED",
  66     "xmlIOParseDTD": "LIBXML_VALID_ENABLED",
  67     "xmlParseDTD": "LIBXML_VALID_ENABLED",
  68     "xmlParseDoc": "LIBXML_SAX1_ENABLED",
  69     "xmlParseMemory": "LIBXML_SAX1_ENABLED",
  70     "xmlRecoverDoc": "LIBXML_SAX1_ENABLED",
  71     "xmlParseFile": "LIBXML_SAX1_ENABLED",
  72     "xmlRecoverFile": "LIBXML_SAX1_ENABLED",
  73     "xmlRecoverMemory": "LIBXML_SAX1_ENABLED",
  74     "xmlSAXParseFileWithData": "LIBXML_SAX1_ENABLED",
  75     "xmlSAXParseMemory": "LIBXML_SAX1_ENABLED",
  76     "xmlSAXUserParseMemory": "LIBXML_SAX1_ENABLED",
  77     "xmlSAXParseDoc": "LIBXML_SAX1_ENABLED",
  78     "xmlSAXParseDTD": "LIBXML_SAX1_ENABLED",
  79     "xmlSAXUserParseFile": "LIBXML_SAX1_ENABLED",
  80     "xmlParseEntity": "LIBXML_SAX1_ENABLED",
  81     "xmlParseExternalEntity": "LIBXML_SAX1_ENABLED",
  82     "xmlSAXParseMemoryWithData": "LIBXML_SAX1_ENABLED",
  83     "xmlParseBalancedChunkMemory": "LIBXML_SAX1_ENABLED",
  84     "xmlParseBalancedChunkMemoryRecover": "LIBXML_SAX1_ENABLED",
  85     "xmlSetupParserForBuffer": "LIBXML_SAX1_ENABLED",
  86     "xmlStopParser": "LIBXML_PUSH_ENABLED",
  87     "xmlAttrSerializeTxtContent": "LIBXML_OUTPUT_ENABLED",
  88     "xmlSAXParseFile": "LIBXML_SAX1_ENABLED",
  89     "xmlSAXParseEntity": "LIBXML_SAX1_ENABLED",
  90     "xmlNewTextChild": "LIBXML_TREE_ENABLED",
  91     "xmlNewDocRawNode": "LIBXML_TREE_ENABLED",
  92     "xmlNewProp": "LIBXML_TREE_ENABLED",
  93     "xmlReconciliateNs": "LIBXML_TREE_ENABLED",
  94     "xmlValidateNCName": "LIBXML_TREE_ENABLED",
  95     "xmlValidateNMToken": "LIBXML_TREE_ENABLED",
  96     "xmlValidateName": "LIBXML_TREE_ENABLED",
  97     "xmlNewChild": "LIBXML_TREE_ENABLED",
  98     "xmlValidateQName": "LIBXML_TREE_ENABLED",
  99     "xmlSprintfElementContent": "LIBXML_OUTPUT_ENABLED",
 100     "xmlValidGetPotentialChildren" : "LIBXML_VALID_ENABLED",
 101     "xmlValidGetValidElements" : "LIBXML_VALID_ENABLED",
 102     "docbDefaultSAXHandlerInit" : "LIBXML_DOCB_ENABLED",
 103     "xmlTextReaderPreservePattern" : "LIBXML_PATTERN_ENABLED",
 104 }
 105
 106 #
 107 # Some functions really need to be skipped for the tests.
 108 #
 109 skipped_functions = [
 110 # block on I/O
 111 "xmlFdRead", "xmlReadFd", "xmlCtxtReadFd",
 112 "htmlFdRead", "htmlReadFd", "htmlCtxtReadFd",
 113 "xmlReaderNewFd", "xmlReaderForFd",
 114 "xmlIORead", "xmlReadIO", "xmlCtxtReadIO",
 115 "htmlIORead", "htmlReadIO", "htmlCtxtReadIO",
 116 "xmlReaderNewIO", "xmlBufferDump", "xmlNanoFTPConnect",
 117 "xmlNanoFTPConnectTo", "xmlNanoHTTPMethod", "xmlNanoHTTPMethodRedir",
 118 # Complex I/O APIs
 119 "xmlCreateIOParserCtxt", "xmlParserInputBufferCreateIO",
 120 "xmlRegisterInputCallbacks", "xmlReaderForIO",
 121 "xmlOutputBufferCreateIO", "xmlRegisterOutputCallbacks",
 122 "xmlSaveToIO", "xmlIOHTTPOpenW",
 123 # library state cleanup, generate false leak informations and other
 124 # troubles, heavillyb tested otherwise.
 125 "xmlCleanupParser", "xmlRelaxNGCleanupTypes", "xmlSetListDoc",
 126 "xmlSetTreeDoc", "xmlUnlinkNode",
 127 # hard to avoid leaks in the tests
 128 "xmlStrcat", "xmlStrncat", "xmlCatalogAddLocal", "xmlNewTextWriterDoc",
 129 "xmlXPathNewValueTree", "xmlXPathWrapString",
 130 # unimplemented
 131 "xmlTextReaderReadInnerXml", "xmlTextReaderReadOuterXml",
 132 "xmlTextReaderReadString",
 133 # destructor
 134 "xmlListDelete", "xmlOutputBufferClose", "xmlNanoFTPClose", "xmlNanoHTTPClose",
 135 # deprecated
 136 "xmlCatalogGetPublic", "xmlCatalogGetSystem", "xmlEncodeEntities",
 137 "xmlNewGlobalNs", "xmlHandleEntity", "xmlNamespaceParseNCName",
 138 "xmlNamespaceParseNSDef", "xmlNamespaceParseQName",
 139 "xmlParseNamespace", "xmlParseQuotedString", "xmlParserHandleReference",
 140 "xmlScanName",
 141 "xmlDecodeEntities",
 142 # allocators
 143 "xmlMemFree",
 144 # verbosity
 145 "xmlCatalogSetDebug", "xmlShellPrintXPathError", "xmlShellPrintNode",
 146 # Internal functions, no user space should really call them
 147 "xmlParseAttribute", "xmlParseAttributeListDecl", "xmlParseName",
 148 "xmlParseNmtoken", "xmlParseEntityValue", "xmlParseAttValue",
 149 "xmlParseSystemLiteral", "xmlParsePubidLiteral", "xmlParseCharData",
 150 "xmlParseExternalID", "xmlParseComment", "xmlParsePITarget", "xmlParsePI",
 151 "xmlParseNotationDecl", "xmlParseEntityDecl", "xmlParseDefaultDecl",
 152 "xmlParseNotationType", "xmlParseEnumerationType", "xmlParseEnumeratedType",
 153 "xmlParseAttributeType", "xmlParseAttributeListDecl",
 154 "xmlParseElementMixedContentDecl", "xmlParseElementChildrenContentDecl",
 155 "xmlParseElementContentDecl", "xmlParseElementDecl", "xmlParseMarkupDecl",
 156 "xmlParseCharRef", "xmlParseEntityRef", "xmlParseReference",
 157 "xmlParsePEReference", "xmlParseDocTypeDecl", "xmlParseAttribute",
 158 "xmlParseStartTag", "xmlParseEndTag", "xmlParseCDSect", "xmlParseContent",
 159 "xmlParseElement", "xmlParseVersionNum", "xmlParseVersionInfo",
 160 "xmlParseEncName", "xmlParseEncodingDecl", "xmlParseSDDecl",
 161 "xmlParseXMLDecl", "xmlParseTextDecl", "xmlParseMisc",
 162 "xmlParseExternalSubset", "xmlParserHandlePEReference",
 163 "xmlSkipBlankChars",
 164 ]
 165
 166 #
 167 # These functions have side effects on the global state
 168 # and hence generate errors on memory allocation tests
 169 #
 170 skipped_memcheck = [ "xmlLoadCatalog", "xmlAddEncodingAlias",
 171    "xmlSchemaInitTypes", "xmlNanoFTPProxy", "xmlNanoFTPScanProxy",
 172    "xmlNanoHTTPScanProxy", "xmlResetLastError", "xmlCatalogConvert",
 173    "xmlCatalogRemove", "xmlLoadCatalogs", "xmlCleanupCharEncodingHandlers",
 174    "xmlInitCharEncodingHandlers", "xmlCatalogCleanup",
 175    "xmlSchemaGetBuiltInType",
 176    "htmlParseFile", "htmlCtxtReadFile", # loads the catalogs
 177    "xmlTextReaderSchemaValidate", "xmlSchemaCleanupTypes", # initialize the schemas type system
 178    "xmlCatalogResolve", "xmlIOParseDTD" # loads the catalogs
 179 ]
 180
 181 #
 182 # Extra code needed for some test cases
 183 #
 184 extra_pre_call = {
 185    "xmlSAXUserParseFile": """
 186 #ifdef LIBXML_SAX1_ENABLED
 187         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
 188 #endif
 189 """,
 190    "xmlSAXUserParseMemory": """
 191 #ifdef LIBXML_SAX1_ENABLED
 192         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
 193 #endif
 194 """,
 195    "xmlParseBalancedChunkMemory": """
 196 #ifdef LIBXML_SAX1_ENABLED
 197         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
 198 #endif
 199 """,
 200    "xmlParseBalancedChunkMemoryRecover": """
 201 #ifdef LIBXML_SAX1_ENABLED
 202         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
 203 #endif
 204 """,
 205    "xmlParserInputBufferCreateFd":
 206        "if (fd >= 0) fd = -1;",
 207 }
 208 extra_post_call = {
 209    "xmlAddChild":
 210        "if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }",
 211    "xmlAddEntity":
 212        "if (ret_val != NULL) { xmlFreeNode(ret_val) ; ret_val = NULL; }",
 213    "xmlAddChildList":
 214        "if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }",
 215    "xmlAddSibling":
 216        "if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }",
 217    "xmlAddNextSibling":
 218        "if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }",
 219    "xmlAddPrevSibling":
 220        "if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }",
 221    "xmlDocSetRootElement":
 222        "if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }",
 223    "xmlReplaceNode":
 224        """if (cur != NULL) {
 225               xmlUnlinkNode(cur);
 226               xmlFreeNode(cur) ; cur = NULL ; }
 227           if (old != NULL) {
 228               xmlUnlinkNode(old);
 229               xmlFreeNode(old) ; old = NULL ; }
 230           ret_val = NULL;""",
 231    "xmlTextMerge":
 232        """if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
 233               xmlUnlinkNode(second);
 234               xmlFreeNode(second) ; second = NULL ; }""",
 235    "xmlBuildQName":
 236        """if ((ret_val != NULL) && (ret_val != ncname) &&
 237               (ret_val != prefix) && (ret_val != memory))
 238               xmlFree(ret_val);
 239           ret_val = NULL;""",
 240    "xmlNewDocElementContent":
 241        """xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;""",
 242    "xmlDictReference": "xmlDictFree(dict);",
 243    # Functions which deallocates one of their parameters
 244    "xmlXPathConvertBoolean": """val = NULL;""",
 245    "xmlXPathConvertNumber": """val = NULL;""",
 246    "xmlXPathConvertString": """val = NULL;""",
 247    "xmlSaveFileTo": """buf = NULL;""",
 248    "xmlSaveFormatFileTo": """buf = NULL;""",
 249    "xmlIOParseDTD": "input = NULL;",
 250    "xmlRemoveProp": "cur = NULL;",
 251    "xmlNewNs": "if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);",
 252    "xmlCopyNamespace": "if (ret_val != NULL) xmlFreeNs(ret_val);",
 253    "xmlCopyNamespaceList": "if (ret_val != NULL) xmlFreeNsList(ret_val);",
 254    "xmlNewTextWriter": "if (ret_val != NULL) out = NULL;",
 255    "xmlNewTextWriterPushParser": "if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;",
 256    "xmlNewIOInputStream": "if (ret_val != NULL) input = NULL;",
 257    "htmlParseChunk": "if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}",
 258    "htmlParseDocument": "if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}",
 259    "xmlParseDocument": "if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}",
 260    "xmlParseChunk": "if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}",
 261    "xmlParseExtParsedEnt": "if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}",
 262    "xmlDOMWrapAdoptNode": "if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}",
 263    "xmlBufferSetAllocationScheme": "if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;}"
 264 }
 265
 266 modules = []
 267
 268 def is_skipped_module(name):
 269     for mod in skipped_modules:
 270         if mod == name:
 271             return 1
 272     return 0
 273
 274 def is_skipped_function(name):
 275     for fun in skipped_functions:
 276         if fun == name:
 277             return 1
 278     # Do not test destructors
 279     if string.find(name, 'Free') != -1:
 280         return 1
 281     return 0
 282
 283 def is_skipped_memcheck(name):
 284     for fun in skipped_memcheck:
 285         if fun == name:
 286             return 1
 287     return 0
 288
 289 missing_types = {}
 290 def add_missing_type(name, func):
 291     try:
 292         list = missing_types[name]
 293         list.append(func)
 294     except:
 295         missing_types[name] = [func]
 296
 297 generated_param_types = []
 298 def add_generated_param_type(name):
 299     generated_param_types.append(name)
 300
 301 generated_return_types = []
 302 def add_generated_return_type(name):
 303     generated_return_types.append(name)
 304
 305 missing_functions = {}
 306 missing_functions_nr = 0
 307 def add_missing_functions(name, module):
 308     global missing_functions_nr
 309
 310     missing_functions_nr = missing_functions_nr + 1
 311     try:
 312         list = missing_functions[module]
 313         list.append(name)
 314     except:
 315         missing_functions[module] = [name]
 316
 317 #
 318 # Provide the type generators and destructors for the parameters
 319 #
 320
 321 def type_convert(str, name, info, module, function, pos):
 322 #    res = string.replace(str, "    ", " ")
 323 #    res = string.replace(str, "   ", " ")
 324 #    res = string.replace(str, "  ", " ")
 325     res = string.replace(str, " *", "_ptr")
 326 #    res = string.replace(str, "*", "_ptr")
 327     res = string.replace(res, " ", "_")
 328     if res == 'const_char_ptr':
 329         if string.find(name, "file") != -1 or \
 330            string.find(name, "uri") != -1 or \
 331            string.find(name, "URI") != -1 or \
 332            string.find(info, "filename") != -1 or \
 333            string.find(info, "URI") != -1 or \
 334            string.find(info, "URL") != -1:
 335             if string.find(function, "Save") != -1 or \
 336                string.find(function, "Create") != -1 or \
 337                string.find(function, "Write") != -1 or \
 338                string.find(function, "Fetch") != -1:
 339                 return('fileoutput')
 340             return('filepath')
 341     if res == 'void_ptr':
 342         if module == 'nanoftp' and name == 'ctx':
 343             return('xmlNanoFTPCtxtPtr')
 344         if function == 'xmlNanoFTPNewCtxt' or \
 345            function == 'xmlNanoFTPConnectTo' or \
 346            function == 'xmlNanoFTPOpen':
 347             return('xmlNanoFTPCtxtPtr')
 348         if module == 'nanohttp' and name == 'ctx':
 349             return('xmlNanoHTTPCtxtPtr')
 350         if function == 'xmlNanoHTTPMethod' or \
 351            function == 'xmlNanoHTTPMethodRedir' or \
 352            function == 'xmlNanoHTTPOpen' or \
 353            function == 'xmlNanoHTTPOpenRedir':
 354             return('xmlNanoHTTPCtxtPtr');
 355         if function == 'xmlIOHTTPOpen':
 356             return('xmlNanoHTTPCtxtPtr')
 357         if string.find(name, "data") != -1:
 358             return('userdata')
 359         if string.find(name, "user") != -1:
 360             return('userdata')
 361     if res == 'xmlDoc_ptr':
 362         res = 'xmlDocPtr'
 363     if res == 'xmlNode_ptr':
 364         res = 'xmlNodePtr'
 365     if res == 'xmlDict_ptr':
 366         res = 'xmlDictPtr'
 367     if res == 'xmlNodePtr' and pos != 0:
 368         if (function == 'xmlAddChild' and pos == 2) or \
 369            (function == 'xmlAddChildList' and pos == 2) or \
 370            (function == 'xmlAddNextSibling' and pos == 2) or \
 371            (function == 'xmlAddSibling' and pos == 2) or \
 372            (function == 'xmlDocSetRootElement' and pos == 2) or \
 373            (function == 'xmlReplaceNode' and pos == 2) or \
 374            (function == 'xmlTextMerge') or \
 375            (function == 'xmlAddPrevSibling' and pos == 2):
 376             return('xmlNodePtr_in');
 377     if res == 'const xmlBufferPtr':
 378         res = 'xmlBufferPtr'
 379     if res == 'xmlChar_ptr' and name == 'name' and \
 380        string.find(function, "EatName") != -1:
 381         return('eaten_name')
 382     if res == 'void_ptr*':
 383         res = 'void_ptr_ptr'
 384     if res == 'char_ptr*':
 385         res = 'char_ptr_ptr'
 386     if res == 'xmlChar_ptr*':
 387         res = 'xmlChar_ptr_ptr'
 388     if res == 'const_xmlChar_ptr*':
 389         res = 'const_xmlChar_ptr_ptr'
 390     if res == 'const_char_ptr*':
 391         res = 'const_char_ptr_ptr'
 392     if res == 'FILE_ptr' and module == 'debugXML':
 393         res = 'debug_FILE_ptr';
 394     if res == 'int' and name == 'options':
 395         if module == 'parser' or module == 'xmlreader':
 396             res = 'parseroptions'
 397
 398     return res
 399
 400 known_param_types = []
 401
 402 def is_known_param_type(name, rtype):
 403     global test
 404     for type in known_param_types:
 405         if type == name:
 406             return 1
 407     for type in generated_param_types:
 408         if type == name:
 409             return 1
 410
 411     if name[-3:] == 'Ptr' or name[-4:] == '_ptr':
 412         if rtype[0:6] == 'const ':
 413             crtype = rtype[6:]
 414         else:
 415             crtype = rtype
 416
 417         define = 0
 418         if modules_defines.has_key(module):
 419             test.write("#ifdef %s\n" % (modules_defines[module]))
 420             define = 1
 421         test.write("""
 422 #define gen_nb_%s 1
 423 static %s gen_%s(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 424     return(NULL);
 425 }
 426 static void des_%s(int no ATTRIBUTE_UNUSED, %s val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 427 }
 428 """ % (name, crtype, name, name, rtype))
 429         if define == 1:
 430             test.write("#endif\n\n")
 431         add_generated_param_type(name)
 432         return 1
 433
 434     return 0
 435
 436 #
 437 # Provide the type destructors for the return values
 438 #
 439
 440 known_return_types = []
 441
 442 def is_known_return_type(name):
 443     for type in known_return_types:
 444         if type == name:
 445             return 1
 446     return 0
 447
 448 #
 449 # Copy the beginning of the C test program result
 450 #
 451
 452 try:
 453     input = open("testapi.c", "r")
 454 except:
 455     input = open(srcPref + "testapi.c", "r")
 456 test = open('testapi.c.new', 'w')
 457
 458 def compare_and_save():
 459     global test
 460
 461     test.close()
 462     try:
 463         input = open("testapi.c", "r").read()
 464     except:
 465         input = ''
 466     test = open('testapi.c.new', "r").read()
 467     if input != test:
 468         try:
 469             os.system("rm testapi.c; mv testapi.c.new testapi.c")
 470         except:
 471             os.system("mv testapi.c.new testapi.c")
 472         print("Updated testapi.c")
 473     else:
 474         print("Generated testapi.c is identical")
 475
 476 line = input.readline()
 477 while line != "":
 478     if line == "/* CUT HERE: everything below that line is generated */\n":
 479         break;
 480     if line[0:15] == "#define gen_nb_":
 481         type = string.split(line[15:])[0]
 482         known_param_types.append(type)
 483     if line[0:19] == "static void desret_":
 484         type = string.split(line[19:], '(')[0]
 485         known_return_types.append(type)
 486     test.write(line)
 487     line = input.readline()
 488 input.close()
 489
 490 if line == "":
 491     print "Could not find the CUT marker in testapi.c skipping generation"
 492     test.close()
 493     sys.exit(0)
 494
 495 print("Scanned testapi.c: found %d parameters types and %d return types\n" % (
 496       len(known_param_types), len(known_return_types)))
 497 test.write("/* CUT HERE: everything below that line is generated */\n")
 498
 499
 500 #
 501 # Open the input API description
 502 #
 503 doc = libxml2.readFile(srcPref + 'doc/libxml2-api.xml', None, 0)
 504 if doc == None:
 505     print "Failed to load doc/libxml2-api.xml"
 506     sys.exit(1)
 507 ctxt = doc.xpathNewContext()
 508
 509 #
 510 # Generate a list of all function parameters and select only
 511 # those used in the api tests
 512 #
 513 argtypes = {}
 514 args = ctxt.xpathEval("/api/symbols/function/arg")
 515 for arg in args:
 516     mod = arg.xpathEval('string(../@file)')
 517     func = arg.xpathEval('string(../@name)')
 518     if (mod not in skipped_modules) and (func not in skipped_functions):
 519         type = arg.xpathEval('string(@type)')
 520         if not argtypes.has_key(type):
 521             argtypes[type] = func
 522
 523 # similarly for return types
 524 rettypes = {}
 525 rets = ctxt.xpathEval("/api/symbols/function/return")
 526 for ret in rets:
 527     mod = ret.xpathEval('string(../@file)')
 528     func = ret.xpathEval('string(../@name)')
 529     if (mod not in skipped_modules) and (func not in skipped_functions):
 530         type = ret.xpathEval('string(@type)')
 531         if not rettypes.has_key(type):
 532             rettypes[type] = func
 533
 534 #
 535 # Generate constructors and return type handling for all enums
 536 # which are used as function parameters
 537 #
 538 enums = ctxt.xpathEval("/api/symbols/typedef[@type='enum']")
 539 for enum in enums:
 540     module = enum.xpathEval('string(@file)')
 541     name = enum.xpathEval('string(@name)')
 542     #
 543     # Skip any enums which are not in our filtered lists
 544     #
 545     if (name == None) or ((name not in argtypes) and (name not in rettypes)):
 546         continue;
 547     define = 0
 548
 549     if argtypes.has_key(name) and is_known_param_type(name, name) == 0:
 550         values = ctxt.xpathEval("/api/symbols/enum[@type='%s']" % name)
 551         i = 0
 552         vals = []
 553         for value in values:
 554             vname = value.xpathEval('string(@name)')
 555             if vname == None:
 556                 continue;
 557             i = i + 1
 558             if i >= 5:
 559                 break;
 560             vals.append(vname)
 561         if vals == []:
 562             print "Didn't find any value for enum %s" % (name)
 563             continue
 564         if modules_defines.has_key(module):
 565             test.write("#ifdef %s\n" % (modules_defines[module]))
 566             define = 1
 567         test.write("#define gen_nb_%s %d\n" % (name, len(vals)))
 568         test.write("""static %s gen_%s(int no, int nr ATTRIBUTE_UNUSED) {\n""" %
 569                    (name, name))
 570         i = 1
 571         for value in vals:
 572             test.write("    if (no == %d) return(%s);\n" % (i, value))
 573             i = i + 1
 574         test.write("""    return(0);
 575 }
 576
 577 static void des_%s(int no ATTRIBUTE_UNUSED, %s val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 578 }
 579
 580 """ % (name, name));
 581         known_param_types.append(name)
 582
 583     if (is_known_return_type(name) == 0) and (name in rettypes):
 584         if define == 0 and modules_defines.has_key(module):
 585             test.write("#ifdef %s\n" % (modules_defines[module]))
 586             define = 1
 587         test.write("""static void desret_%s(%s val ATTRIBUTE_UNUSED) {
 588 }
 589
 590 """ % (name, name))
 591         known_return_types.append(name)
 592     if define == 1:
 593         test.write("#endif\n\n")
 594
 595 #
 596 # Load the interfaces
 597 #
 598 headers = ctxt.xpathEval("/api/files/file")
 599 for file in headers:
 600     name = file.xpathEval('string(@name)')
 601     if (name == None) or (name == ''):
 602         continue
 603
 604     #
 605     # Some module may be skipped because they don't really consists
 606     # of user callable APIs
 607     #
 608     if is_skipped_module(name):
 609         continue
 610
 611     #
 612     # do not test deprecated APIs
 613     #
 614     desc = file.xpathEval('string(description)')
 615     if string.find(desc, 'DEPRECATED') != -1:
 616         print "Skipping deprecated interface %s" % name
 617         continue;
 618
 619     test.write("#include <libxml/%s.h>\n" % name)
 620     modules.append(name)
 621
 622 #
 623 # Generate the callers signatures
 624 #
 625 for module in modules:
 626     test.write("static int test_%s(void);\n" % module);
 627
 628 #
 629 # Generate the top caller
 630 #
 631
 632 test.write("""
 633 /**
 634  * testlibxml2:
 635  *
 636  * Main entry point of the tester for the full libxml2 module,
 637  * it calls all the tester entry point for each module.
 638  *
 639  * Returns the number of error found
 640  */
 641 static int
 642 testlibxml2(void)
 643 {
 644     int test_ret = 0;
 645
 646 """)
 647
 648 for module in modules:
 649     test.write("    test_ret += test_%s();\n" % module)
 650
 651 test.write("""
 652     printf("Total: %d functions, %d tests, %d errors\\n",
 653            function_tests, call_tests, test_ret);
 654     return(test_ret);
 655 }
 656
 657 """)
 658
 659 #
 660 # How to handle a function
 661 #
 662 nb_tests = 0
 663
 664 def generate_test(module, node):
 665     global test
 666     global nb_tests
 667     nb_cond = 0
 668     no_gen = 0
 669
 670     name = node.xpathEval('string(@name)')
 671     if is_skipped_function(name):
 672         return
 673
 674     #
 675     # check we know how to handle the args and return values
 676     # and store the informations for the generation
 677     #
 678     try:
 679         args = node.xpathEval("arg")
 680     except:
 681         args = []
 682     t_args = []
 683     n = 0
 684     for arg in args:
 685         n = n + 1
 686         rtype = arg.xpathEval("string(@type)")
 687         if rtype == 'void':
 688             break;
 689         info = arg.xpathEval("string(@info)")
 690         nam = arg.xpathEval("string(@name)")
 691         type = type_convert(rtype, nam, info, module, name, n)
 692         if is_known_param_type(type, rtype) == 0:
 693             add_missing_type(type, name);
 694             no_gen = 1
 695         if (type[-3:] == 'Ptr' or type[-4:] == '_ptr') and \
 696             rtype[0:6] == 'const ':
 697             crtype = rtype[6:]
 698         else:
 699             crtype = rtype
 700         t_args.append((nam, type, rtype, crtype, info))
 701
 702     try:
 703         rets = node.xpathEval("return")
 704     except:
 705         rets = []
 706     t_ret = None
 707     for ret in rets:
 708         rtype = ret.xpathEval("string(@type)")
 709         info = ret.xpathEval("string(@info)")
 710         type = type_convert(rtype, 'return', info, module, name, 0)
 711         if rtype == 'void':
 712             break
 713         if is_known_return_type(type) == 0:
 714             add_missing_type(type, name);
 715             no_gen = 1
 716         t_ret = (type, rtype, info)
 717         break
 718
 719     test.write("""
 720 static int
 721 test_%s(void) {
 722     int test_ret = 0;
 723
 724 """ % (name))
 725
 726     if no_gen == 1:
 727         add_missing_functions(name, module)
 728         test.write("""
 729     /* missing type support */
 730     return(test_ret);
 731 }
 732
 733 """)
 734         return
 735
 736     try:
 737         conds = node.xpathEval("cond")
 738         for cond in conds:
 739             test.write("#if %s\n" % (cond.get_content()))
 740             nb_cond = nb_cond + 1
 741     except:
 742         pass
 743
 744     define = 0
 745     if function_defines.has_key(name):
 746         test.write("#ifdef %s\n" % (function_defines[name]))
 747         define = 1
 748
 749     # Declare the memory usage counter
 750     no_mem = is_skipped_memcheck(name)
 751     if no_mem == 0:
 752         test.write("    int mem_base;\n");
 753
 754     # Declare the return value
 755     if t_ret != None:
 756         test.write("    %s ret_val;\n" % (t_ret[1]))
 757
 758     # Declare the arguments
 759     for arg in t_args:
 760         (nam, type, rtype, crtype, info) = arg;
 761         # add declaration
 762         test.write("    %s %s; /* %s */\n" % (crtype, nam, info))
 763         test.write("    int n_%s;\n" % (nam))
 764     test.write("\n")
 765
 766     # Cascade loop on of each argument list of values
 767     for arg in t_args:
 768         (nam, type, rtype, crtype, info) = arg;
 769         #
 770         test.write("    for (n_%s = 0;n_%s < gen_nb_%s;n_%s++) {\n" % (
 771                    nam, nam, type, nam))
 772
 773     # log the memory usage
 774     if no_mem == 0:
 775         test.write("        mem_base = xmlMemBlocks();\n");
 776
 777     # prepare the call
 778     i = 0;
 779     for arg in t_args:
 780         (nam, type, rtype, crtype, info) = arg;
 781         #
 782         test.write("        %s = gen_%s(n_%s, %d);\n" % (nam, type, nam, i))
 783         i = i + 1;
 784
 785     # do the call, and clanup the result
 786     if extra_pre_call.has_key(name):
 787         test.write("        %s\n"% (extra_pre_call[name]))
 788     if t_ret != None:
 789         test.write("\n        ret_val = %s(" % (name))
 790         need = 0
 791         for arg in t_args:
 792             (nam, type, rtype, crtype, info) = arg
 793             if need:
 794                 test.write(", ")
 795             else:
 796                 need = 1
 797             if rtype != crtype:
 798                 test.write("(%s)" % rtype)
 799             test.write("%s" % nam);
 800         test.write(");\n")
 801         if extra_post_call.has_key(name):
 802             test.write("        %s\n"% (extra_post_call[name]))
 803         test.write("        desret_%s(ret_val);\n" % t_ret[0])
 804     else:
 805         test.write("\n        %s(" % (name));
 806         need = 0;
 807         for arg in t_args:
 808             (nam, type, rtype, crtype, info) = arg;
 809             if need:
 810                 test.write(", ")
 811             else:
 812                 need = 1
 813             if rtype != crtype:
 814                 test.write("(%s)" % rtype)
 815             test.write("%s" % nam)
 816         test.write(");\n")
 817         if extra_post_call.has_key(name):
 818             test.write("        %s\n"% (extra_post_call[name]))
 819
 820     test.write("        call_tests++;\n");
 821
 822     # Free the arguments
 823     i = 0;
 824     for arg in t_args:
 825         (nam, type, rtype, crtype, info) = arg;
 826         # This is a hack to prevent generating a destructor for the
 827         # 'input' argument in xmlTextReaderSetup.  There should be
 828         # a better, more generic way to do this!
 829         if string.find(info, 'destroy') == -1:
 830             test.write("        des_%s(n_%s, " % (type, nam))
 831             if rtype != crtype:
 832                 test.write("(%s)" % rtype)
 833             test.write("%s, %d);\n" % (nam, i))
 834         i = i + 1;
 835
 836     test.write("        xmlResetLastError();\n");
 837     # Check the memory usage
 838     if no_mem == 0:
 839         test.write("""        if (mem_base != xmlMemBlocks()) {
 840             printf("Leak of %%d blocks found in %s",
 841                    xmlMemBlocks() - mem_base);
 842             test_ret++;
 843 """ % (name));
 844         for arg in t_args:
 845             (nam, type, rtype, crtype, info) = arg;
 846             test.write("""            printf(" %%d", n_%s);\n""" % (nam))
 847         test.write("""            printf("\\n");\n""")
 848         test.write("        }\n")
 849
 850     for arg in t_args:
 851         test.write("    }\n")
 852
 853     test.write("    function_tests++;\n")
 854     #
 855     # end of conditional
 856     #
 857     while nb_cond > 0:
 858         test.write("#endif\n")
 859         nb_cond = nb_cond -1
 860     if define == 1:
 861         test.write("#endif\n")
 862
 863     nb_tests = nb_tests + 1;
 864
 865     test.write("""
 866     return(test_ret);
 867 }
 868
 869 """)
 870
 871 #
 872 # Generate all module callers
 873 #
 874 for module in modules:
 875     # gather all the functions exported by that module
 876     try:
 877         functions = ctxt.xpathEval("/api/symbols/function[@file='%s']" % (module))
 878     except:
 879         print "Failed to gather functions from module %s" % (module)
 880         continue;
 881
 882     # iterate over all functions in the module generating the test
 883     i = 0
 884     nb_tests_old = nb_tests
 885     for function in functions:
 886         i = i + 1
 887         generate_test(module, function);
 888
 889     # header
 890     test.write("""static int
 891 test_%s(void) {
 892     int test_ret = 0;
 893
 894     if (quiet == 0) printf("Testing %s : %d of %d functions ...\\n");
 895 """ % (module, module, nb_tests - nb_tests_old, i))
 896
 897     # iterate over all functions in the module generating the call
 898     for function in functions:
 899         name = function.xpathEval('string(@name)')
 900         if is_skipped_function(name):
 901             continue
 902         test.write("    test_ret += test_%s();\n" % (name))
 903
 904     # footer
 905     test.write("""
 906     if (test_ret != 0)
 907         printf("Module %s: %%d errors\\n", test_ret);
 908     return(test_ret);
 909 }
 910 """ % (module))
 911
 912 #
 913 # Generate direct module caller
 914 #
 915 test.write("""static int
 916 test_module(const char *module) {
 917 """);
 918 for module in modules:
 919     test.write("""    if (!strcmp(module, "%s")) return(test_%s());\n""" % (
 920         module, module))
 921 test.write("""    return(0);
 922 }
 923 """);
 924
 925 print "Generated test for %d modules and %d functions" %(len(modules), nb_tests)
 926
 927 compare_and_save()
 928
 929 missing_list = []
 930 for missing in missing_types.keys():
 931     if missing == 'va_list' or missing == '...':
 932         continue;
 933
 934     n = len(missing_types[missing])
 935     missing_list.append((n, missing))
 936
 937 def compare_missing(a, b):
 938     return b[0] - a[0]
 939
 940 missing_list.sort(compare_missing)
 941 print "Missing support for %d functions and %d types see missing.lst" % (missing_functions_nr, len(missing_list))
 942 lst = open("missing.lst", "w")
 943 lst.write("Missing support for %d types" % (len(missing_list)))
 944 lst.write("\n")
 945 for miss in missing_list:
 946     lst.write("%s: %d :" % (miss[1], miss[0]))
 947     i = 0
 948     for n in missing_types[miss[1]]:
 949         i = i + 1
 950         if i > 5:
 951             lst.write(" ...")
 952             break
 953         lst.write(" %s" % (n))
 954     lst.write("\n")
 955 lst.write("\n")
 956 lst.write("\n")
 957 lst.write("Missing support per module");
 958 for module in missing_functions.keys():
 959     lst.write("module %s:\n   %s\n" % (module, missing_functions[module]))
 960
 961 lst.close()
 962
 963