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:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gentest.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2