def test_mergeResolvedUnresolved(self): """ Test that merging two typelibs, one of which contains an unresolved reference to an interface, and the other of which contains a resolved reference to the same interface results in keeping the resolved reference. """ # t1 has an unresolved interface, t2 has a resolved version t1 = xpt.Typelib() # add an unresolved interface t1.interfaces.append(xpt.Interface("IFoo")) t2 = xpt.Typelib() # add a resolved interface p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) t2.interfaces.append(xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m])) t1.merge(t2) self.assertEqual(1, len(t1.interfaces)) self.assertEqual("IFoo", t1.interfaces[0].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t1.interfaces[0].iid) self.assert_(t1.interfaces[0].resolved) self.assertEqual(1, len(t1.interfaces[0].methods)) self.assertEqual("Bar", t1.interfaces[0].methods[0].name) # t1 has a resolved interface, t2 has an unresolved version t1 = xpt.Typelib() # add a resolved interface p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) t1.interfaces.append(xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m])) t2 = xpt.Typelib() # add an unresolved interface t2.interfaces.append(xpt.Interface("IFoo")) t1.merge(t2) self.assertEqual(1, len(t1.interfaces)) self.assertEqual("IFoo", t1.interfaces[0].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t1.interfaces[0].iid) self.assert_(t1.interfaces[0].resolved) self.assertEqual(1, len(t1.interfaces[0].methods)) self.assertEqual("Bar", t1.interfaces[0].methods[0].name)
def test_constants(self): c = xpt.Constant("X", xpt.SimpleType(xpt.Type.Tags.uint32), 0xF000F000) i = xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", constants=[c]) t = xpt.Typelib(interfaces=[i]) self.checkRoundtrip(t) # tack on some more constants i.constants.append(xpt.Constant("Y", xpt.SimpleType(xpt.Type.Tags.int16), -30000)) i.constants.append(xpt.Constant("Z", xpt.SimpleType(xpt.Type.Tags.uint16), 0xB0B0)) i.constants.append(xpt.Constant("A", xpt.SimpleType(xpt.Type.Tags.int32), -1000000)) self.checkRoundtrip(t)
def test_mergeReplaceArrayTypeParams(self): """ Test that merging an interface correctly updates ArrayType params whose element_type is an InterfaceType on methods of other interfaces. """ # t1 has an unresolved interface and an interface that uses the # unresolved interface as a type in an ArrayType in a parameter # of a method. t2 has a resolved version of the unresolved interface. t1 = xpt.Typelib() # add an unresolved interface i = xpt.Interface("IFoo") t1.interfaces.append(i) # add an interface that uses the unresolved interface # as a type in an ArrayType in a param value in a method. vp = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) intp = xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)) p = xpt.Param(xpt.ArrayType(xpt.InterfaceType(i), 1, 2)) m = xpt.Method("ArrayIfaceParam", vp, params=[p, intp, intp]) t1.interfaces.append(xpt.Interface("IParam", iid="11111111-1111-1111-1111-111111111111", methods=[m])) t2 = xpt.Typelib() # add a resolved interface m = xpt.Method("Bar", vp) t2.interfaces.append(xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m])) t1.merge(t2) self.assertEqual(2, len(t1.interfaces)) self.assertEqual("IParam", t1.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t1.interfaces[0].iid) self.assertEqual("IFoo", t1.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t1.interfaces[1].iid) self.assert_(t1.interfaces[1].resolved) # Ensure that IRetval's method's param type has been updated. self.assertEqual(1, len(t1.interfaces[0].methods)) self.assert_(t1.interfaces[0].methods[0].params[0].type.element_type.iface.resolved) self.assertEqual(t1.interfaces[1], t1.interfaces[0].methods[0].params[0].type.element_type.iface)
def test_resolvedIdentical(self): """ Test comparison function on xpt.Interface with interfaces with identical names and IIDs, both of which are resolved. """ p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) i1 = xpt.Interface("ABC", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m]) i2 = xpt.Interface("ABC", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m]) self.assert_(i2 == i1)
def test_unresolvedResolved(self): """ Test comparison function on xpt.Interface with interfaces with identical names and IIDs but different resolved status. """ i1 = xpt.Interface("ABC", iid="11223344-5566-7788-9900-aabbccddeeff") p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) i2 = xpt.Interface("ABC", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m]) self.assert_(i2 < i1) self.assert_(i2 != i1)
def test_mergeReplaceParams(self): """ Test that merging an interface correctly updates InterfaceType params on methods of other interfaces. """ # t1 has an unresolved interface and an interface that uses the # unresolved interface as a param value in a method. t2 # has a resolved version of the unresolved interface. t1 = xpt.Typelib() # add an unresolved interface i = xpt.Interface("IFoo") t1.interfaces.append(i) # add an interface that uses the unresolved interface # as a param value in a method. vp = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) p = xpt.Param(xpt.InterfaceType(i)) m = xpt.Method("IfaceParam", vp, params=[p]) t1.interfaces.append( xpt.Interface("IParam", iid="11111111-1111-1111-1111-111111111111", methods=[m], scriptable=True)) t2 = xpt.Typelib() # add a resolved interface m = xpt.Method("Bar", vp) t2.interfaces.append( xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m], scriptable=True)) t3 = xpt.xpt_link([t1, t2]) self.assertEqual(2, len(t3.interfaces)) self.assertEqual("IParam", t3.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t3.interfaces[0].iid) self.assertEqual("IFoo", t3.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t3.interfaces[1].iid) self.assert_(t3.interfaces[1].resolved) # Ensure that IRetval's method's param type has been updated. self.assertEqual(1, len(t3.interfaces[0].methods)) self.assert_(t3.interfaces[0].methods[0].params[0].type.iface.resolved) self.assertEqual(t3.interfaces[1], t3.interfaces[0].methods[0].params[0].type.iface) # t1 has a resolved interface. t2 has an unresolved version # and an interface that uses the unresolved interface as a # param value in a method. t1 = xpt.Typelib() # add a resolved interface m = xpt.Method("Bar", vp) t1.interfaces.append( xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m], scriptable=True)) t2 = xpt.Typelib() # add an unresolved interface i = xpt.Interface("IFoo") t2.interfaces.append(i) # add an interface that uses the unresolved interface # as a param value in a method. vp = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) p = xpt.Param(xpt.InterfaceType(i)) m = xpt.Method("IfaceParam", vp, params=[p]) t2.interfaces.append( xpt.Interface("IParam", iid="11111111-1111-1111-1111-111111111111", methods=[m], scriptable=True)) t3 = xpt.xpt_link([t1, t2]) self.assertEqual(2, len(t3.interfaces)) self.assertEqual("IParam", t3.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t3.interfaces[0].iid) self.assertEqual("IFoo", t3.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t3.interfaces[1].iid) self.assert_(t3.interfaces[1].resolved) # Ensure that IRetval's method's param type has been updated. self.assertEqual(1, len(t3.interfaces[0].methods)) self.assert_(t3.interfaces[0].methods[0].params[0].type.iface.resolved) self.assertEqual(t3.interfaces[1], t3.interfaces[0].methods[0].params[0].type.iface)
def test_mergeReplaceParents(self): """ Test that merging an interface results in other interfaces' parent member being updated properly. """ # t1 has an unresolved interface, t2 has a resolved version, # but t1 also has another interface whose parent is the unresolved # interface. t1 = xpt.Typelib() # add an unresolved interface pi = xpt.Interface("IFoo") t1.interfaces.append(pi) # add a child of the unresolved interface t1.interfaces.append( xpt.Interface("IChild", iid="11111111-1111-1111-1111-111111111111", resolved=True, parent=pi, scriptable=True)) t2 = xpt.Typelib() # add a resolved interface p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) t2.interfaces.append( xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m], scriptable=True)) t3 = xpt.xpt_link([t1, t2]) self.assertEqual(2, len(t3.interfaces)) self.assertEqual("IChild", t3.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t3.interfaces[0].iid) self.assertEqual("IFoo", t3.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t3.interfaces[1].iid) self.assert_(t3.interfaces[0].resolved) # Ensure that IChild's parent has been updated self.assertEqual(t3.interfaces[1], t3.interfaces[0].parent) self.assert_(t3.interfaces[0].parent.resolved) # t1 has a resolved interface, t2 has an unresolved version, # but t2 also has another interface whose parent is the unresolved # interface. t1 = xpt.Typelib() # add a resolved interface p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) t1.interfaces.append( xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m], scriptable=True)) t2 = xpt.Typelib() # add an unresolved interface pi = xpt.Interface("IFoo") t2.interfaces.append(pi) # add a child of the unresolved interface t2.interfaces.append( xpt.Interface("IChild", iid="11111111-1111-1111-1111-111111111111", resolved=True, parent=pi, scriptable=True)) t3 = xpt.xpt_link([t1, t2]) self.assertEqual(2, len(t3.interfaces)) self.assertEqual("IChild", t3.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t3.interfaces[0].iid) self.assertEqual("IFoo", t3.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t3.interfaces[1].iid) self.assert_(t3.interfaces[0].resolved) # Ensure that IChild's parent has been updated self.assertEqual(t3.interfaces[1], t3.interfaces[0].parent) self.assert_(t3.interfaces[0].parent.resolved)
def test_methods(self): p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) i = xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m]) t = xpt.Typelib(interfaces=[i]) self.checkRoundtrip(t) # add some more methods i.methods.append( xpt.Method("One", xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), params=[ xpt.Param(xpt.SimpleType(xpt.Type.Tags.int64)), xpt.Param( xpt.SimpleType(xpt.Type.Tags.float, pointer=True)) ])) self.checkRoundtrip(t) # test some other types (should really be more thorough) i.methods.append( xpt.Method("Two", xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), params=[ xpt.Param( xpt.SimpleType(xpt.Type.Tags.UTF8String, pointer=True)), xpt.Param( xpt.SimpleType(xpt.Type.Tags.wchar_t_ptr, pointer=True)) ])) self.checkRoundtrip(t) # add a method with an InterfaceType argument bar = xpt.Interface("IBar") t.interfaces.append(bar) i.methods.append( xpt.Method("IFaceMethod", xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), params=[xpt.Param(xpt.InterfaceType(bar))])) self.checkRoundtrip(t) # add a method with an InterfaceIsType argument i.methods.append( xpt.Method("IFaceIsMethod", xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)), params=[ xpt.Param(xpt.InterfaceIsType(1)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.nsIID)) ])) self.checkRoundtrip(t) # add a method with an ArrayType argument i.methods.append( xpt.Method("ArrayMethod", xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)), params=[ xpt.Param( xpt.ArrayType( xpt.SimpleType(xpt.Type.Tags.int32), 1, 2)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), ])) self.checkRoundtrip(t) # add a method with a StringWithSize and WideStringWithSize arguments i.methods.append( xpt.Method("StringWithSizeMethod", xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)), params=[ xpt.Param(xpt.StringWithSizeType(1, 2)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), xpt.Param(xpt.WideStringWithSizeType(4, 5)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), xpt.Param(xpt.SimpleType(xpt.Type.Tags.int32)), ])) self.checkRoundtrip(t)
def test_mergeReplaceRetval(self): """ Test that merging an interface correctly updates InterfaceType return values on methods of other interfaces. """ # t1 has an unresolved interface and an interface that uses the # unresolved interface as a return value from a method. t2 # has a resolved version of the unresolved interface. t1 = xpt.Typelib() # add an unresolved interface i = xpt.Interface("IFoo") t1.interfaces.append(i) # add an interface that uses the unresolved interface # as a return value in a method. p = xpt.Param(xpt.InterfaceType(i)) m = xpt.Method("ReturnIface", p) t1.interfaces.append( xpt.Interface("IRetval", iid="11111111-1111-1111-1111-111111111111", methods=[m])) t2 = xpt.Typelib() # add a resolved interface p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) t2.interfaces.append( xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m])) t1.merge(t2) self.assertEqual(2, len(t1.interfaces)) self.assertEqual("IRetval", t1.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t1.interfaces[0].iid) self.assertEqual("IFoo", t1.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t1.interfaces[1].iid) self.assert_(t1.interfaces[1].resolved) # Ensure that IRetval's method's return value type has been updated. self.assertEqual(1, len(t1.interfaces[0].methods)) self.assert_(t1.interfaces[0].methods[0].result.type.iface.resolved) self.assertEqual(t1.interfaces[1], t1.interfaces[0].methods[0].result.type.iface) # t1 has a resolved interface. t2 has an unresolved version and # an interface that uses the unresolved interface as a return value # from a method. t1 = xpt.Typelib() # add a resolved interface p = xpt.Param(xpt.SimpleType(xpt.Type.Tags.void)) m = xpt.Method("Bar", p) t1.interfaces.append( xpt.Interface("IFoo", iid="11223344-5566-7788-9900-aabbccddeeff", methods=[m])) t2 = xpt.Typelib() # add an unresolved interface i = xpt.Interface("IFoo") t2.interfaces.append(i) # add an interface that uses the unresolved interface # as a return value in a method. p = xpt.Param(xpt.InterfaceType(i)) m = xpt.Method("ReturnIface", p) t2.interfaces.append( xpt.Interface("IRetval", iid="11111111-1111-1111-1111-111111111111", methods=[m])) t1.merge(t2) self.assertEqual(2, len(t1.interfaces)) self.assertEqual("IRetval", t1.interfaces[0].name) self.assertEqual("11111111-1111-1111-1111-111111111111", t1.interfaces[0].iid) self.assertEqual("IFoo", t1.interfaces[1].name) self.assertEqual("11223344-5566-7788-9900-aabbccddeeff", t1.interfaces[1].iid) self.assert_(t1.interfaces[1].resolved) # Ensure that IRetval's method's return value type has been updated. self.assertEqual(1, len(t1.interfaces[0].methods)) self.assert_(t1.interfaces[0].methods[0].result.type.iface.resolved) self.assertEqual(t1.interfaces[1], t1.interfaces[0].methods[0].result.type.iface)
def get_nsresult(): return xpt.SimpleType(TypeMap['nsresult'])
def get_type(type, calltype, iid_is=None, size_is=None): """ Return the appropriate xpt.Type object for this param """ if isinstance(type, xpidl.Typedef): type = type.realtype if isinstance(type, xpidl.Builtin): if type.name == 'string' and size_is != None: return xpt.StringWithSizeType(size_is, size_is) elif type.name == 'wstring' and size_is != None: return xpt.WideStringWithSizeType(size_is, size_is) else: tag = TypeMap[type.name] isPtr = (tag == xpt.Type.Tags.char_ptr or tag == xpt.Type.Tags.wchar_t_ptr) return xpt.SimpleType( tag, pointer=isPtr, #XXXkhuey unique_pointer is completely unused (bug 677787.) reference=False) if isinstance(type, xpidl.Array): return xpt.ArrayType( get_type(type.type, calltype), size_is, #XXXkhuey length_is duplicates size_is (bug 677788), size_is) if isinstance(type, xpidl.Interface) or isinstance( type, xpidl.Forward): xptiface = None for i in ifaces: if i.name == type.name: xptiface = i if not xptiface: xptiface = xpt.Interface(name=type.name) ifaces.append(xptiface) return xpt.InterfaceType(xptiface) if isinstance(type, xpidl.Native): if type.specialtype: # XXXkhuey jsval is marked differently in the typelib and in the headers :-( isPtr = (type.isPtr(calltype) or type.isRef(calltype) ) and not type.specialtype == 'jsval' isRef = type.isRef( calltype) and not type.specialtype == 'jsval' return xpt.SimpleType( TypeMap[type.specialtype], pointer=isPtr, #XXXkhuey unique_pointer is completely unused reference=isRef) elif iid_is != None: return xpt.InterfaceIsType(iid_is) else: # void ptr return xpt.SimpleType( TypeMap['void'], pointer=True, #XXXkhuey unique_pointer is completely unused reference=False) raise Exception("Unknown type!")