# KLayout Layout Viewer # Copyright (C) 2006-2017 Matthias Koefferlein # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import pya import unittest import os import sys import gc # Set this to True to disable some tests involving exceptions leak_check = "TEST_LEAK_CHECK" in os.environ # see test_21 class AEXT(pya.A): def __init__(self): self.offset = None def s(self, o): self.offset = o def g(self): return self.offset def m(self): return self.offset+self.a1() # Note: there are no protected methods, but this emulates the respective test for RBA def call_a10_prot(self, f): a10_prot(f) def __repr__(self): return str(self.offset) def repr_of_a(self): return "a1=" + str(self.a1()) pya.A.__repr__ = repr_of_a class XEdge(pya.Edge): def __init__(self): super(XEdge, self).__init__(pya.Point(1,2), pya.Point(3,4)) class EEXT(pya.E): def func(self, x): self.m = x.n def xfunc(self, x): return len(x) def __init__(self): self.m = None self.n = 42 class X(object): nothing = False class C_IMP1(pya.C): def f(self, s): return 615 class C_IMP2(pya.C): def f(self, s): return len(s) class C_IMP3(pya.C): anything = None class Z_IMP1(pya.Z): def f(self, x): return x.cls_name() class Z_IMP2(pya.Z): def f(self, x): return type(x).__name__ class Z_IMP3(pya.Z): def f(self, x): return super(Z_IMP3, self).f(x) + "*" def ph(x): # prepares a string with the proper integera values (1L for Python2, 1 for Python3) if sys.version_info < (3, 0): return x.replace("X", "L") else: return x.replace("X", "") class PyGObject(pya.GObject): z = -1 def __init__(self, z): super(PyGObject, self).__init__() self.z = z # reimplementation of "virtual int g()" def g(self): return self.z*2 class PyGFactory(pya.GFactory): def __init__(self): super(PyGFactory, self).__init__() # reimplementation of "virtual GObject *f(int)" def f(self, z): return PyGObject(z) class BasicTest(unittest.TestCase): def test_00(self): # all references of PA are released now: ac0 = pya.A.a0() a = pya.A.new_a(100) self.assertEqual( pya.A.a0(), ac0 + 1 ) a = None self.assertEqual( pya.A.a0(), ac0 ) a = pya.A() self.assertEqual( pya.A.a0(), ac0 ) # delayed instantiation of detached objects - A is actually created if it is used first a.a2() # just check, if it can be called self.assertEqual( pya.A.a0(), ac0 + 1 ) # open question: with ruby 1.8, aa is not deleted if the self.assertEqual is missing. Why? # maybe the GC does not like to be called that frequently? aa = a.dup() self.assertEqual( pya.A.a0(), ac0 + 2 ) aa = None self.assertEqual( pya.A.a0(), ac0 + 1 ) a = None self.assertEqual( pya.A.a0(), ac0 ) a = pya.A() self.assertEqual( pya.A.a0(), ac0 ) # delayed instantiation of detached objects - A is actually created if it is used first a.a2() # just check, if it can be called self.assertEqual( pya.A.a0(), ac0 + 1 ) # static and non-static methods can be mixed, but they will be made non-ambiguous too self.assertEqual( pya.A.aa(), "static_a" ) self.assertEqual( a.aa(), "a" ) self.assertEqual( a.a1(), 17 ) a.a5(-5) self.assertEqual( a.a1(), -5 ) a.a5(0x7fffffff) self.assertEqual( a.a1(), 0x7fffffff ) a.a5(-0x80000000) self.assertEqual( a.a1(), -0x80000000 ) self.assertEqual( a.a3("a"), 1 ) self.assertEqual( a.a3("ab"), 2 ) self.assertEqual( a.a3("µ"), 2 ) # two UTF8 bytes self.assertEqual( a.a3_qstr("a"), 1 ) self.assertEqual( a.a3_qstr("ab"), 2 ) self.assertEqual( a.a3_qstr("µ"), 1 ) # one UTF character self.assertEqual( a.a3_qstrref("a"), 1 ) self.assertEqual( a.a3_qstrref("ab"), 2 ) self.assertEqual( a.a3_qstrref("µ"), 1 ) # one UTF character self.assertEqual( a.a3_qba("a"), 1 ) self.assertEqual( a.a3_qba("ab"), 2 ) self.assertEqual( a.a3_qba("µ"), 2 ) # two UTF8 bytes self.assertEqual( a.a3(""), 0 ) self.assertEqual( a.a4([1]), 1.0 ) t = (1,) self.assertEqual( a.a4(t), 1.0 ) self.assertEqual( a.a4([1, 125e-3]), 0.125 ) t = (5, 1, -1.25) self.assertEqual( a.a4(t), -1.25 ) arr = [] for d in a.a6(): arr.append(d) self.assertEqual(arr, [5, 1, -1.25]) arr = [] for d in a.a7(): arr.append(d) self.assertEqual(arr, [5, 1, -1.25]) arr = [] for d in a.a8(): arr.append(d) self.assertEqual(arr, [5, 1, -1.25]) a.destroy() self.assertEqual( pya.A.a0(), ac0 ) if not leak_check: error_caught = False try: a.a2() # object has been destroyed already except: error_caught = True self.assertEqual( error_caught, True ) error_caught = False try: a.destroy() # object has been destroyed already except: error_caught = True self.assertEqual( error_caught, True ) self.assertEqual( pya.A.a0(), ac0 ) a = pya.A.new_a( 55 ) self.assertEqual( pya.A.a0(), ac0 + 1 ) self.assertEqual( a.a1(), 55 ) self.assertEqual( a.a_vp1( a.a_vp2() ), "abc" ) a.destroy() self.assertEqual( pya.A.a0(), ac0 ) a = pya.A.new_a(0) self.assertEqual( str(a.a9a(5)), "True" ) self.assertEqual( str(a.a9a(4)), "False" ) self.assertEqual( str(a.a9b(True)), "5" ) self.assertEqual( str(a.a9b(0)), "-5" ) self.assertEqual( str(a.a9b(1)), "5" ) self.assertEqual( str(a.a9b(False)), "-5" ) self.assertEqual( str(a.a9b(None)), "-5" ) self.assertEqual( str(a.get_e()), "#0" ) a.set_e( pya.Enum.a ) self.assertEqual( str(a.get_e()), "a" ) a.set_e( pya.Enum.b ) self.assertEqual( str(a.get_e()), "b" ) a.set_eptr( None ) self.assertEqual( str(a.get_e()), "#0" ) a.set_eptr( pya.Enum.c ) self.assertEqual( str(a.get_e()), "c" ) a.set_ecptr( None ) self.assertEqual( str(a.get_e()), "#0" ) a.set_ecptr( pya.Enum.b ) self.assertEqual( str(a.get_e()), "b" ) a.set_ecref( pya.Enum.a ) self.assertEqual( str(a.get_e()), "a" ) a.set_eref( pya.Enum.c ) self.assertEqual( str(a.get_e()), "c" ) self.assertEqual( str(a.get_eptr()), "c" ) self.assertEqual( str(a.get_eref()), "c" ) self.assertEqual( str(a.get_ecptr()), "c" ) self.assertEqual( str(a.get_ecref()), "c" ) a.set_ecptr( None ) self.assertEqual( a.get_ecptr(), None ) self.assertEqual( str(a.get_ecref()), "#0" ) self.assertEqual( a.get_eptr(), None ) self.assertEqual( str(a.get_eref()), "#0" ) ea = pya.Enum.a eb = pya.Enum.b ei = pya.Enum(17) e0 = pya.Enum() self.assertEqual( str(ea), "a" ) self.assertEqual( str(pya.Enum(str(ea))), "a" ) self.assertEqual( str(eb), "b" ) self.assertEqual( str(pya.Enum(str(eb))), "b" ) self.assertEqual( str(ei), "#17" ) self.assertEqual( str(pya.Enum(str(ei))), "#17" ) self.assertEqual( str(e0), "#0" ) self.assertEqual( str(pya.Enum(str(e0))), "#0" ) self.assertEqual( repr(e0), "(not a valid enum value)" ) self.assertEqual( repr(ea), "a (1)" ) self.assertEqual( repr(eb), "b (2)" ) self.assertEqual( eb == ea, False ) self.assertEqual( eb == eb, True ) self.assertEqual( eb != ea, True ) self.assertEqual( eb != eb, False ) self.assertEqual( eb < ea, False ) self.assertEqual( eb < eb, False ) self.assertEqual( ea < eb, True ) eea = pya.Enums() eei = pya.Enums(3) eeb = pya.Enums(eb) self.assertEqual( str(eea), "" ) self.assertEqual( repr(eea), " (0)" ) self.assertEqual( repr(pya.Enums(str(eea))), " (0)" ) self.assertEqual( repr(eei), "a|b (3)" ) self.assertEqual( repr(pya.Enums(str(eei))), "a|b (3)" ) self.assertEqual( repr(eeb), "b (2)" ) self.assertEqual( repr(pya.Enums(str(eeb))), "b (2)" ) eeab1 = ea | eb eeab2 = ea | pya.Enums(eb) eeab3 = pya.Enums(ea) | eb eeab4 = pya.Enums(ea) | pya.Enums(eb) self.assertEqual( repr(eeab1), "a|b (3)" ) self.assertEqual( repr(eeab2), "a|b (3)" ) self.assertEqual( repr(eeab3), "a|b (3)" ) self.assertEqual( repr(eeab4), "a|b (3)" ) # Note: unsigned enum's will produce the long int, signed enums will produce the short one self.assertEqual( repr(~eeab4) == " (-4)" or repr(~eeab4) == " (4294967292)", True ) self.assertEqual( repr(eeab4 & ea), "a (1)" ) self.assertEqual( repr(eeab4 & eeb), "b (2)" ) self.assertEqual( repr(eeab4 ^ eeb), "a (1)" ) self.assertEqual( repr(eeab4 ^ eb), "a (1)" ) self.assertEqual( repr(eeab4), "a|b (3)" ) eeab4 ^= ea self.assertEqual( repr(eeab4), "b (2)" ) ee = pya.Enum() self.assertEqual( str(ee), "#0" ) a.mod_eref( ee, pya.Enum.c ) self.assertEqual( str(ee), "c" ) a.mod_eptr( ee, pya.Enum.a ) self.assertEqual( str(ee), "a" ) self.assertEqual( repr(a.ev()), "[]" ) a.push_ev( pya.Enum.a ) a.push_ev( pya.Enum() ) a.push_ev( pya.Enum.b ) self.assertEqual( repr(a.ev()), "[a (1), (not a valid enum value), b (2)]" ) self.assertEqual( repr(a.get_ef()), " (0)" ) a.set_ef( pya.Enum.a ) self.assertEqual( str(a.get_ef()), "a" ) a.set_ef( pya.Enums(pya.Enum.b) ) self.assertEqual( str(a.get_ef()), "b" ) a.set_efptr( None ) self.assertEqual( repr(a.get_ef()), " (0)" ) a.set_efptr( pya.Enums(pya.Enum.c) ) self.assertEqual( str(a.get_ef()), "a|b|c" ) a.set_efcptr( None ) self.assertEqual( repr(a.get_ef()), " (0)" ) a.set_efcptr( pya.Enums(pya.Enum.b) ) self.assertEqual( str(a.get_ef()), "b" ) a.set_efcptr( pya.Enum.c ) self.assertEqual( str(a.get_ef()), "a|b|c" ) a.set_efcref( pya.Enum.b ) self.assertEqual( str(a.get_ef()), "b" ) a.set_efcref( pya.Enums(pya.Enum.a) ) self.assertEqual( str(a.get_ef()), "a" ) a.set_efref( pya.Enums(pya.Enum.c) ) self.assertEqual( str(a.get_ef()), "a|b|c" ) self.assertEqual( str(a.get_efptr()), "a|b|c" ) self.assertEqual( str(a.get_efref()), "a|b|c" ) self.assertEqual( str(a.get_efcptr()), "a|b|c" ) self.assertEqual( str(a.get_efcref()), "a|b|c" ) a.set_efcptr( None ) self.assertEqual( a.get_efcptr(), None ) self.assertEqual( repr(a.get_efcref()), " (0)" ) self.assertEqual( a.get_efptr(), None ) self.assertEqual( repr(a.get_efref()), " (0)" ) ee = pya.Enums() self.assertEqual( repr(ee), " (0)" ) a.mod_efref( ee, pya.Enum.b ) self.assertEqual( str(ee), "b" ) a.mod_efptr( ee, pya.Enum.a ) self.assertEqual( str(ee), "a|b" ) def test_12(self): a1 = pya.A() a1.a5( -15 ) a2 = a1 a3 = a2.dup() self.assertEqual( a1.a1(), -15 ) self.assertEqual( a2.a1(), -15 ) self.assertEqual( a3.a1(), -15 ) a1.a5( 11 ) a3.a5( -11 ) self.assertEqual( a1.a1(), 11 ) self.assertEqual( a2.a1(), 11 ) self.assertEqual( a3.a1(), -11 ) self.assertEqual( a1.a10_d(5.2), "5.2" ) self.assertEqual( a1.a10_d_qstr(5.25), "5.25" ) self.assertEqual( a1.a10_d_qstrref(5.2), "5.2" ) self.assertEqual( a1.a10_d_qba(5.1), "5.1" ) self.assertEqual( a1.a10_f(5.7), "5.7" ) x = pya.Value(1.5) self.assertEqual( str(x.value), "1.5" ) self.assertEqual( a1.a10_fptr(x), "6.5" ) self.assertEqual( str(x.value), "6.5" ) self.assertEqual( a1.a10_fptr(1), "6" ) self.assertEqual( a1.a10_fptr(None), "nil" ) self.assertEqual( a1.a10_fptr(pya.Value()), "nil" ) self.assertEqual( str(x), "6.5" ) self.assertEqual( str(x.value), "6.5" ) x = pya.Value(2.5) self.assertEqual( a1.a10_dptr(x), "8.5" ) self.assertEqual( a1.a10_dptr(2), "8" ) self.assertEqual( a1.a10_dptr(None), "nil" ) self.assertEqual( a1.a10_dptr(pya.Value()), "nil" ) self.assertEqual( x.to_s(), "8.5" ) self.assertEqual( str(x.value), "8.5" ) x = pya.Value(2) self.assertEqual( a1.a10_iptr(x), "9" ) self.assertEqual( a1.a10_iptr(3), "10" ) self.assertEqual( a1.a10_iptr(None), "nil" ) self.assertEqual( a1.a10_iptr(pya.Value()), "nil" ) self.assertEqual( str(x), "9" ) self.assertEqual( str(x.value), "9" ) x = pya.Value(False) self.assertEqual( a1.a10_bptr(x), "true" ) self.assertEqual( a1.a10_bptr(False), "true" ) self.assertEqual( a1.a10_bptr(None), "nil" ) self.assertEqual( a1.a10_bptr(pya.Value()), "nil" ) self.assertEqual( str(x), "true" ) self.assertEqual( str(x.value), "True" ) x = pya.Value(10) self.assertEqual( a1.a10_uiptr(x), "20" ) self.assertEqual( a1.a10_uiptr(11), "21" ) self.assertEqual( a1.a10_uiptr(None), "nil" ) self.assertEqual( a1.a10_uiptr(pya.Value()), "nil" ) self.assertEqual( str(x), "20" ) self.assertEqual( str(x.value), "20" ) x = pya.Value(10) self.assertEqual( a1.a10_ulptr(x), "21" ) self.assertEqual( a1.a10_ulptr(12), "23" ) self.assertEqual( a1.a10_ulptr(None), "nil" ) self.assertEqual( a1.a10_ulptr(pya.Value()), "nil" ) self.assertEqual( str(x), "21" ) self.assertEqual( str(x.value), "21" ) x = pya.Value(10) self.assertEqual( a1.a10_lptr(x), "22" ) self.assertEqual( a1.a10_lptr(11), "23" ) self.assertEqual( a1.a10_lptr(None), "nil" ) self.assertEqual( a1.a10_lptr(pya.Value()), "nil" ) self.assertEqual( str(x), "22" ) self.assertEqual( str(x.value), "22" ) x = pya.Value(10) self.assertEqual( a1.a10_llptr(x), "23" ) self.assertEqual( a1.a10_llptr(11), "24" ) self.assertEqual( a1.a10_llptr(None), "nil" ) self.assertEqual( a1.a10_llptr(pya.Value()), "nil" ) self.assertEqual( str(x), "23" ) self.assertEqual( str(x.value), "23" ) x = pya.Value(10) self.assertEqual( a1.a10_ullptr(x), "24" ) self.assertEqual( a1.a10_ullptr(12), "26" ) self.assertEqual( a1.a10_ullptr(None), "nil" ) self.assertEqual( a1.a10_ullptr(pya.Value()), "nil" ) self.assertEqual( x.to_s(), "24" ) self.assertEqual( x.value, 24 ) x = pya.Value("z") self.assertEqual( a1.a10_sptr(x), "zx" ) self.assertEqual( a1.a10_sptr("a"), "ax" ) self.assertEqual( a1.a10_sptr(None), "nil" ) self.assertEqual( a1.a10_sptr(pya.Value()), "nil" ) self.assertEqual( x.to_s(), "zx" ) self.assertEqual( x.value, "zx" ) # String modification is not possible in CPython API, hence strings cannot be used # directly as out parameters (but as boxed values they can) x = "z" self.assertEqual( a1.a10_sptr(x), "zx" ) self.assertEqual( x, "z" ) try: # passing other objects than StringValue and a string fails self.assertEqual( a1.a10_sptr([]), "nil" ) err = False except: err = True self.assertEqual( err, True ) self.assertEqual( a1.a10_cfptr(6.5), "6.5" ) self.assertEqual( a1.a10_cfptr(None), "nil" ) self.assertEqual( a1.a10_cdptr(8.5), "8.5" ) self.assertEqual( a1.a10_cdptr(None), "nil" ) self.assertEqual( a1.a10_ciptr(9), "9" ) self.assertEqual( a1.a10_ciptr(None), "nil" ) self.assertEqual( a1.a10_cbptr(True), "true" ) self.assertEqual( a1.a10_cbptr(None), "nil" ) self.assertEqual( a1.a10_cuiptr(20), "20" ) self.assertEqual( a1.a10_cuiptr(None), "nil" ) self.assertEqual( a1.a10_culptr(21), "21" ) self.assertEqual( a1.a10_culptr(None), "nil" ) self.assertEqual( a1.a10_clptr(22), "22" ) self.assertEqual( a1.a10_clptr(None), "nil" ) self.assertEqual( a1.a10_cllptr(23), "23" ) self.assertEqual( a1.a10_cllptr(None), "nil" ) self.assertEqual( a1.a10_cullptr(24), "24" ) self.assertEqual( a1.a10_cullptr(None), "nil" ) self.assertEqual( a1.a10_csptr(None), "nil" ) self.assertEqual( a1.a10_csptr("x"), "x" ) x = pya.Value(1.5) self.assertEqual( a1.a10_fref(x), "11.5" ) try: self.assertEqual( a1.a10_fref(None), "nil" ) err = False except: err = True self.assertEqual( err, True ) try: self.assertEqual( a1.a10_fref(pya.Value()), "nil" ) err = False except: err = True self.assertEqual( err, True ) self.assertEqual( x.value, 11.5 ) x = pya.Value(2.5) self.assertEqual( a1.a10_dref(x), "13.5" ) self.assertEqual( a1.a10_dref(2), "13" ) self.assertEqual( x.value, 13.5 ) x = pya.Value(2) self.assertEqual( a1.a10_iref(x), "14" ) self.assertEqual( a1.a10_iref(1), "13" ) self.assertEqual( x.value, 14 ) x = pya.Value(False) self.assertEqual( a1.a10_bref(x), "true" ) self.assertEqual( a1.a10_bref(False), "true" ) self.assertEqual( x.value, True ) x = pya.Value(10) self.assertEqual( a1.a10_uiref(x), "24" ) self.assertEqual( a1.a10_uiref(11), "25" ) self.assertEqual( x.value, 24 ) x = pya.Value(10) self.assertEqual( a1.a10_ulref(x), "25" ) self.assertEqual( a1.a10_ulref(12), "27" ) self.assertEqual( x.value, 25 ) x = pya.Value(10) self.assertEqual( a1.a10_lref(x), "26" ) self.assertEqual( a1.a10_lref(13), "29" ) self.assertEqual( x.value, 26 ) x = pya.Value(10) self.assertEqual( a1.a10_llref(x), "27" ) self.assertEqual( a1.a10_llref(14), "31" ) self.assertEqual( x.value, 27 ) x = pya.Value(10) self.assertEqual( a1.a10_ullref(x), "28" ) self.assertEqual( a1.a10_ullref(11), "29" ) self.assertEqual( x.value, 28 ) x = pya.Value("x") self.assertEqual( a1.a10_sref(x), "xy" ) self.assertEqual( x.value, "xy" ) self.assertEqual( a1.a10_sref("p"), "py" ) self.assertEqual( a1.a10_cfref(6.5), "6.5" ) try: self.assertEqual( a1.a10_cfref(None), "nil" ) err = False except: err = True self.assertEqual( err, True ) self.assertEqual( a1.a10_cdref(8.5), "8.5" ) self.assertEqual( a1.a10_ciref(9), "9" ) self.assertEqual( a1.a10_cbref(True), "true" ) self.assertEqual( a1.a10_cuiref(20), "20" ) self.assertEqual( a1.a10_culref(21), "21" ) self.assertEqual( a1.a10_clref(22), "22" ) self.assertEqual( a1.a10_cllref(23), "23" ) self.assertEqual( a1.a10_cullref(24), "24" ) self.assertEqual( a1.a10_csref("x"), "x" ) def test_13(self): b = pya.B() if not leak_check: err_caught = False try: b.b7().a1() # cannot call non-const method on const reference except: err_caught = True self.assertEqual( err_caught, True ) b.b7().a2() self.assertEqual( b.b1(), 5 ) self.assertEqual( b.b2(), "" ) b.b5( "xyz" ) self.assertEqual( b.b2(), "xyz" ) self.assertEqual( b.b5a(), "xyz" ) b.b5b( "yx", "zz" ) self.assertEqual( b.b2(), "yxzz" ) self.assertEqual( b.b5a(), "yxzz" ) arr = [] err_caught = False if not leak_check: try: for a in b.b10(): arr.append(a.a1()) # b10 is a const iterator - cannot call a1 on it except: err_caught = True self.assertEqual( err_caught, True ) self.assertEqual(arr, []) err_caught = False if not leak_check: try: for a in b.b10p(): arr.append(a.a1()) # b10p is a const iterator - cannot call a1 on it except: err_caught = True self.assertEqual( err_caught, True ) self.assertEqual(arr, []) arr = [] for a in b.b10(): arr.append(a.dup().a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] # NOTE: the following will crash: # for a in b.dup().b10(): # ... # because the clone created by dup() will be # destroyed too early. bdup = b.dup() for a in bdup.b10(): arr.append(a.dup().a1()) self.assertEqual(arr, [100, 121, 144]) return arr = [] for a in b.b10(): arr.append(a.a1c()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b10p(): arr.append(a.dup().a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] # Ticket #811: for a in b.dup().b10p(): arr.append(a.dup().a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] bdup = b.dup() for a in bdup.b10p(): arr.append(a.dup().a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b10p(): arr.append(a.a1c()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b11(): arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] bdup = b.dup() for a in bdup.b11(): arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b12(): arr.append(a.a1()) self.assertEqual(arr, [7100, 7121, 7144, 7169]) arr = [] bdup = b.dup() for a in bdup.b12(): arr.append(a.a1()) self.assertEqual(arr, [7100, 7121, 7144, 7169]) aarr = b.b16a() arr = [] for a in aarr: arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) aarr = b.b16b() arr = [] for a in aarr: arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) aarr = b.b16c() arr = [] for a in aarr: arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) b.b17a( [ pya.A.new_a( 101 ), pya.A.new_a( -122 ) ] ) arr = [] for a in b.b11(): arr.append(a.a1()) self.assertEqual(arr, [101, -122]) b.b17a( [] ) arr = [] for a in b.b11(): arr.append(a.a1()) self.assertEqual(arr, []) b.b17b( [ pya.A.new_a( 102 ), pya.A.new_a( -123 ) ] ) arr = [] for a in b.b11(): arr.append(a.a1()) self.assertEqual(arr, [102, -123]) b.b17c( [ pya.A.new_a( 100 ), pya.A.new_a( 121 ), pya.A.new_a( 144 ) ] ) arr = [] for a in b.b11(): arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) if not leak_check: arr = [] try: for a in b.b13(): arr.append(a.a1()) except: err_caught = True self.assertEqual( err_caught, True ) self.assertEqual(arr, []) arr = [] for a in b.b13(): arr.append(a.a1c()) self.assertEqual(arr, [-3100, -3121]) arr = [] bdup = b.dup() for a in bdup.b13(): arr.append(a.a1c()) self.assertEqual(arr, [-3100, -3121]) arr = [] for a in b.b18(): arr.append(a.a1c()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b18(): arr.append(a.a1()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b18b(): arr.append(a.a1c()) self.assertEqual(arr, [100, 121, 144]) arr = [] # even though b18b returns a "const A &", calling a non-const method does not work # since A is a managed object and is not turned into a copy. err_caught = False try: for a in b.b18b(): arr.append(a.a1()) except: err_caught = True end self.assertEqual(arr, []) self.assertEqual(err_caught, True) arr = [] for a in b.b18c(): arr.append(a.a1c()) self.assertEqual(arr, [100, 121, 144]) arr = [] # this does not work since b18c delivers a "const *" which cannot be used to call a non-const # method on err_caught = False try: for a in b.b18c(): arr.append(a.a1()) except: err_caught = True end self.assertEqual(arr, []) self.assertEqual(err_caught, True) def test_13b(self): b = pya.B() bb = pya.B() bb.b5("a") b.push_b(bb) bb = pya.B() bb.b5("y") b.push_b(bb) bb = pya.B() bb.b5("uu") b.push_b(bb) arr = [] for bb in b.each_b_copy(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] for bb in b.each_b_copy(): bb.b5(bb.b2() + "x") arr.append(bb.b2()) self.assertEqual(arr, ["ax", "yx", "uux"]) arr = [] for bb in b.each_b_copy(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] for bb in b.each_b_cref(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] # this works, since the "const B &" will be converted to a copy for bb in b.each_b_cref(): bb.b5(bb.b2() + "x") arr.append(bb.b2()) self.assertEqual(arr, ["ax", "yx", "uux"]) arr = [] for bb in b.each_b_cref(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] for bb in b.each_b_cptr(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] # const references cannot be modified err_caught = False try: for bb in b.each_b_cptr(): bb.b5(bb.b2() + "x") arr.append(bb.b2()) except: err_caught = True self.assertEqual(err_caught, True) self.assertEqual(arr, []) arr = [] for bb in b.each_b_cptr(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] for bb in b.each_b_ref(): arr.append(bb.b2()) self.assertEqual(arr, ["a", "y", "uu"]) arr = [] for bb in b.each_b_ref(): bb.b5(bb.b2() + "x") arr.append(bb.b2()) self.assertEqual(arr, ["ax", "yx", "uux"]) arr = [] for bb in b.each_b_ref(): arr.append(bb.b2()) self.assertEqual(arr, ["ax", "yx", "uux"]) arr = [] for bb in b.each_b_ptr(): arr.append(bb.b2()) self.assertEqual(arr, ["ax", "yx", "uux"]) arr = [] for bb in b.each_b_ptr(): bb.b5(bb.b2() + "x") arr.append(bb.b2()) self.assertEqual(arr, ["axx", "yxx", "uuxx"]) arr = [] for bb in b.each_b_ptr(): arr.append(bb.b2()) self.assertEqual(arr, ["axx", "yxx", "uuxx"]) def test_14(self): a = pya.A() a.a5( 22 ) b = pya.B() self.assertEqual( b.b3( a ), 22 ) self.assertEqual( b.b4( a ), "b4_result: 22" ) a.a5( -6 ) self.assertEqual( b.b3( a ), -6 ) self.assertEqual( b.b4( a ), "b4_result: -6" ) self.assertEqual( b.b4( pya.A() ), "b4_result: 17" ) def test_15(self): a = pya.A_NC() self.assertEqual( True, isinstance(a, pya.A) ) a.a5( 22 ) b = pya.B() self.assertEqual( b.b3( a ), 22 ) self.assertEqual( b.b4( a ), "b4_result: 22" ) a.a5( -6 ) self.assertEqual( b.b3( a ), -6 ) self.assertEqual( b.b4( a ), "b4_result: -6" ) self.assertEqual( b.b4( pya.A_NC() ), "b4_result: 17" ) def test_16(self): if leak_check: return # Test, if this throws an error (object of class X passed to A argument): err = "" try: b = pya.B() self.assertEqual( b.b4( pya.X() ), "b4_result: -6" ) self.assertEqual( False, True ) # this must never hit except Exception as e: err = str(e) self.assertEqual( err, "Unexpected object type (expected argument of class A, got X) in B.b4" ); # Test, if this throws an error (object of class X passed to A argument): err = "" try: b = pya.B() bb = pya.B() self.assertEqual( b.b4( bb ), "b4_result: -6" ) self.assertEqual( False, True ) # this must never hit except Exception as e: err = str(e) self.assertEqual( err, "Unexpected object type (expected argument of class A, got B) in B.b4" ); def test_17(self): # test copies of objects being returned b = pya.B() a = b.b6( 1971 ); self.assertEqual( a.a1(), 1971 ); self.assertEqual( b.b9( a ), 1971 ); aa = b.b6( -61 ); self.assertEqual( b.b9cref( aa ), -61 ); self.assertEqual( a.a1(), 1971 ); self.assertEqual( b.b9( a ), 1971 ); self.assertEqual( aa.a1(), -61 ); self.assertEqual( b.b9( aa ), -61 ); aa.a5(98); a.a5(100); self.assertEqual( a.a1(), 100 ); self.assertEqual( b.b9( a ), 100 ); self.assertEqual( aa.a1(), 98 ); self.assertEqual( b.b9( aa ), 98 ); def test_18(self): # Test references to objects (returned by b.b7) b = pya.B() b.b8( 77 ) self.assertEqual( b.b7().a1c(), 77 ); b.b8cref( 79 ) self.assertEqual( b.b7().a1c(), 79 ); aref = b.b7() err_caught = False if not leak_check: try: x = aref.a1() # cannot call non-const method on const reference (as delivered by b7) except: err_caught = True self.assertEqual( err_caught, True ) self.assertEqual( aref.a1c(), 79 ); b.b8( -1 ) self.assertEqual( aref.a1c(), -1 ); def test_19(self): c0 = pya.C() self.assertEqual( c0.g("x"), 1977 ); c1 = C_IMP1() self.assertEqual( c1.g("x"), 615 ); c2 = C_IMP2() self.assertEqual( c2.g("x"), 1 ); self.assertEqual( c2.g(""), 0 ); self.assertEqual( c2.g("abc"), 3 ); self.assertEqual( c1.g("x"), 615 ); c3 = C_IMP3() self.assertEqual( c3.g("x"), 1977 ); self.assertEqual( pya.C.s1(), 4451 ); pya.C.s2clr() pya.C.s2( 7.0 ) self.assertEqual( pya.C.s3( 5.5 ), "5.500" ); arr = [] for i in pya.C.each(): arr.append(i) self.assertEqual( arr, [ 0, 1, 2, 3, 4, 5, 6 ] ) self.assertEqual( C_IMP1.s1(), 4451 ); C_IMP1.s2( 1.0 ) self.assertEqual( C_IMP1.s3( 1.5 ), "1.500" ); arr = [] for i in C_IMP1.each(): arr.append(i) self.assertEqual( arr, [ 0, 1, 2, 3, 4, 5, 6, 0 ] ) self.assertEqual( C_IMP2.s1(), 4451 ); C_IMP2.s2( 2.0 ) self.assertEqual( C_IMP2.s3( -1.5 ), "-1.500" ); arr = [] for i in C_IMP2.each(): arr.append(i) self.assertEqual( arr, [ 0, 1, 2, 3, 4, 5, 6, 0, 0, 1 ] ) def test_20(self): b = pya.B() a1 = b.b14a( True ) a2 = b.b14b() self.assertEqual( a1.a1(), 17 ) self.assertEqual( a2.a1(), 17 ) a1.a5( 761 ) self.assertEqual( a1.a1(), 761 ) self.assertEqual( a2.a1(), 761 ) a1 = b.b14a( False ) self.assertEqual( a1, None ) self.assertEqual( b.b15( b.b14b() ), True ) self.assertEqual( b.b15( b.b14a( False ) ), False ) self.assertEqual( b.b15( None ), False ) def test_21(self): # Python does not allow extending built-in types - the following test # is taken from the Ruby binding. I don't know how to implement it for # Python however. return # test client data binding to C++ objects b = pya.B() # b14b() returns a pya.A object, but it cannot be extended dynamically by a method s ... b.b14b().s( 117 ) self.assertEqual( b.b14b().g(), 117 ) n = 0 def handler(a): a.s(n) n += 1 b.b10_nc( lambda a: handler(a) ) arr = [] b.b10( lambda a: arr.append( a.g ) ) self.assertEqual( arr, [ 0, 1, 2 ] ) arr = [] b.b10p( lambda a: arr.append( a.g ) ) self.assertEqual( arr, [ 0, 1, 2 ] ) def test_22(self): # test client data binding to C++ objects b = pya.B() self.assertEqual( b.b20a( 5.0 ), False ) self.assertEqual( b.b20a( None ), True ) self.assertEqual( b.b20a( 1 ), False ) self.assertEqual( b.b20a( "hallo" ), False ) self.assertEqual( b.b20a( False ), False ) self.assertEqual( b.b20a( True ), False ) self.assertEqual( b.b20a( 10000000000000000 ), False ) self.assertEqual( b.b20b( 5.0 ), True ) self.assertEqual( b.b20b( None ), False ) self.assertEqual( b.b20b( 1 ), False ) self.assertEqual( b.b20b( "hallo" ), False ) self.assertEqual( b.b20b( False ), False ) self.assertEqual( b.b20b( True ), False ) if sys.maxsize > 5000000000: # on 64 bit platforms this fits into a long value, therefore this test returns false: self.assertEqual( b.b20b( 10000000000000000 ), False ) else: # otherwise it is converted to a double: self.assertEqual( b.b20b( 10000000000000000 ), True ) self.assertEqual( b.b20c( 5.0 ), False ) self.assertEqual( b.b20c( None ), False ) if sys.maxsize > 5000000000: # on 64 bit platforms this fits into a long value, therefore this test returns True: self.assertEqual( b.b20c( 10000000000000000 ), True ) else: # otherwise it is converted to a double and the test returns false: self.assertEqual( b.b20c( 10000000000000000 ), False ) self.assertEqual( b.b20c( "hallo" ), False ) self.assertEqual( b.b20c( False ), False ) self.assertEqual( b.b20c( True ), False ) self.assertEqual( b.b20d( 5.0 ), False ) self.assertEqual( b.b20d( None ), False ) self.assertEqual( b.b20d( 1 ), False ) self.assertEqual( b.b20d( "hallo" ), True ) self.assertEqual( b.b20d( False ), False ) self.assertEqual( b.b20d( True ), False ) self.assertEqual( b.b20d( 10000000000000000 ), False ) self.assertEqual( b.b20e( 5.0 ), False ) self.assertEqual( b.b20e( None ), False ) self.assertEqual( b.b20e( 1 ), False ) self.assertEqual( b.b20e( "hallo" ), False ) self.assertEqual( b.b20e( False ), True ) self.assertEqual( b.b20e( True ), True ) self.assertEqual( b.b20e( 10000000000000000 ), False ) self.assertEqual( b.b21a( 50 ), "50" ) self.assertEqual( b.b21a( True ), "true" ) self.assertEqual( b.b21a( False ), "false" ) self.assertEqual( b.b21a( "hallo" ), "hallo" ) self.assertEqual( b.b21a( 5.5 ), "5.5" ) self.assertEqual( b.b21a( None ), "nil" ) self.assertEqual( b.b21b( 50 ), 50.0 ) self.assertEqual( b.b21b( True ), 1.0 ) self.assertEqual( b.b21b( False ), 0.0 ) self.assertEqual( b.b21b( 5.5 ), 5.5 ) self.assertEqual( b.b21b( None ), 0.0 ) self.assertEqual( b.b21c( 50 ), 50 ) self.assertEqual( b.b21c( True ), 1 ) self.assertEqual( b.b21c( False ), 0 ) self.assertEqual( b.b21c( 5.5 ), 5 ) self.assertEqual( b.b21c( None ), 0 ) self.assertEqual( b.b22a( [ 1, "hallo", 5.5 ] ), 3 ) self.assertEqual( b.b23a(), [ 1, "hallo", 5.5 ] ) a = [] for x in b.b24(): a.append(x) self.assertEqual( a, [ 1, "hallo", 5.5 ] ) self.assertEqual( b.b22c(), 5.5 ) self.assertEqual( b.b22d(), 5.5 ) self.assertEqual( b.b22a( [ 1, "hallo" ] ), 2 ) self.assertEqual( b.b23b(), [ 1, "hallo" ] ) self.assertEqual( b.b23d(), [ 1, "hallo" ] ) self.assertEqual( b.b23e(), [ 1, "hallo" ] ) self.assertEqual( b.b23e_null(), None ) self.assertEqual( b.b23f(), [ 1, "hallo" ] ) self.assertEqual( b.b23f_null(), None ) self.assertEqual( b.b22c(), "hallo" ) self.assertEqual( b.b22d(), "hallo" ) self.assertEqual( b.b22a( [ ] ), 0 ) self.assertEqual( b.b23c(), [ ] ) a = [] for x in b.b24(): a.append(x) self.assertEqual( a, [ ] ) self.assertEqual( b.b22b(), None ) self.assertEqual( b.b22c(), None ) self.assertEqual( b.b22d(), None ) self.assertEqual( b.b22a( [ [ 1, "hallo" ], [ 10, 17, 20 ] ] ), 2 ) self.assertEqual( b.b23a(), [ [ 1, "hallo" ], [ 10, 17, 20 ] ] ) a = [] for x in b.b24(): a.append(x) self.assertEqual( a, [ [ 1, "hallo" ], [ 10, 17, 20 ] ] ) # ability to pass complex objects over tl::Variant: self.assertEqual( b.b22a( [ pya.Box(pya.Point(0, 0), pya.Point(10, 20)) ] ), 1 ) self.assertEqual( str(b.b22c()), "(0,0;10,20)" ) self.assertEqual( type(b.b22c()).__name__, "Box" ) # ability to pass complex objects over tl::Variant: self.assertEqual( b.b22a( [ pya.DBox(pya.DPoint(0, 0), pya.DPoint(10, 20)) ] ), 1 ) self.assertEqual( str(b.b22c()), "(0,0;10,20)" ) self.assertEqual( type(b.b22c()).__name__, "DBox" ) # ability to pass complex objects over tl::Variant: self.assertEqual( b.b22a( [ pya.LayerInfo("hallo") ] ), 1 ) self.assertEqual( str(b.b22c()), "hallo" ) self.assertEqual( type(b.b22c()).__name__, "LayerInfo" ) def test_23(self): b = pya.B() a = pya.A() self.assertEqual( b.bx(), 17 ) self.assertEqual( b.b30(), 17 ) self.assertEqual( b.bx(5), "xz" ) self.assertEqual( b.by(5), "xz" ) self.assertEqual( b.b31(6), "xz" ) self.assertEqual( b.b33(a), "aref" ) self.assertEqual( b.bx(a), "aref" ) self.assertEqual( b.bx("a", 15), 20.5 ) self.assertEqual( b.b32("b", 25), 20.5 ) na = pya.A.a0() # instance count self.assertEqual(b.bx(a, 15), "aref+i") self.assertEqual(pya.A.a0(), na) err_caught = False try: # cannot cast second argument to int self.assertEqual(b.b34(a, "X"), "aref+i") except: err_caught = True self.assertEqual(err_caught, True) # the exception thrown before must not leave an instance on the call stack: self.assertEqual(pya.A.a0(), na) err_caught = False try: # invalid number of arguments self.assertEqual(b.by(), "xz") except: err_caught = True self.assertEqual(err_caught, True) err_caught = False try: # invalid number of arguments self.assertEqual(b.bx( 1, 5, 7 ), "xz") except: err_caught = True self.assertEqual(err_caught, True) b.destroy() a.destroy() def test_24(self): n = [ 0, 0 , "" ] # Events e = EEXT() e.m = 100 e.s1() # no event installed self.assertEqual( 0, n[0] ) e.s2() self.assertEqual( 0, n[1] ) e.s3() self.assertEqual( "", n[2] ) self.assertEqual( 100, e.m ) # This is not allowed: e.e0( lambda: n0 = n0 + 1 ), hence we use a function: def f0(): n[0] = n[0] + 1 e.e0(f0) # This is not allowed: e.e1( lambda x: n1 = n1 + x.m ), hence we use a function: def f1(x): n[1] = n[1] + x.m e.e1(f1) # This is not allowed: e.e2( lambda i, s: n2 = n2 + str(i) + s), hence we use a function: def f2(i, s): n[2] = n[2] + str(i) + s e.e2(f2) e.s1() self.assertEqual( 1, n[0] ) e.s1() self.assertEqual( 2, n[0] ) # This is not allowed: p = lambda: n0 = n0 + 2, hence we use a function: def f4(): n[0] = n[0] + 2 e.e0(f4) e.s1() self.assertEqual( 4, n[0] ) e.s2() self.assertEqual( 100, n[1] ) e.m = 1 e.s2() self.assertEqual( 101, n[1] ) e.s3() self.assertEqual( "18hallo", n[2] ) e.s3() self.assertEqual( "18hallo18hallo", n[2] ) # NOTE: currently, exceptions are not propagated over # signals because of undefined behaviour if False: def raise_excpt(): raise Exception("X") e.e0( lambda: raise_excpt() ) error_caught = False try: e.s1() except: error_caught = True self.assertEqual( error_caught, True ) # Signals with return values are not supported currently if False: e.e0r( lambda x: 5 ) self.assertEqual( e.s1r("x"), 5 ) e.e0r( lambda s: len(s) + 2 ) self.assertEqual( e.s1r("x"), 3 ) self.assertEqual( e.s1r("abcxyz"), 8 ) # Event bound to itself e.e0r(e.xfunc) self.assertEqual( e.s1r("x"), 1 ) self.assertEqual( e.s1r("xxx"), 3 ) def test_25(self): # destruction of an instance via c++ pya.A.a20(None) ac0 = pya.A.a0() a = pya.A() a.create() self.assertEqual(a.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) pya.A.a20(a) # install static instance of A self.assertEqual(a.destroyed(), False) pya.A.a20(None) self.assertEqual(a.destroyed(), True) self.assertEqual(pya.A.a0(), ac0) a = pya.A() a.create() self.assertEqual(a.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) pya.A.a20(a) # install static instance of A self.assertEqual(a.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) pya.A.a20(a) # re-install static instance of A self.assertEqual(a.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) # install another instance aa = pya.A() aa.create() self.assertEqual(aa.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 2) pya.A.a20(aa) # install static instance of A # original one is destroyed now, only new instance remains self.assertEqual(a.destroyed(), True) self.assertEqual(aa.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) pya.A.a20(None) # discard installed instance self.assertEqual(aa.destroyed(), True) self.assertEqual(pya.A.a0(), ac0) # the same without create .. should work too, but not create an instance because of late # instantiation in default ctor a = pya.A() self.assertEqual(a.destroyed(), False) self.assertEqual(pya.A.a0(), ac0) pya.A.a20(a) # install static instance of A self.assertEqual(a.destroyed(), False) pya.A.a20(None) self.assertEqual(pya.A.a0(), ac0) self.assertEqual(a.destroyed(), True) def test_26(self): # cyclic references - event bound to itself base_count = EEXT.inst_count() e = EEXT() e.e1(e.func) e.m = -17 self.assertEqual(EEXT.inst_count(), base_count + 1) self.assertEqual(e.m, -17) # s2 will call e.func(self,x) with x=self and func will put x.n (which is 42) into x.m e.s2() self.assertEqual(e.m, 42) self.assertEqual(EEXT.inst_count(), base_count + 1) e = None self.assertEqual(EEXT.inst_count(), base_count) # the same, but with += e = EEXT() e.e1 += e.func e.m = -17 self.assertEqual(EEXT.inst_count(), base_count + 1) self.assertEqual(e.m, -17) # s2 will call e.func(self,x) with x=self and func will put x.n (which is 42) into x.m e.s2() self.assertEqual(e.m, 42) self.assertEqual(EEXT.inst_count(), base_count + 1) # now detach the event with -= e.e1 -= e.func e.m = -17 e.s2() self.assertEqual(e.m, -17) self.assertEqual(EEXT.inst_count(), base_count + 1) e = None self.assertEqual(EEXT.inst_count(), base_count) def test_27(self): # destruction of an instance via c++ pya.A.a20(None) ac0 = pya.A.a0() a = pya.A() a._create() self.assertEqual(a._destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) pya.A.a20(a) self.assertEqual(pya.A.a20_get() == None, False) # release A instance -> will delete it a = None self.assertEqual(pya.A.a0(), ac0) self.assertEqual(pya.A.a20_get() == None, True) a = pya.A() a._create() self.assertEqual(a.destroyed(), False) self.assertEqual(pya.A.a0(), ac0 + 1) pya.A.a20(a) # install static instance of A self.assertEqual(pya.A.a20_get() == None, False) a._unmanage() # release A instance -> won't delete it since it is unmanaged a = None self.assertEqual(pya.A.a0(), ac0 + 1) self.assertEqual(pya.A.a20_get() == None, False) a = pya.A.a20_get() a._manage() # release A instance -> will be deleted since now it's managed again a = None self.assertEqual(pya.A.a0(), ac0) self.assertEqual(pya.A.a20_get() == None, True) def test_28(self): self.assertEqual(pya.B.inst() == None, True) self.assertEqual(pya.B.has_inst(), False) b = pya.B() pya.B.set_inst(b) self.assertEqual(pya.B.has_inst(), True) self.assertEqual(pya.B.inst() == b, False) self.assertEqual(pya.B.inst().addr(), b.addr()) # new B instance -> will delete the old one b = None self.assertEqual(pya.B.has_inst(), False) b = pya.B() pya.B.set_inst(b) b._unmanage() ba = b.addr() self.assertEqual(pya.B.has_inst(), True) self.assertEqual(pya.B.inst() == b, False) self.assertEqual(pya.B.inst().addr(), b.addr()) # new B instance -> will not delete the old one (since we made it unmanaged) b = None self.assertEqual(pya.B.has_inst(), True) self.assertEqual(pya.B.inst().addr(), ba) # Make it managed again pya.B.inst()._manage() # new B instance -> will delete the old one (since we made it managed again) b = None self.assertEqual(pya.B.has_inst(), False) def test_30(self): # some basic tests for the *Value boxing classes val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) val.value = 17.5 self.assertEqual(val.value, 17.5) self.assertEqual(val.to_s(), "17.5") val.value += 1 self.assertEqual(val.to_s(), "18.5") val = pya.Value(5) self.assertEqual(val.value, 5) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) val.value = 17.5 self.assertEqual(val.value, 17.5) self.assertEqual(val.to_s(), "17.5") val.value += 1 self.assertEqual(val.to_s(), "18.5") val = pya.Value(5) self.assertEqual(val.value, 5) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) val.value = True self.assertEqual(val.value, True) self.assertEqual(val.to_s(), "true") val = pya.Value(True) self.assertEqual(val.value, True) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) val.value = 17 self.assertEqual(val.value, 17) self.assertEqual(val.to_s(), "17") val.value += 1 self.assertEqual(val.to_s(), "18") val = pya.Value(5) self.assertEqual(val.value, 5) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) val.value = 17 self.assertEqual(val.value, 17) self.assertEqual(val.to_s(), "17") val.value += 1 self.assertEqual(val.to_s(), "18") val = pya.Value(5) self.assertEqual(val.value, 5) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) val.value = 17 self.assertEqual(val.value, 17) self.assertEqual(val.to_s(), "17") val.value += 1 self.assertEqual(val.to_s(), "18") val = pya.Value(5) self.assertEqual(val.value, 5) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) if sys.version_info < (3, 0): # Version 2.x has int instead of long val.value = 270000000 self.assertEqual(val.value, 270000000) self.assertEqual(val.to_s(), "270000000") val.value += 1 self.assertEqual(val.to_s(), "270000001") else: val.value = 2700000000 self.assertEqual(val.value, 2700000000) self.assertEqual(val.to_s(), "2700000000") val.value += 1 self.assertEqual(val.to_s(), "2700000001") val = pya.Value(500000000) self.assertEqual(val.value, 500000000) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) if sys.version_info < (3, 0): # Version 2.x has int instead of long val.value = 1700000000 self.assertEqual(val.to_s(), "1700000000") self.assertEqual(val.value, 1700000000) val.value += 1 self.assertEqual(val.to_s(), "1700000001") val = pya.Value(500000000) self.assertEqual(val.value, 500000000) else: val.value = 170000000000 self.assertEqual(val.to_s(), "170000000000") self.assertEqual(val.value, 170000000000) val.value += 1 self.assertEqual(val.to_s(), "170000000001") val = pya.Value(50000000000) self.assertEqual(val.value, 50000000000) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.to_s(), "nil") self.assertEqual(val.value, None) if sys.version_info < (3, 0): # Version 2.x has int instead of long val.value = 1700000000 self.assertEqual(val.value, 1700000000) self.assertEqual(val.to_s(), "1700000000") val.value += 1 self.assertEqual(val.to_s(), "1700000001") val = pya.Value(500000000) self.assertEqual(val.value, 500000000) else: val.value = 170000000000 self.assertEqual(val.value, 170000000000) self.assertEqual(val.to_s(), "170000000000") val.value += 1 self.assertEqual(val.to_s(), "170000000001") val = pya.Value(50000000000) self.assertEqual(val.value, 50000000000) val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val = pya.Value() self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") val.value = "abc" self.assertEqual(val.value, "abc") self.assertEqual(val.to_s(), "abc") val.value += "x" self.assertEqual(val.to_s(), "abcx") val = pya.Value("uv") self.assertEqual(val.value, "uv") val.value = None self.assertEqual(val.value, None) self.assertEqual(val.to_s(), "nil") def test_31(self): # some basic tests with derived and base classes pya.X.init() pya.Y.init() x = pya.X("hallo") self.assertEqual(True, isinstance(x, pya.X)) self.assertEqual(False, isinstance(x, pya.A)) self.assertEqual(False, isinstance(x, pya.Y)) self.assertEqual("hallo", x.s) self.assertEqual("X", x.cls_name()) cxp = pya.X.x_cptr() self.assertEqual("X::a", cxp.s) try: cxp.s = "x" error_caught = False except: error_caught = True self.assertEqual(True, error_caught) xp = pya.X.x_ptr() self.assertEqual("X::a", xp.s) s_old = xp.s xp.s = "x" self.assertEqual("x", xp.s) xp.s = 41 self.assertEqual("42", xp.s) xp.s = s_old y = pya.Y("hallo") self.assertEqual(True, isinstance(y, pya.X)) self.assertEqual(False, isinstance(y, pya.A)) self.assertEqual(True, isinstance(y, pya.Y)) self.assertEqual("hallo", y.s) self.assertEqual("Y", y.cls_name()) self.assertEqual(5, y.i()) cyp = pya.Y.y_cptr() self.assertEqual("Y::a", cyp.s) self.assertEqual("Y", cyp.cls_name()) try: cyp.s = "y" error_caught = False except: error_caught = True self.assertEqual(True, error_caught) yp = pya.Y.y_ptr() self.assertEqual("Y", yp.cls_name()) self.assertEqual("Y::a", yp.s) yp.s = "y" self.assertEqual("y", yp.s) self.assertEqual(1, yp.i()) yp.s = "abc" self.assertEqual(3, yp.i()) self.assertEqual("Y", type(yp).__name__) def test_32(self): # run test only if we have Qt bindings if not "QStringPair" in pya.__dict__: return # QPair p = pya.QStringPair() p.first = "a" p.second = "b" self.assertEqual("a", p.first) self.assertEqual("b", p.second) pp = p.dup() self.assertEqual("a", pp.first) self.assertEqual("b", pp.second) pp.first = "u" self.assertEqual("a", p.first) self.assertEqual("b", p.second) self.assertEqual("u", pp.first) self.assertEqual("b", pp.second) self.assertEqual(pp == p, False) self.assertEqual(pp != p, True) pp = pya.QStringPair("a", "b") self.assertEqual("a", pp.first) self.assertEqual("b", pp.second) self.assertEqual(pp == p, True) self.assertEqual(pp != p, False) def test_33(self): def str_from_bytearray(ba): if (sys.version_info > (3, 0)): return ba else: return ba.decode("utf-8") # run test only if we have Qt bindings if not "QByteArrayPair" in pya.__dict__: return # QPair p = pya.QByteArrayPair() p.first = "a" p.second = "b" self.assertEqual("a", str_from_bytearray(p.first)) self.assertEqual("b", str_from_bytearray(p.second)) pp = p.dup() self.assertEqual("a", str_from_bytearray(pp.first)) self.assertEqual("b", str_from_bytearray(pp.second)) pp.first = "u" self.assertEqual("a", str_from_bytearray(p.first)) self.assertEqual("b", str_from_bytearray(p.second)) self.assertEqual("u", str_from_bytearray(pp.first)) self.assertEqual("b", str_from_bytearray(pp.second)) self.assertEqual(pp == p, False) self.assertEqual(pp != p, True) pp = pya.QByteArrayPair("a", "b") self.assertEqual("a", str_from_bytearray(pp.first)) self.assertEqual("b", str_from_bytearray(pp.second)) self.assertEqual(pp == p, True) self.assertEqual(pp != p, False) def test_34(self): # run test only if we have Qt bindings if not "QDialog" in pya.__dict__: return # QDialog and QWidget # Hint: QApplication creates some leaks (FT, GTK). Hence it must not be used in the leak_check case .. if not leak_check: a = pya.QCoreApplication.instance() self.assertEqual("", str(type(a))) qd = pya.QDialog() pya.QApplication.setActiveWindow(qd) self.assertEqual(repr(pya.QApplication.activeWindow), repr(qd)) self.assertEqual("", str(type(pya.QApplication.activeWindow))) qd._destroy() self.assertEqual(repr(pya.QApplication.activeWindow), "None") def test_35(self): # vectors of pointers pya.X.init() pya.Y.init() vx_cptr = pya.X.vx_cptr() self.assertEqual(2, len(vx_cptr)) try: vx_cptr[0].s = "y" error_caught = False except: error_caught = True self.assertEqual(True, error_caught) vx = pya.X.vx() self.assertEqual(2, len(vx)) self.assertEqual("X::a", vx[0].s) self.assertEqual("X::b", vx[1].s) vx_ptr = pya.X.vx_ptr() self.assertEqual(2, len(vx_ptr)) self.assertEqual("X", type(vx_ptr[0]).__name__) self.assertEqual("X", type(vx_ptr[1]).__name__) vx_ptr[0].s = "u" self.assertEqual("u", vx_cptr[0].s) self.assertEqual("X::a", vx[0].s) self.assertEqual("X::b", vx[1].s) vy_cptr = pya.Y.vy_cptr() self.assertEqual(2, len(vy_cptr)) try: vy_cptr[0].s = "y" error_caught = False except: error_caught = True self.assertEqual(True, error_caught) vy_cptr = pya.Y.vyasx_cptr() self.assertEqual(2, len(vy_cptr)) try: vy_cptr[0].s = "y" error_caught = False except: error_caught = True self.assertEqual(True, error_caught) vy0_ptr = pya.Y.vy0_ptr() self.assertEqual(1, len(vy0_ptr)) self.assertEqual("None", str(vy0_ptr[0])) vy_ptr = pya.Y.vy_ptr() self.assertEqual(2, len(vy_ptr)) self.assertEqual("Y", type(vy_ptr[0]).__name__) self.assertEqual("Y", type(vy_ptr[1]).__name__) vy_ptr[0].s = "uvw" self.assertEqual("uvw", vy_cptr[0].s) self.assertEqual(3, vy_cptr[0].i()) vy_ptr = pya.Y.vyasx_ptr() self.assertEqual(2, len(vy_ptr)) self.assertEqual("Y", type(vy_ptr[0]).__name__) self.assertEqual("Y", type(vy_ptr[1]).__name__) vy_ptr[0].s = "uvw" self.assertEqual("uvw", vy_cptr[0].s) self.assertEqual(3, vy_cptr[0].i()) y = pya.Y("") yc = y.vx_dyn_count() y.vx_dyn_make() self.assertEqual(yc + 1, y.vx_dyn_count()) y.vx_dyn_destroy() self.assertEqual(yc, y.vx_dyn_count()) y.vx_dyn_make() self.assertEqual(yc + 1, y.vx_dyn_count()) yy = y.vx_dyn() self.assertEqual(1, len(yy)) self.assertEqual("Y", type(yy[0]).__name__) self.assertEqual(True, yy[0] != None) yy[0].destroy() self.assertEqual(True, yy[0].destroyed()) self.assertEqual(yc, y.vx_dyn_count()) y.vx_dyn_make() self.assertEqual(yc + 1, y.vx_dyn_count()) yy = y.vx_dyn() self.assertEqual(1, len(yy)) self.assertEqual("Y", type(yy[0]).__name__) self.assertEqual(True, yy[0] != None) y.vx_dyn_destroy() self.assertEqual(True, yy[0].destroyed()) self.assertEqual(yc, y.vx_dyn_count()) def test_36(self): x = XEdge() self.assertEqual("XEdge", type(x).__name__) self.assertEqual("(1,2;3,4)", str(x)) def test_37(self): # This test is taken from the Ruby binding, but # Python does not have protected methods: return # protected methods ok = False a = pya.A() e = "" try: a.a10_prot() # cannot be called - is protected ok = True except Exception as ex: e = str(ex) self.assertEqual(e == "protected method `a10_prot' called", 0) self.assertEqual(ok, False) self.assertEqual(a.call_a10_prot(1.25), "1.25") def test_38(self): # mixed const / non-const reference and events ec = pya.E.ic() self.assertEqual(ec.is_const_object(), True) enc = pya.E.inc() # Now, ec has turned into a non-const reference as well! # This is strange but is a consequence of the unique C++/Python binding and there can # only be a non-const or const ruby object! self.assertEqual(ec.is_const_object(), False) self.assertEqual(enc.is_const_object(), False) # the "True reference" is a not copy since E is derived from ObjectBase ec.x = 15 self.assertEqual(ec.x, 15); ec2 = pya.E.ic() self.assertEqual(ec2.x, 15); ec2 = pya.E.icref() self.assertEqual(ec2.x, 15); ec2.x = 17 self.assertEqual(ec2.x, 17); self.assertEqual(ec.x, 17); self.assertEqual(ec2.is_const_object(), False) # because it's a copy # the "True reference" is a not copy since E is derived from ObjectBase enc2 = pya.E.incref() self.assertEqual(enc2.x, 17); enc2.x = 19 self.assertEqual(enc2.x, 19); self.assertEqual(ec.x, 19); # because the non-const reference by incref is not a copy def test_39(self): # mixed const / non-const reference and events fc = pya.F.ic() self.assertEqual(fc.is_const_object(), True) fnc = pya.F.inc() # In contrase to E, the fc reference is not touched because F is not derived # from ObjectBase self.assertEqual(fc.is_const_object(), True) self.assertEqual(fnc.is_const_object(), False) # the "True reference" is a copy fnc.x = 15 self.assertEqual(fc.x, 15); fc2 = pya.F.ic() self.assertEqual(fc2.x, 15); fc2 = pya.F.icref() self.assertEqual(fc2.x, 15); fc2.x = 17 self.assertEqual(fc2.x, 17); self.assertEqual(fc.x, 15); self.assertEqual(fc2.is_const_object(), False) # because it's a copy # the "True reference" is a copy fnc2 = pya.F.incref() self.assertEqual(fnc2.x, 15); fnc2.x = 19 self.assertEqual(fnc2.x, 19); self.assertEqual(fc.x, 19); # because the non-const reference by incref is not a copy def test_40(self): # optional arguments g = pya.G() self.assertEqual(g.iv(), 0) g.set_iva(2) self.assertEqual(g.iv(), 2) g.set_ivb(3) self.assertEqual(g.iv(), 3) g.set_ivb() self.assertEqual(g.iv(), 1) g.set_sv1a("hello") self.assertEqual(g.sv(), "hello") failed = False try: g.set_sv1a() except: failed = True self.assertEqual(failed, True) g.set_sv1b("world") self.assertEqual(g.sv(), "world") g.set_sv1b() self.assertEqual(g.sv(), "value") g.set_sv2a("hello") self.assertEqual(g.sv(), "hello") failed = False try: g.set_sv2a() except: failed = True self.assertEqual(failed, True) g.set_sv2b("world") self.assertEqual(g.sv(), "world") g.set_sv2b() self.assertEqual(g.sv(), "value") g.set_vva(17, "c") self.assertEqual(g.iv(), 17) self.assertEqual(g.sv(), "c") failed = False try: g.set_svva() except: failed = True self.assertEqual(failed, True) failed = False try: g.set_svva(11) except: failed = True self.assertEqual(failed, True) g.set_vvb(11) self.assertEqual(g.iv(), 11) self.assertEqual(g.sv(), "value") g.set_vvb(10, "None") self.assertEqual(g.iv(), 10) self.assertEqual(g.sv(), "None") failed = False try: g.set_svvb() except: failed = True self.assertEqual(failed, True) g.set_vvc(11) self.assertEqual(g.iv(), 11) self.assertEqual(g.sv(), "value") g.set_vvc() self.assertEqual(g.iv(), 1) self.assertEqual(g.sv(), "value") g.set_vvc(17, "None") self.assertEqual(g.iv(), 17) self.assertEqual(g.sv(), "None") def test_41(self): v3 = sys.version_info >= (3, 0) # maps b = pya.B() b.insert_map1(1, "hello") if v3: self.assertEqual(repr(b.map1), "{1: 'hello'}") else: self.assertEqual(repr(b.map1), "{1L: 'hello'}") b.map1 = {} b.insert_map1(2, "hello") if v3: self.assertEqual(repr(b.map1_cref()), "{2: 'hello'}") else: self.assertEqual(repr(b.map1_cref()), "{2L: 'hello'}") b.map1 = {} b.insert_map1(3, "hello") if v3: self.assertEqual(repr(b.map1_cptr()), "{3: 'hello'}") else: self.assertEqual(repr(b.map1_cptr()), "{3L: 'hello'}") b.map1 = {} b.insert_map1(4, "hello") if v3: self.assertEqual(repr(b.map1_ref()), "{4: 'hello'}") else: self.assertEqual(repr(b.map1_ref()), "{4L: 'hello'}") b.map1 = {} b.insert_map1(5, "hello") if v3: self.assertEqual(repr(b.map1_ptr()), "{5: 'hello'}") else: self.assertEqual(repr(b.map1_ptr()), "{5L: 'hello'}") self.assertEqual(b.map1_cptr_null() == None, True); self.assertEqual(b.map1_ptr_null() == None, True); try: # error converting 1 or True to string b.map1 = { 42: 1, -17: True } error_caught = False except: error_caught = True self.assertEqual(error_caught, True) b.map1 = { 42: "1", -17: "True" } if v3: self.assertEqual(repr(b.map1), "{42: '1', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '1', -17L: 'True'}") b.set_map1_cref({ 42: "2", -17: "True" }) if v3: self.assertEqual(repr(b.map1), "{42: '2', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '2', -17L: 'True'}") b.set_map1_cptr({ 42: "3", -17: "True" }) if v3: self.assertEqual(repr(b.map1), "{42: '3', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '3', -17L: 'True'}") b.set_map1_cptr(None) if v3: self.assertEqual(repr(b.map1), "{42: '3', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '3', -17L: 'True'}") b.set_map1_ref({ 42: "4", -17: "True" }) if v3: self.assertEqual(repr(b.map1), "{42: '4', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '4', -17L: 'True'}") b.set_map1_ptr({ 42: "5", -17: "True" }) if v3: self.assertEqual(repr(b.map1), "{42: '5', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '5', -17L: 'True'}") b.set_map1_ptr(None) if v3: self.assertEqual(repr(b.map1), "{42: '5', -17: 'True'}") else: self.assertEqual(repr(b.map1), "{42L: '5', -17L: 'True'}") b.map2 = { 'xy': 1, -17: True } if v3: self.assertEqual(repr(b.map2), "{'xy': 1, -17: True}") else: self.assertEqual(repr(b.map2), "{'xy': 1L, -17L: True}") self.assertEqual(b.map2_null(), None) def test_42(self): # virtual functions and sub-classes z = pya.Z() self.assertEqual(z.f(None), "(nil)") self.assertEqual(z.f(pya.X("hello")), "hello") z1 = Z_IMP1() self.assertEqual(z1.f(pya.X("a")), "X") self.assertEqual(z1.f(pya.Y("b")), "Y") self.assertEqual(z1.f_with_x("a"), "X") self.assertEqual(z1.f_with_y("b"), "Y") self.assertEqual(z1.f_with_yy("b"), "YY") z2 = Z_IMP2() self.assertEqual(z2.f(pya.X("1")), "X") self.assertEqual(z2.f(pya.Y("2")), "Y") self.assertEqual(z2.f_with_x("1"), "X") self.assertEqual(z2.f_with_y("2"), "Y") self.assertEqual(z2.f_with_yy("3"), "Y") z1 = Z_IMP3() self.assertEqual(z1.f(pya.X("x")), "x*") self.assertEqual(z1.f(pya.Y("y")), "y*") self.assertEqual(z1.f_with_x("x"), "x*") self.assertEqual(z1.f_with_y("y"), "y*") self.assertEqual(z1.f_with_yy("yy"), "yy*") def test_50(self): # advanced containers and out parameters b = pya.B() a1 = AEXT() a1.s(42) a1.a5(11) a2 = AEXT() a2.s(17) a2.a5(22) a3 = AEXT() a3.s(33) a3.a5(33) b.set_map_iaptr( { 1: a1, 2: a2 } ) self.assertEqual(repr(b.map_iaptr()), ph("{1X: 42, 2X: 17}")) self.assertEqual(repr(b.map_iaptr_cref()), ph("{1X: 42, 2X: 17}")) self.assertEqual(repr(b.map_iaptr_ref()), ph("{1X: 42, 2X: 17}")) self.assertEqual(repr(b.map_iaptr_cptr()), ph("{1X: 42, 2X: 17}")) self.assertEqual(repr(b.map_iaptr_ptr()), ph("{1X: 42, 2X: 17}")) b.set_map_iaptr_cptr(None) self.assertEqual(repr(b.map_iaptr()), "{}") b.set_map_iaptr_cptr( { 17: a2, 42: a1 } ) self.assertEqual(repr(b.map_iaptr()), ph("{17X: 17, 42X: 42}")) b.set_map_iaptr_ptr( { 18: a2, 43: a1 } ) self.assertEqual(repr(b.map_iaptr()), ph("{18X: 17, 43X: 42}")) b.set_map_iaptr_ref( { 1: a2, 3: a1 } ) self.assertEqual(repr(b.map_iaptr()), ph("{1X: 17, 3X: 42}")) b.set_map_iaptr_cref( { 2: a2, 4: a1 } ) self.assertEqual(repr(b.map_iaptr()), ph("{2X: 17, 4X: 42}")) b.set_map_iaptr_ptr( { } ) self.assertEqual(repr(b.map_iaptr()), "{}") b.set_map_iaptr_cref( { 2: a2, 4: a1 } ) self.assertEqual(repr(b.map_iaptr()), ph("{2X: 17, 4X: 42}")) b.set_map_iaptr_ptr(None) self.assertEqual(repr(b.map_iaptr()), "{}") m = { 2: a1, 4: a2 } # map as an "out" parameter: pya.B.insert_map_iaptr(m, 3, a3) self.assertEqual(repr(m), ph("{2X: 42, 3X: 33, 4X: 17}")) b.set_map_iacptr( { 1: a1, 2: a2 } ) self.assertEqual(repr(b.map_iacptr()), ph("{1X: 42, 2X: 17}")) m = { 2: a1, 4: a2 } # map as an "out" parameter: pya.B.insert_map_iacptr(m, 5, a3) self.assertEqual(repr(m), ph("{2X: 42, 4X: 17, 5X: 33}")) b.set_map_ia( { 1: a1, 2: a2 } ) # because we have raw copies, the Ruby-add-on is lost and # only a1 (built-in) remains as an attribute: self.assertEqual(repr(b.map_ia()), ph("{1X: a1=11, 2X: a1=22}")) m = { 2: a1, 4: a2 } # map as an "out" parameter: pya.B.insert_map_ia(m, 5, a3) self.assertEqual(repr(m), ph("{2X: a1=11, 4X: a1=22, 5X: a1=33}")) b.set_map_iav( { 1: [ a1, a2 ], 2: [] } ) # because we have raw copies, the Ruby-add-on is lost and # only a1 (built-in) remains as an attribute: self.assertEqual(repr(b.map_iav()), ph("{1X: [a1=11, a1=22], 2X: []}")) m = { 1: [ a1, a2 ], 2: [] } # map as an "out" parameter: pya.B.push_map_iav(m, 2, a3) self.assertEqual(repr(m), ph("{1X: [a1=11, a1=22], 2X: [a1=33]}")) pya.B.insert_map_iav(m, 5, [ a1, a3 ]) self.assertEqual(repr(m), ph("{1X: [a1=11, a1=22], 2X: [a1=33], 5X: [a1=11, a1=33]}")) v = [ [ "a", "aa" ], [] ] pya.B.push_vvs( v, [ "1", "2" ] ) self.assertEqual(v, [["a", "aa"], [], ["1", "2"]]) b.set_vvs( [ [ "1" ], [ "2", "3" ] ] ) self.assertEqual(b.vvs(), [["1"], ["2", "3"]]) self.assertEqual(b.vvs_ref(), [["1"], ["2", "3"]]) self.assertEqual(b.vvs_cref(), [["1"], ["2", "3"]]) self.assertEqual(b.vvs_ptr(), [["1"], ["2", "3"]]) self.assertEqual(b.vvs_cptr(), [["1"], ["2", "3"]]) b.set_vvs_ref( [ [ "1" ], [ "2", "3" ] ] ) self.assertEqual(b.vvs(), [["1"], ["2", "3"]]) b.set_vvs_cref( [ [ "2" ], [ "1", "3" ] ] ) self.assertEqual(b.vvs(), [["2"], ["1", "3"]]) b.set_vvs_ptr( [ [ "1" ], [ "3", "2" ] ] ) self.assertEqual(b.vvs(), [["1"], ["3", "2"]]) b.set_vvs_ptr(None) self.assertEqual(b.vvs(), []) b.set_vvs_cptr( [ [ "0" ], [ "3", "2" ] ] ) self.assertEqual(b.vvs(), [["0"], ["3", "2"]]) b.set_vvs_cptr(None) self.assertEqual(b.vvs(), []) v = [ "a", "b" ] pya.B.push_ls(v, "x") self.assertEqual(v, [ "a", "b", "x" ]) b.set_ls([ "1" ]) self.assertEqual(b.ls(), [ "1" ]) b.set_ls([]) self.assertEqual(b.ls(), []) # Tuples cannot be modified - this will not work: # v = ( "a", "b" ) # pya.B.push_ls(v, "x") # self.assertEqual(v, ( "a", "b", "x" )) b.set_ls(( "1", "2" )) self.assertEqual(b.ls(), [ "1", "2" ]) b.set_ls(()) self.assertEqual(b.ls(), []) v = [ "a", "b" ] pya.B.push_ss(v, "x") self.assertEqual(v, [ "a", "b", "x" ]) b.set_ss([ "1" ]) self.assertEqual(b.ss(), [ "1" ]) b.set_ss([]) self.assertEqual(b.ss(), []) v = [ "a", "b" ] pya.B.push_qls(v, "x") self.assertEqual(v, [ "a", "b", "x" ]) b.set_qls([ "1" ]) self.assertEqual(b.qls(), [ "1" ]) b.set_qls([]) self.assertEqual(b.qls(), []) v = [ "a", 1 ] pya.B.push_qlv(v, 2.5) self.assertEqual(v, [ "a", 1, 2.5 ]) b.set_qlv([ 17, "1" ]) self.assertEqual(b.qlv(), [ 17, "1" ]) b.set_qlv([]) self.assertEqual(b.qlv(), []) v = [ "a", "b" ] pya.B.push_qsl(v, "x") self.assertEqual(v, [ "a", "b", "x" ]) b.set_qsl([ "1" ]) self.assertEqual(b.qsl(), [ "1" ]) b.set_qsl([]) self.assertEqual(b.qsl(), []) v = [ "a", "b" ] pya.B.push_qvs(v, "x") self.assertEqual(v, [ "a", "b", "x" ]) b.set_qvs([ "1" ]) self.assertEqual(b.qvs(), [ "1" ]) b.set_qvs([]) self.assertEqual(b.qvs(), []) v = [ "a", "b" ] pya.B.push_qss(v, "x") v_sorted = v v_sorted.sort() self.assertEqual(v_sorted, [ "a", "b", "x" ]) b.set_qss([ "1" ]) self.assertEqual(b.qss(), [ "1" ]) b.set_qss([]) self.assertEqual(b.qss(), []) v = { 1: "a", 17: "b" } pya.B.insert_qmap_is(v, 2, "x") self.assertEqual(v, { 1: "a", 17: "b", 2: "x" }) b.set_qmap_is({ 1: "t", 17: "b" }) self.assertEqual(b.qmap_is(), { 1: "t", 17: "b" }) b.set_qmap_is({}) self.assertEqual(b.qmap_is(), {}) v = { 1: "a", 17: "b" } pya.B.insert_qhash_is(v, 2, "x") self.assertEqual(v, { 1: "a", 17: "b", 2: "x" }) b.set_qhash_is({ 1: "t", 17: "b" }) self.assertEqual(b.qhash_is(), { 1: "t", 17: "b" }) b.set_qhash_is({}) self.assertEqual(b.qhash_is(), {}) def test_51(self): # new subclass and child class declarations y2 = pya.Y2() self.assertEqual(y2.x1(), 2) self.assertEqual(y2.x2(), 42) self.assertEqual(isinstance(y2, pya.X), True) y3 = pya.Z.Y3() self.assertEqual(y3.x1(), 3) self.assertEqual(y3.x2(), 42) self.assertEqual(isinstance(y3, pya.X), True) y4 = pya.Z.Y4() self.assertEqual(y4.x1(), 4) self.assertEqual(isinstance(y4, pya.X), False) def test_60(self): class SignalCollector(object): got_s0 = False got_s1 = None got_s2_1 = None got_s2_2 = None def f_s0(self): self.got_s0 = True def f_s1(self, iv): self.got_s1 = iv def f_s2(self, s, obj): self.got_s2_1 = s self.got_s2_2 = obj sc = SignalCollector() sq = pya.SQ() sq.s0 = sc.f_s0 sq.trigger_s0() self.assertEqual(sc.got_s0, True) sq.s1 = sc.f_s1 sq.trigger_s1(17) self.assertEqual(sc.got_s1, 17) sq.trigger_s1(42) self.assertEqual(sc.got_s1, 42) sq.tag = 999 sq.s2 = sc.f_s2 sq.trigger_s2("foo") self.assertEqual(sc.got_s2_1, "foo") self.assertEqual(sc.got_s2_2.tag, 999) sq.tag = 111 sc.got_s2_2 = None sq.trigger_s2("bar") self.assertEqual(sc.got_s2_1, "bar") self.assertEqual(sc.got_s2_2.tag, 111) # clear handler sq.s2 = None sq.tag = 0 sc.got_s2_1 = None sc.got_s2_2 = None sq.trigger_s2("x") self.assertEqual(sc.got_s2_1, None) self.assertEqual(sc.got_s2_2, None) # attach again with set sq.s2.set(sc.f_s2) sq.tag = 2 sc.got_s2_1 = None sc.got_s2_2 = None sq.trigger_s2("y") self.assertEqual(sc.got_s2_1, "y") self.assertEqual(sc.got_s2_2.tag, 2) # clear handler (with clear) sq.s2.clear() sq.tag = 0 sc.got_s2_1 = None sc.got_s2_2 = None sq.trigger_s2("z") self.assertEqual(sc.got_s2_1, None) self.assertEqual(sc.got_s2_2, None) # attach again with add sq.s2.set(sc.f_s2) sq.tag = 2222 sc.got_s2_1 = None sc.got_s2_2 = None sq.trigger_s2("u") self.assertEqual(sc.got_s2_1, "u") self.assertEqual(sc.got_s2_2.tag, 2222) # clear handler (with remove) sq.s2.remove(sc.f_s2) sq.tag = 0 sc.got_s2_1 = None sc.got_s2_2 = None sq.trigger_s2("v") self.assertEqual(sc.got_s2_1, None) self.assertEqual(sc.got_s2_2, None) def test_61(self): class SignalCollector(object): got_s0a = 0 got_s0b = 0 def p1(self): self.got_s0a += 1 def p1b(self): self.got_s0a += 1 def p2(self): self.got_s0b += 1 sc = SignalCollector() sq = pya.SQ() sq.s0 = sc.p1 sq.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 0) sc.got_s0a = 0 sc.got_s0b = 0 sq.s0 = sc.p2 sq.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 sq.s0 += sc.p1 sq.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 # same proc is not added again sq.s0 += sc.p1 sq.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 # second proc p1 with same effect sq.s0 += sc.p1b sq.trigger_s0() self.assertEqual(sc.got_s0a, 2) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 sq.s0 -= sc.p1 sq.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 sq.s0 -= sc.p1b sq.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 sq.s0 -= sc.p1 sq.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 sq.s0 -= sc.p2 sq.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 0) def test_70(self): class SignalCollector(object): got_s0 = False got_s1 = None got_s2_1 = None got_s2_2 = None def f_s0(self): self.got_s0 = True def f_s1(self, iv): self.got_s1 = iv def f_s2(self, s, obj): self.got_s2_1 = s self.got_s2_2 = obj sc = SignalCollector() se = pya.SE() se.s0 = sc.f_s0 se.trigger_s0() self.assertEqual(sc.got_s0, True) sc.got_s1 = None se.s1 = sc.f_s1 se.trigger_s1(17) self.assertEqual(sc.got_s1, 17) se.trigger_s1(42) self.assertEqual(sc.got_s1, 42) sc.got_s2_1 = None sc.got_s2_2 = None se.tag = 999 se.s2 = sc.f_s2 se.trigger_s2("foo") self.assertEqual(sc.got_s2_1, "foo") self.assertEqual(sc.got_s2_2.tag, 999) se.tag = 111 sc.got_s2_2 = None se.trigger_s2("bar") self.assertEqual(sc.got_s2_1, "bar") self.assertEqual(sc.got_s2_2.tag, 111) def test_71(self): class SignalCollector(object): got_s0a = 0 got_s0b = 0 def p1(self): self.got_s0a += 1 def p1b(self): self.got_s0a += 1 def p2(self): self.got_s0b += 1 sc = SignalCollector() se = pya.SE() se.s0 = sc.p1 se.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 0) sc.got_s0a = 0 sc.got_s0b = 0 se.s0 = sc.p2 se.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 se.s0 += sc.p1 se.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 # same proc is not added again se.s0 += sc.p1 se.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 # second proc p1 with same effect se.s0 += sc.p1b se.trigger_s0() self.assertEqual(sc.got_s0a, 2) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 se.s0 -= sc.p1 se.trigger_s0() self.assertEqual(sc.got_s0a, 1) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 se.s0 -= sc.p1b se.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 se.s0 -= sc.p1 se.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 1) sc.got_s0a = 0 sc.got_s0b = 0 se.s0 -= sc.p2 se.trigger_s0() self.assertEqual(sc.got_s0a, 0) self.assertEqual(sc.got_s0b, 0) # Custom factory implemented in Python def test_80(self): gc = pya.GObject.g_inst_count() gf = PyGFactory() go = pya.GFactory.create_f(gf, 17) self.assertEqual(go.g_virtual(), 34) self.assertEqual(go.g_org(), 0) self.assertEqual(pya.GObject.g_inst_count(), gc + 1) go = None self.assertEqual(pya.GObject.g_inst_count(), gc) # run unit tests if __name__ == '__main__': suite = unittest.TestSuite() # NOTE: Use this instead of loadTestsfromTestCase to select a specific test: # suite.addTest(BasicTest("test_26")) suite = unittest.TestLoader().loadTestsFromTestCase(BasicTest) if not unittest.TextTestRunner(verbosity = 1).run(suite).wasSuccessful(): sys.exit(1)