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 # add checks to avoid out-of-bounds array access 786 i = 0; 787 for arg in t_args: 788 (nam, type, rtype, crtype, info) = arg; 789 # assume that "size", "len", and "start" parameters apply to either 790 # the nearest preceding or following char pointer 791 if type == "int" and (nam == "size" or nam == "len" or nam == "start"): 792 for j in range(i - 1, -1, -1) + range(i + 1, len(t_args)): 793 (bnam, btype) = t_args[j][:2] 794 if btype == "const_char_ptr" or btype == "const_xmlChar_ptr": 795 test.write( 796 " if ((%s != NULL) &&\n" 797 " (%s > (int) strlen((const char *) %s) + 1))\n" 798 " continue;\n" 799 % (bnam, nam, bnam)) 800 break 801 i = i + 1; 802 803 # do the call, and clanup the result 804 if extra_pre_call.has_key(name): 805 test.write(" %s\n"% (extra_pre_call[name])) 806 if t_ret != None: 807 test.write("\n ret_val = %s(" % (name)) 808 need = 0 809 for arg in t_args: 810 (nam, type, rtype, crtype, info) = arg 811 if need: 812 test.write(", ") 813 else: 814 need = 1 815 if rtype != crtype: 816 test.write("(%s)" % rtype) 817 test.write("%s" % nam); 818 test.write(");\n") 819 if extra_post_call.has_key(name): 820 test.write(" %s\n"% (extra_post_call[name])) 821 test.write(" desret_%s(ret_val);\n" % t_ret[0]) 822 else: 823 test.write("\n %s(" % (name)); 824 need = 0; 825 for arg in t_args: 826 (nam, type, rtype, crtype, info) = arg; 827 if need: 828 test.write(", ") 829 else: 830 need = 1 831 if rtype != crtype: 832 test.write("(%s)" % rtype) 833 test.write("%s" % nam) 834 test.write(");\n") 835 if extra_post_call.has_key(name): 836 test.write(" %s\n"% (extra_post_call[name])) 837 838 test.write(" call_tests++;\n"); 839 840 # Free the arguments 841 i = 0; 842 for arg in t_args: 843 (nam, type, rtype, crtype, info) = arg; 844 # This is a hack to prevent generating a destructor for the 845 # 'input' argument in xmlTextReaderSetup. There should be 846 # a better, more generic way to do this! 847 if string.find(info, 'destroy') == -1: 848 test.write(" des_%s(n_%s, " % (type, nam)) 849 if rtype != crtype: 850 test.write("(%s)" % rtype) 851 test.write("%s, %d);\n" % (nam, i)) 852 i = i + 1; 853 854 test.write(" xmlResetLastError();\n"); 855 # Check the memory usage 856 if no_mem == 0: 857 test.write(""" if (mem_base != xmlMemBlocks()) { 858 printf("Leak of %%d blocks found in %s", 859 xmlMemBlocks() - mem_base); 860 test_ret++; 861 """ % (name)); 862 for arg in t_args: 863 (nam, type, rtype, crtype, info) = arg; 864 test.write(""" printf(" %%d", n_%s);\n""" % (nam)) 865 test.write(""" printf("\\n");\n""") 866 test.write(" }\n") 867 868 for arg in t_args: 869 test.write(" }\n") 870 871 test.write(" function_tests++;\n") 872 # 873 # end of conditional 874 # 875 while nb_cond > 0: 876 test.write("#endif\n") 877 nb_cond = nb_cond -1 878 if define == 1: 879 test.write("#endif\n") 880 881 nb_tests = nb_tests + 1; 882 883 test.write(""" 884 return(test_ret); 885 } 886 887 """) 888 889 # 890 # Generate all module callers 891 # 892 for module in modules: 893 # gather all the functions exported by that module 894 try: 895 functions = ctxt.xpathEval("/api/symbols/function[@file='%s']" % (module)) 896 except: 897 print "Failed to gather functions from module %s" % (module) 898 continue; 899 900 # iterate over all functions in the module generating the test 901 i = 0 902 nb_tests_old = nb_tests 903 for function in functions: 904 i = i + 1 905 generate_test(module, function); 906 907 # header 908 test.write("""static int 909 test_%s(void) { 910 int test_ret = 0; 911 912 if (quiet == 0) printf("Testing %s : %d of %d functions ...\\n"); 913 """ % (module, module, nb_tests - nb_tests_old, i)) 914 915 # iterate over all functions in the module generating the call 916 for function in functions: 917 name = function.xpathEval('string(@name)') 918 if is_skipped_function(name): 919 continue 920 test.write(" test_ret += test_%s();\n" % (name)) 921 922 # footer 923 test.write(""" 924 if (test_ret != 0) 925 printf("Module %s: %%d errors\\n", test_ret); 926 return(test_ret); 927 } 928 """ % (module)) 929 930 # 931 # Generate direct module caller 932 # 933 test.write("""static int 934 test_module(const char *module) { 935 """); 936 for module in modules: 937 test.write(""" if (!strcmp(module, "%s")) return(test_%s());\n""" % ( 938 module, module)) 939 test.write(""" return(0); 940 } 941 """); 942 943 print "Generated test for %d modules and %d functions" %(len(modules), nb_tests) 944 945 compare_and_save() 946 947 missing_list = [] 948 for missing in missing_types.keys(): 949 if missing == 'va_list' or missing == '...': 950 continue; 951 952 n = len(missing_types[missing]) 953 missing_list.append((n, missing)) 954 955 def compare_missing(a, b): 956 return b[0] - a[0] 957 958 missing_list.sort(compare_missing) 959 print "Missing support for %d functions and %d types see missing.lst" % (missing_functions_nr, len(missing_list)) 960 lst = open("missing.lst", "w") 961 lst.write("Missing support for %d types" % (len(missing_list))) 962 lst.write("\n") 963 for miss in missing_list: 964 lst.write("%s: %d :" % (miss[1], miss[0])) 965 i = 0 966 for n in missing_types[miss[1]]: 967 i = i + 1 968 if i > 5: 969 lst.write(" ...") 970 break 971 lst.write(" %s" % (n)) 972 lst.write("\n") 973 lst.write("\n") 974 lst.write("\n") 975 lst.write("Missing support per module"); 976 for module in missing_functions.keys(): 977 lst.write("module %s:\n %s\n" % (module, missing_functions[module])) 978 979 lst.close() 980 981 982