import sys import weakref import gc import os.path import copy sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'build', 'default', 'tests')) which = int(sys.argv[1]) del sys.argv[1] if which == 1: import foo elif which == 2: import foo2 as foo elif which == 3: import foo3 as foo elif which == 4: import foo4 as foo else: raise AssertionError("bad command line arguments") import unittest class TestFoo(unittest.TestCase): def test_add_prefix(self): obj = foo.SomeObject("hello ") ln, msg = obj.add_prefix("gjc") self.assertEqual(msg, "hello gjc") self.assertEqual(ln, len("hello gjc")) def test_foo(self): f = foo.Foo("hello") self.assertEqual(f.get_datum(), "hello") def test_pass_foo_by_value(self): obj = foo.SomeObject("") f = foo.Foo("hello") obj.set_foo_value(f) f2 = obj.get_foo_value() self.assertEqual(f2.get_datum(), "hello") def test_pass_foo_by_transfer_ptr(self): obj = foo.SomeObject("") f = foo.Foo("hello") obj.set_foo_ptr(f) del f f2 = obj.get_foo_ptr() self.assertEqual(f2.get_datum(), "hello") def test_pass_foo_shared_ptr(self): obj = foo.SomeObject("") f = foo.Foo("hello") obj.set_foo_shared_ptr(f) self.assertEqual(f.get_datum(), "hello") f2 = obj.get_foo_shared_ptr() self.assertEqual(f2.get_datum(), "hello") def test_pass_by_reference(self): obj = foo.SomeObject("") f = foo.Foo("hello") obj.set_foo_by_ref(f) self.assertEqual(f.get_datum(), "hello") f2 = obj.get_foo_by_ref() self.assertEqual(f2.get_datum(), "hello") def test_refcounting(self): obj = foo.SomeObject("") z = foo.Zbr("hello") obj.set_zbr_transfer(z) self.assertEqual(z.get_datum(), "hello") z2 = obj.get_zbr() self.assertEqual(z2.get_datum(), "hello") z3 = obj.get_zbr() self.assertEqual(z3.get_datum(), "hello") zz = foo.Zbr("world") self.assertEqual(zz.get_datum(), "world") obj.set_zbr_shared(zz) ## previous z's should not have been changed self.assertEqual(z.get_datum(), "hello") self.assertEqual(z2.get_datum(), "hello") self.assertEqual(z3.get_datum(), "hello") self.assertEqual(zz.get_datum(), "world") zz2 = obj.get_zbr() self.assertEqual(zz2.get_datum(), "world") zz3 = obj.peek_zbr() self.assertEqual(zz3.get_datum(), "world") def test_instance_get_attribute(self): obj = foo.SomeObject("Hello") self.assertEqual(obj.m_prefix, "Hello") def test_instance_set_attribute(self): obj = foo.SomeObject("") obj.m_prefix = "World" self.assertEqual(obj.m_prefix, "World") def test_static_get_attribute(self): self.assertEqual(foo.SomeObject.staticData, "Hello Static World!") def test_static_set_attribute(self): foo.SomeObject.staticData = "Foo Bar Zbr" self.assertEqual(foo.SomeObject.staticData, "Foo Bar Zbr") def test_overloaded_functions(self): v1 = foo.get_int(123.0) self.assertEqual(v1, 123) v2 = foo.get_int("123") self.assertEqual(v2, 123) self.assertRaises(TypeError, foo.get_int, [123]) def test_default_value(self): v1 = foo.get_int(123.0) self.assertEqual(v1, 123) v1 = foo.get_int(123.0, 2) self.assertEqual(v1, 123*2) def test_overloaded_methods(self): obj = foo.SomeObject("zbr") v1 = obj.get_int(123.0) self.assertEqual(v1, 123) v2 = obj.get_int("123") self.assertEqual(v2, 123) self.assertRaises(TypeError, obj.get_int, [123]) def test_overloaded_constructors(self): obj1 = foo.SomeObject("zbr") self.assertEqual(obj1.get_prefix(), "zbr") obj2 = foo.SomeObject(5) self.assertEqual(obj2.get_prefix(), "XXXXX") self.assertRaises(TypeError, foo.SomeObject, [123]) def test_return_type_narrowing(self): obj = foo.SomeObject("zbr") obj.set_foo_ptr(foo.Foo()) foo1 = obj.get_foo_ptr() self.assertEqual(type(foo1), foo.Foo) bar2 = foo.Bar() self.assertEqual(type(bar2), foo.Bar) obj.set_foo_ptr(bar2) foo2 = obj.get_foo_ptr() self.assertEqual(type(foo2), foo.Bar) def test_type_narrowing_hidden_subclass(self): """This test only works with GCC >= 3.0 (and not with other compilers)""" obj = foo.get_hidden_subclass_pointer() self.assertEqual(type(obj), foo.Bar) def test_subclass_gc(self): """Check if subclassed object is garbage collected""" try: class Test(foo.SomeObject): pass except TypeError: self.fail() while gc.collect(): pass count_before = foo.SomeObject.instance_count t = Test("xxx") t.xxx = t ref = weakref.ref(t) del t while gc.collect(): pass self.assertEqual(ref(), None) self.assertEqual(foo.SomeObject.instance_count, count_before) def test_nosubclass_gc(self): """Check if subclassable object is garbage collected""" while gc.collect(): pass count_before = foo.SomeObject.instance_count t = foo.SomeObject("xxx") t.xxx = t del t while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, count_before) def test_virtual_no_subclass(self): t = foo.SomeObject("xxx") self.assertEqual(t.call_get_prefix(), "xxx") def test_virtual_subclass(self): class Test(foo.SomeObject): def get_prefix(self): return "yyy" t = Test("xxx") self.assertEqual(t.call_get_prefix(), "yyy") def test_virtual_with_chaining_to_parent_class(self): class Test(foo.SomeObject): def get_prefix(self): prefix = super(Test, self).get_prefix() return prefix + "yyy" t = Test("xxx") self.assertEqual(t.call_get_prefix(), "xxxyyy") def test_subclassable_transfer_ptr(self): while gc.collect(): pass count_before = foo.SomeObject.instance_count obj = foo.SomeObject("xxx") foo.store_some_object(obj) del obj while gc.collect(): pass ## check that SomeObject isn't prematurely deleted self.assertEqual(foo.SomeObject.instance_count, count_before + 1) ## now delete the object from the C side.. foo.delete_some_object() while gc.collect(): pass ## check that SomeObject was finally deleted self.assertEqual(foo.SomeObject.instance_count, count_before) def test_subclassable_store_and_take_back(self): while gc.collect(): pass count_before = foo.SomeObject.instance_count obj = foo.SomeObject("xxx") foo.store_some_object(obj) del obj while gc.collect(): pass ## check that SomeObject isn't prematurely deleted self.assertEqual(foo.SomeObject.instance_count, count_before + 1) ## now get the object back from the C side.. obj = foo.take_some_object() self.assertEqual(obj.get_prefix(), "xxx") del obj while gc.collect(): pass ## check that SomeObject was finally deleted self.assertEqual(foo.SomeObject.instance_count, count_before) def test_subclass_with_virtual_transfer_ptr(self): class Test(foo.SomeObject): def __init__(self, prefix, extra_prefix): super(Test, self).__init__(prefix) self.extra_prefix = extra_prefix def get_prefix(self): prefix = super(Test, self).get_prefix() return prefix + self.extra_prefix while gc.collect(): pass count_before = foo.SomeObject.instance_count foo.store_some_object(Test("xxx", "yyy")) while gc.collect(): pass ## check that SomeObject isn't prematurely deleted self.assertEqual(foo.SomeObject.instance_count, count_before + 1) ## invoke the virtual method and check that it returns the correct value prefix = foo.invoke_some_object_get_prefix() self.assertEqual(prefix, "xxxyyy") ## now delete the object from the C side.. foo.delete_some_object() while gc.collect(): pass ## check that SomeObject was finally deleted self.assertEqual(foo.SomeObject.instance_count, count_before) def test_subclassed_store_and_take_back(self): class Test(foo.SomeObject): pass while gc.collect(): pass count_before = foo.SomeObject.instance_count obj1 = Test("xxx") obj1.attribute = 123 foo.store_some_object(obj1) ## now get the object back from the C side.. obj2 = foo.take_some_object() self.assert_(obj2 is obj1) self.assertEqual(obj2.attribute, 123) self.assertEqual(obj2.get_prefix(), "xxx") del obj1, obj2 while gc.collect(): pass ## check that SomeObject was finally deleted self.assertEqual(foo.SomeObject.instance_count, count_before) def test_namespaced_function(self): self.assertEqual(foo.xpto.some_function(), "hello") def test_namespaced_class(self): self.assert_(hasattr(foo.xpto, 'SomeClass')) def test_implicit_conversion_method_value(self): obj = foo.SomeObject("xxx") zoo1 = foo.Zoo("zpto") try: obj.set_foo_value(zoo1) except TypeError: self.fail() foo1 = obj.get_foo_value() self.assertEqual(foo1.get_datum(), "zpto") def test_implicit_conversion_function_value(self): zoo1 = foo.Zoo("zpto") try: foo.function_that_takes_foo(zoo1) except TypeError: self.fail() foo1 = foo.function_that_returns_foo() self.assertEqual(foo1.get_datum(), "zpto") def test_implicit_conversion_constructor_value(self): zoo1 = foo.Zoo("zpto") try: obj = foo.ClassThatTakesFoo(zoo1) except TypeError: self.fail() foo1 = obj.get_foo() self.assertEqual(foo1.get_datum(), "zpto") def test_custodian_method_self(self): while gc.collect(): pass SomeObject_count_before = foo.SomeObject.instance_count obj1 = foo.SomeObject("xxx") Foobar_count1 = foo.Foobar.instance_count # get once foo1 = obj1.get_foobar_with_self_as_custodian() Foobar_count2 = foo.Foobar.instance_count self.assertEqual(Foobar_count2, Foobar_count1 + 1) # get another time, the C++ object should be the same foo2 = obj1.get_foobar_with_self_as_custodian() Foobar_count3 = foo.Foobar.instance_count self.assertEqual(Foobar_count3, Foobar_count2) ## now, deleting foo1 should keep the Foobar count the same, since ## obj1 is keeping it alive del foo1, foo2 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) ## now deleting obj1 should cause both foo1 and obj1 to be destroyed del obj1 while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before) self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_custodian_method_other(self): while gc.collect(): pass SomeObject_count_before = foo.SomeObject.instance_count Foobar_count1 = foo.Foobar.instance_count obj1 = foo.SomeObject("xxx") obj2 = foo.SomeObject("yyy") foo1 = obj1.get_foobar_with_other_as_custodian(obj2) while gc.collect(): pass Foobar_count2 = foo.Foobar.instance_count ## now, deleting foo1 should keep Foobar count the same, since ## obj2 is keeping it alive del foo1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) ## deleting obj1 should still keep Foobar count the same, since ## obj2, not obj1, is keeping it alive del obj1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before + 1) ## now deleting obj2 should cause both foo1 and obj2 to be destroyed del obj2 while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before) self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_custodian_function_other(self): while gc.collect(): pass SomeObject_count_before = foo.SomeObject.instance_count Foobar_count1 = foo.Foobar.instance_count obj1 = foo.SomeObject("xxx") foo1 = foo.get_foobar_with_other_as_custodian(obj1) Foobar_count2 = foo.Foobar.instance_count ## now, deleting foo1 should keep Foobar count the same, since ## obj1 is keeping it alive del foo1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) ## now deleting obj1 should cause both foo1 and obj1 to be destroyed del obj1 while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before) self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_custodian_function_param_other(self): while gc.collect(): pass SomeObject_count_before = foo.SomeObject.instance_count Foobar_count1 = foo.Foobar.instance_count obj1 = foo.SomeObject("xxx") foo1 = foo.create_new_foobar() foo.set_foobar_with_other_as_custodian(foo1, obj1) Foobar_count2 = foo.Foobar.instance_count ## now, deleting foo1 should keep Foobar count the same, since ## obj1 is keeping it alive del foo1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) ## now deleting obj1 should cause both foo1 and obj1 to be destroyed del obj1 while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before) self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_custodian_function_param_return(self): while gc.collect(): pass SomeObject_count_before = foo.SomeObject.instance_count Foobar_count1 = foo.Foobar.instance_count foo1 = foo.create_new_foobar() obj1 = foo.set_foobar_with_return_as_custodian(foo1) Foobar_count2 = foo.Foobar.instance_count ## now, deleting foo1 should keep Foobar count the same, since ## obj1 is keeping it alive del foo1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) ## now deleting obj1 should cause both foo1 and obj1 to be destroyed del obj1 while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before) self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_custodian_method_param_self(self): while gc.collect(): pass SomeObject_count_before = foo.SomeObject.instance_count obj1 = foo.SomeObject("xxx") Foobar_count1 = foo.Foobar.instance_count foo1 = foo.create_new_foobar() obj1.set_foobar_with_self_as_custodian(foo1) Foobar_count2 = foo.Foobar.instance_count self.assertEqual(Foobar_count2, Foobar_count1 + 1) ## now, deleting foo1 should keep the Foobar count the same, since ## obj1 is keeping it alive del foo1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count2) ## now deleting obj1 should cause both foo1 and obj1 to be destroyed del obj1 while gc.collect(): pass self.assertEqual(foo.SomeObject.instance_count, SomeObject_count_before) self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_subclass_with_virtual_with_foo_parameter_value(self): class Test(foo.SomeObject): def __init__(self, prefix, extra_prefix): super(Test, self).__init__(prefix) self.extra_prefix = extra_prefix def get_prefix_with_foo_value(self, fooval): prefix = super(Test, self).get_prefix_with_foo_value(fooval) return prefix + self.extra_prefix + fooval.get_datum() t = Test("123", "456") foo1 = foo.Foo("zbr") prefix = t.get_prefix_with_foo_value(foo1) self.assertEqual(prefix, "123zbr456zbr") def test_subclass_with_virtual_with_foo_parameter_ref(self): class Test(foo.SomeObject): def __init__(self, prefix, extra_prefix): super(Test, self).__init__(prefix) self.extra_prefix = extra_prefix def get_prefix_with_foo_ref(self, fooval): prefix = super(Test, self).get_prefix_with_foo_ref(fooval) return prefix + self.extra_prefix + fooval.get_datum() t = Test("123", "456") foo1 = foo.Foo("zbr") prefix = t.get_prefix_with_foo_ref(foo1) self.assertEqual(prefix, "123zbr456zbr") def test_subclass_with_virtual_with_foo_parameter_ptr(self): class Test(foo.SomeObject): def __init__(self, prefix, extra_prefix): super(Test, self).__init__(prefix) self.extra_prefix = extra_prefix def get_prefix_with_foo_ptr(self, fooval): prefix = super(Test, self).get_prefix_with_foo_ptr(fooval) return prefix + self.extra_prefix + fooval.get_datum() t = Test("123", "456") foo1 = foo.Foo("zbr") prefix = t.get_prefix_with_foo_ptr(foo1) self.assertEqual(prefix, "123zbr456zbr") def test_attribute_with_getset(self): obj = foo.SomeObject("") f1 = foo.Foo("hello") obj.foo = f1 f2 = obj.foo self.assertEqual(f2.get_datum(), "hello") def test_function_as_method(self): while gc.collect(): pass obj = foo.SomeObject("xpto") self.assertEqual(obj.get_something_prefixed("something"), "xptosomething") del obj while gc.collect(): pass def test_function_as_method_val(self): while gc.collect(): pass obj = foo.SomeObject("xpto") self.assertEqual(obj.val_get_something_prefixed("something"), "xptosomething") del obj while gc.collect(): pass def test_function_as_method_ref(self): while gc.collect(): pass obj = foo.SomeObject("xpto") self.assertEqual(obj.ref_get_something_prefixed("something"), "xptosomething") while gc.collect(): pass def test_enum(self): foo.xpto.set_foo_type(foo.xpto.FOO_TYPE_BBB) self.assertEqual(foo.xpto.get_foo_type(), foo.xpto.FOO_TYPE_BBB) old = foo.xpto.set_foo_type_inout(foo.xpto.FOO_TYPE_CCC) self.assertEqual(old, foo.xpto.FOO_TYPE_BBB) old = foo.xpto.set_foo_type_ptr(foo.xpto.FOO_TYPE_AAA) self.assertEqual(old, foo.xpto.FOO_TYPE_CCC) def test_virtual_overload(self): ## first test the plain object obj = foo.SomeObject("") self.assertEqual(obj.get_something(), "something") self.assertEqual(obj.get_something(123), "123") ## now subclass it class MyObject(foo.SomeObject): def get_something(self, arg=None): self.arg = arg return str(arg) obj = MyObject("") s1 = obj.get_something() self.assertEqual(s1, "None") self.assertEqual(obj.arg, None) s2 = obj.get_something(123) self.assertEqual(s2, "123") self.assertEqual(obj.arg, 123) def test_nested_class(self): if not hasattr(foo.SomeObject, "NestedClass"): self.fail() f = foo.SomeObject.NestedClass("hello") self.assertEqual(f.get_datum(), "hello") def test_nested_enum(self): self.assert_(hasattr(foo.SomeObject, "FOO_TYPE_BBB")) def test_private_virtual(self): class Class(foo.AbstractBaseClass2): def private_virtual(self, x): return x*x c = Class() x = c.invoke_private_virtual(2) self.assertEqual(x, 4) def test_protected_virtual(self): class Class(foo.AbstractBaseClass2): def private_virtual(self, x): return x*x def protected_virtual(self, x): y = super(Class, self).protected_virtual(x) return y*y c = Class() x = c.invoke_protected_virtual(2) self.assertEqual(x, 9) def test_protected_pure_virtual(self): class Class(foo.AbstractBaseClass2): def protected_pure_virtual(self, x): return x*x+1 c = Class() x = c.invoke_protected_pure_virtual(2) self.assertEqual(x, 5) def test_subclass_with_reference_counting(self): class Test(foo.Zbr): def __init__(self, y): super(Test, self).__init__("foo") self.y = y def get_int(self, x): return getattr(self, 'y', 0) + x while gc.collect(): pass count_before = foo.Zbr.instance_count foo.store_zbr(Test(123)) while gc.collect(): pass ## check that Zbr isn't prematurely deleted self.assertEqual(foo.Zbr.instance_count, count_before + 1) ## invoke the virtual method and check that it returns the correct value value = foo.invoke_zbr(456) self.assertEqual(value, 123+456) ## now delete the object from the C side.. foo.delete_stored_zbr() while gc.collect(): pass ## check that Zbr was finally deleted self.assertEqual(foo.Zbr.instance_count, count_before) def test_custom_function_wrapper(self): try: foo.function_that_takes_foo("yellow") except TypeError: self.fail() foo1 = foo.function_that_returns_foo() self.assertEqual(foo1.get_datum(), "yellow") def test_custom_method_wrapper(self): v1 = foo.Bar.Hooray() self.assertEqual(v1, "Hooray!") try: v2 = foo.Bar.Hooray(123) # this one is a fake method except TypeError: self.fail() else: self.assertEqual(v2, len("Hooray!") + 123) def test_instance_creation_function(self): f = foo.Foo() self.assert_(f.is_initialized()) b = foo.Bar() self.assert_(b.is_initialized()) def test_pure_virtual(self): self.assertRaises(TypeError, foo.AbstractXpto) try: foo.AbstractXptoImpl() except TypeError, ex: self.fail(str(ex)) def test_parameter_default_value(self): x = foo.get_int("123") self.assertEqual(x, 123) y = foo.get_int("123", 2) self.assertEqual(y, 246) def test_anonymous_struct(self): """https://bugs.launchpad.net/pybindgen/+bug/237054""" word = foo.Word() word.word = 1 self.assertEqual(word.word, 1) word.low = 2 word.high = 3 self.assertEqual(word.low, 2) self.assertEqual(word.high, 3) def test_float_array(self): array = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] s = foo.matrix_sum_of_elements(array) self.assertEqual(s, sum(array)) result = foo.matrix_identity_new() expected = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0] self.assertEqual(result, expected) def test_output_stream(self): f = foo.Foo("hello") self.assertEqual(str(f), "hello") def test_outer_inner_namespace(self): inner = foo.TopNs.PrefixBottomNs.PrefixInner () inner.Do () self.assertEqual (True, True) def test_overloaded_methods_and_inheritance(self): """https://bugs.launchpad.net/pybindgen/+bug/246069""" sock = foo.Socket() self.assertEqual(sock.Bind(), -1) self.assertEqual(sock.Bind(123), 123) udpsock = foo.UdpSocket() self.assertEqual(udpsock.Bind(), 0) try: self.assertEqual(udpsock.Bind(123), 123) except TypeError, ex: pass else: self.fail("UdpSocket.Bind(int) was not supposed to work") def test_struct(self): struct = foo.simple_struct_t() struct.xpto = 123 self.assertEqual(struct.xpto, 123) def test_typedef(self): try: f = foo.xpto.FooXpto("hello") except AttributeError: self.fail() try: r = foo.xpto.get_foo_datum(f) except TypeError: self.fail() self.assertEqual(r, "hello") if 0: def test_deprecations(self): foo.print_something("zbr") def test_anon_enum(self): try: self.assertEqual(foo.SomeObject.CONSTANT_A, 0) except AttributeError: self.fail() def test_template_function(self): if not hasattr(foo, 'IntegerTypeNameGet'): self.fail() else: self.assertEqual(foo.IntegerTypeNameGet(), 'int') def test_operator_call(self): obj = foo.SomeObject("xpto_") l, s = obj("hello") self.assertEqual(s, "xpto_hello") self.assertEqual(l, len("xpto_hello")) def test_container_value_return_param(self): container = foo.get_simple_list() count = 0 for i, simple in enumerate(container): self.assertEqual(simple.xpto, i) count += 1 self.assertEqual(count, 10) #self.assertEqual(len(container), 10) rv = foo.set_simple_list(container) self.assertEqual(rv, sum(range(10))) def test_container_creation(self): container = foo.SimpleStructList() values = list(container) self.assertEqual(values, []) l = [] for i in range(10): simple = foo.simple_struct_t() simple.xpto = i l.append(simple) container = foo.SimpleStructList(l) values = list(container) self.assertEqual(len(values), 10) for i, value in enumerate(values): self.assertEqual(value.xpto, i) rv = foo.set_simple_list(l) self.assertEqual(rv, sum(range(10))) def test_container_reverse_wrappers(self): class MyTestContainer(foo.TestContainer): def __init__(self): super(MyTestContainer, self).__init__() self.list_that_was_set = None def get_simple_list(self): l = [] for i in range(5): simple = foo.simple_struct_t() simple.xpto = i l.append(simple) #container = foo.SimpleStructList(l) return l def set_simple_list(self, container): self.list_that_was_set = container return sum([s.xpto for s in container]) test = MyTestContainer() container = test.get_simple_list() count = 0 for i, simple in enumerate(container): self.assertEqual(simple.xpto, i) count += 1 self.assertEqual(count, 5) ## set l = [] for i in range(5): simple = foo.simple_struct_t() simple.xpto = i l.append(simple) rv = test.set_simple_list(l) self.assertEqual(rv, sum(range(5))) count = 0 for i, simple in enumerate(test.list_that_was_set): self.assertEqual(simple.xpto, i) count += 1 self.assertEqual(count, 5) def test_container_param_by_ref(self): l = [] expected_sum = 0 for i in range(10): simple = foo.simple_struct_t() simple.xpto = i l.append(simple) expected_sum += i*2 test = foo.TestContainer() rv, container = test.set_simple_list_by_ref(l) l1 = list(container) self.assertEqual(rv, expected_sum) self.assertEqual(len(l1), len(l)) for v, v1 in zip(l, l1): self.assertEqual(v1.xpto, 2*v.xpto) def test_unnamed_container(self): test = foo.TestContainer() container = test.get_simple_vec() count = 0 for i, simple in enumerate(container): self.assertEqual(simple.xpto, i) count += 1 self.assertEqual(count, 10) rv = test.set_simple_vec(container) self.assertEqual(rv, sum(range(10))) def test_map_container(self): test = foo.TestContainer() container = test.get_simple_map() count = 0 for i, (simple_key, simple_val) in enumerate(container): self.assertEqual(simple_key, str(i)) self.assertEqual(simple_val.xpto, i) count += 1 self.assertEqual(count, 10) rv = test.set_simple_map(container) self.assertEqual(rv, sum(range(10))) def test_copy(self): s1 = foo.simple_struct_t() s1.xpto = 123 # copy via constructor s2 = foo.simple_struct_t(s1) self.assertEqual(s2.xpto, 123) s2.xpto = 321 self.assertEqual(s2.xpto, 321) self.assertEqual(s1.xpto, 123) # copy via __copy__ s3 = copy.copy(s1) self.assertEqual(s3.xpto, 123) s3.xpto = 456 self.assertEqual(s3.xpto, 456) self.assertEqual(s1.xpto, 123) def test_refcounting_v2(self): while gc.collect(): pass zbr_count_before = foo.Zbr.instance_count obj = foo.SomeObject("") z1 = obj.get_internal_zbr() z2 = obj.get_internal_zbr() self.assert_(z1 is z2) del obj, z1, z2 while gc.collect(): pass zbr_count_after = foo.Zbr.instance_count self.assertEqual(zbr_count_after, zbr_count_before) def test_refcounting_v3(self): zbr_count_before = foo.Zbr.instance_count class MyZbr(foo.Zbr): pass z_in = MyZbr() obj = foo.SomeObject("") obj.set_zbr_transfer(z_in) del z_in z1 = obj.get_zbr() z2 = obj.get_zbr() self.assert_(z1 is z2) del obj, z1, z2 while gc.collect(): pass zbr_count_after = foo.Zbr.instance_count self.assertEqual(zbr_count_after, zbr_count_before) def test_refcounting_v4(self): # same as v3 but using peek_zbr instead of get_zbr zbr_count_before = foo.Zbr.instance_count class MyZbr(foo.Zbr): pass z_in = MyZbr() obj = foo.SomeObject("") obj.set_zbr_transfer(z_in) del z_in z1 = obj.peek_zbr() z2 = obj.peek_zbr() self.assert_(z1 is z2) del obj, z1, z2 while gc.collect(): pass zbr_count_after = foo.Zbr.instance_count self.assertEqual(zbr_count_after, zbr_count_before) def test_out_intptr(self): zbr = foo.Zbr() v1, v2 = zbr.get_value() self.assertEqual(v1, -1) self.assertEqual(v2, 123) def test_scan_containers_in_attributes(self): t = foo.TestContainer() v = list(t.m_floatSet) self.assertEqual(v, [1,2,3]) def test_out_vec(self): t = foo.TestContainer() v = list(t.get_vec()) self.assertEqual(v, ["hello", "world"]) def test_ptr_vec(self): t = foo.TestContainer() t.set_vec_ptr(["hello", "world"]) r = t.get_vec_ptr() self.assertEqual(list(r), ["hello", "world"]) def test_richcompare(self): t1 = foo.Tupl() t1.x = 1 t1.y = 1 t2 = foo.Tupl() t2.x = 1 t2.y = 1 t3 = foo.Tupl() t3.x = 1 t3.y = 2 self.assert_(t1 == t2) self.assert_(not (t1 != t2)) self.assert_(t1 <= t2) self.assert_(t1 >= t2) self.assert_(t3 >= t2) self.assert_(t3 > t2) self.assert_(t2 <= t3) self.assert_(t2 < t3) self.assert_(t2 != t3) self.assert_(not(t2 == t3)) def test_numeric_operators(self): t1 = foo.Tupl() t1.x = 4 t1.y = 6 t2 = foo.Tupl() t2.x = 2 t2.y = 3 r = t1 + t2 self.assertEqual(r.x, t1.x + t2.x) self.assertEqual(r.y, t1.y + t2.y) r = t1 - t2 self.assertEqual(r.x, t1.x - t2.x) self.assertEqual(r.y, t1.y - t2.y) r = t1 * t2 self.assertEqual(r.x, t1.x * t2.x) self.assertEqual(r.y, t1.y * t2.y) r = t1 / t2 self.assertEqual(r.x, t1.x / t2.x) self.assertEqual(r.y, t1.y / t2.y) def test_inplace_numeric_operators(self): t1 = foo.Tupl() t1.x = 4 t1.y = 6 t2 = foo.Tupl() t2.x = 2 t2.y = 3 t1 += t2 self.assertEqual(t1.x, 6) self.assertEqual(t1.y, 9) t1 -= t2 self.assertEqual(t1.x, 4) self.assertEqual(t1.y, 6) t1 *= t2 self.assertEqual(t1.x, 8) self.assertEqual(t1.y, 18) t1 /= t2 self.assertEqual(t1.x, 4) self.assertEqual(t1.y, 6) t1 += 3 self.assertEqual(t1.x, 7) self.assertEqual(t1.y, 9) def test_unary_numeric_operators(self): t1 = foo.Tupl() t1.x = 4 t1.y = 6 t2 = -t1 self.assertEqual(t2.x, -4) self.assertEqual(t2.y, -6) def test_int_typedef(self): rv = foo.xpto.get_flow_id(123) self.assertEqual(rv, 124) def test_virtual_method_reference_parameter(self): class MyReferenceManipulator(foo.ReferenceManipulator): def do_manipulate_object(self, obj): obj.SetValue(12345) manip = MyReferenceManipulator() retval = manip.manipulate_object() self.assertEqual(retval, 12345) def test_sequence_protocol(self): vec = foo.VectorLike() vec.append(1) vec.append(2) vec.append(3) self.assertEqual(len(vec), 3) self.assertEqual(vec[2], 3) vec[2] = 6 self.assertEqual(vec[2], 6) def test_class_with_iterator_protocol(self): vec = foo.VectorLike2() vec.append(1) vec.append(2) vec.append(3) i = iter(vec) l = list(i) self.assertEqual(l, [1,2,3]) def test_class_with_mapping_iterator_protocol(self): map = foo.MapLike() map.set(1, 1.5) map.set(2, 2.5) map.set(3, 3.5) i = iter(map) l = list(i) self.assertEqual(l, [(1, 1.5), (2, 2.5), (3, 3.5)]) def test_function_exception(self): y = foo.my_inverse_func(2) self.assertEqual(y, 0.5) self.assertRaises(foo.DomainError, foo.my_inverse_func, 0) def test_method_exception(self): c = foo.ClassThatThrows(1) y = c.my_inverse_method(2) self.assertEqual(y, 0.5) self.assertRaises(foo.DomainError, c.my_inverse_method, 0) def test_constructor_exceptions(self): c = foo.ClassThatThrows(1) self.assertRaises(foo.DomainError, foo.ClassThatThrows, 0) def test_function_exception2(self): y = foo.my_inverse_func2(2) self.assertEqual(y, 0.5) self.assertRaises(foo.exception, foo.my_inverse_func2, 0) try: foo.my_inverse_func2(0) except foo.exception, ex: msg = str(ex) self.assertEqual(msg, "value must be != 0") def test_method_exception2(self): c = foo.ClassThatThrows(1) y = c.my_inverse_method2(2) self.assertEqual(y, 0.5) self.assertRaises(foo.exception, c.my_inverse_method2, 0) try: c.my_inverse_method2(0) except foo.exception, ex: msg = str(ex) self.assertEqual(msg, "value must be != 0") def test_bug436154(self): r = foo.Foo.add_sub(1, 2) self.assertEqual(r, 3) def test_bug450255(self): c = foo.ProtectedConstructor() def test_bug455689(self): p = foo.Property__StdString() def test_reference_existing_object_ptr(self): while gc.collect(): pass Foobar_count1 = foo.Foobar.instance_count box = foo.Box() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f1 = box.getFoobarInternalPtr() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f2 = box.getFoobarInternalPtr() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) self.assert_(f2 is f1) del f1, f2, box while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_reference_existing_object_ptr_attribute(self): while gc.collect(): pass Foobar_count1 = foo.Foobar.instance_count box = foo.Box() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f1 = box.m_internalFoobar self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f2 = box.m_internalFoobar self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) self.assert_(f2 is f1) del f1, f2, box while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_reference_existing_object_ref(self): while gc.collect(): pass Foobar_count1 = foo.Foobar.instance_count box = foo.Box() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f1 = box.getFoobarInternalRef() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f2 = box.getFoobarInternalRef() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) self.assert_(f2 is f1) del f1, f2, box while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count1) def test_reference_existing_object_ptr2(self): while gc.collect(): pass Foobar_count1 = foo.Foobar.instance_count Box_count1 = foo.Box.instance_count; box = foo.Box() self.assertEqual(foo.Box.instance_count, Box_count1 + 1) self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f1 = box.getFoobarInternalPtr2() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f2 = box.getFoobarInternalPtr2() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) self.assert_(f2 is f1) del f2, box while gc.collect(): pass # f1 is still alive, so box should still exist, in spite of having been locally unreferenced self.assertEqual(foo.Box.instance_count, Box_count1 + 1) self.assertEqual(foo.Foobar.instance_count, Foobar_count1 + 1) # delete f1, it should cause box to be freeable del f1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count1) self.assertEqual(foo.Box.instance_count, Box_count1) def test_reference_existing_object_ref2(self): while gc.collect(): pass Foobar_count1 = foo.Foobar.instance_count Box_count1 = foo.Box.instance_count; box = foo.Box() self.assertEqual(foo.Box.instance_count, Box_count1 + 1) self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f1 = box.getFoobarInternalRef2() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) f2 = box.getFoobarInternalRef2() self.assertEqual(foo.Foobar.instance_count, Foobar_count1+1) self.assert_(f2 is f1) del f2, box while gc.collect(): pass # f1 is still alive, so box should still exist, in spite of having been locally unreferenced self.assertEqual(foo.Box.instance_count, Box_count1 + 1) self.assertEqual(foo.Foobar.instance_count, Foobar_count1 + 1) # delete f1, it should cause box to be freeable del f1 while gc.collect(): pass self.assertEqual(foo.Foobar.instance_count, Foobar_count1) self.assertEqual(foo.Box.instance_count, Box_count1) def test_protected_method_no_subclassing(self): some = foo.SomeObject("xxx") self.assert_(hasattr(some, "protected_method_that_is_not_virtual")) self.assertRaises(TypeError, some.protected_method_that_is_not_virtual, "aax") del some def test_protected_method_with_subclassing(self): class Test(foo.SomeObject): def __init__(self, prefix): super(Test, self).__init__(prefix) some = Test("foo") v = some.protected_method_that_is_not_virtual("ajax") self.assertEqual(v, "fooajax") del some def test_multiple_inheritance(self): mi = foo.MIMixed() self.assert_(hasattr(mi, "mixed_method")) self.assert_(hasattr(mi, "base1_method")) self.assert_(hasattr(mi, "base2_method")) self.assert_(hasattr(mi, "root_method")) self.assertEqual(mi.root_method(), -1) self.assertEqual(mi.base1_method(), 1) self.assertEqual(mi.base2_method(), 2) self.assertEqual(mi.mixed_method(), 3) def test_cstring_return(self): some = foo.SomeObject("xxx") s = some.method_returning_cstring() self.assertEqual(s, "foobar") class Test(foo.SomeObject): def method_returning_cstring(self): return "another string" some = Test("xxx") s = some.method_returning_cstring() self.assertEqual(s, "another string") if __name__ == '__main__': unittest.main()