luke/klayout
1
0
Fork 0
mirror of https://github.com/KLayout/klayout.git synced 2026-08-29 17:30:09 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
f8b83357e1fe1113b86135aa34b3eea99ef42b1f
klayout/testdata/python/basic.py
T
Matthias Koefferlein f8b83357e1 Fixing strange behavior of user property generation with Python 
Problem was that integers are converted to "long long"
in Python, which creates Variants rendering "#l1" as
parsable strings. These are marked as invalid by the
Syntax highlighter of the user properties editor.

This patch fixes the user properties editor syntax
highlighter to cover all Variant variants and
uses "long" type for Variant if possible.
2026-08-10 00:09:42 +02:00

3398 lines
98 KiB
Python
Raw Blame History

# KLayout Layout Viewer
# Copyright (C) 2006-2026 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
import copy
import weakref
# Set this to True to disable some tests involving exceptions
leak_check = "TEST_LEAK_CHECK" in os.environ
class ObjectWithStr:
def __init__(self, s):
self.s = s
def __str__(self):
return self.s
# 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.get_n()
# 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.get_n())
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 C_IMP4(pya.C):
def __init__(self):
self.x = None
self.xx = None
def vfunc(self, cd):
self.x = cd.x()
self.xx = cd.xx()
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", "")
def map2str(dict):
# A helper function to product a "canonical" (i.e. sorted-keys) string
# representation of a dict
keys = list(dict)
for k in keys:
if type(k) is str:
strKeys = []
strDict = {}
for x in keys:
strKeys.append(str(x))
strDict[str(x)] = dict[x]
strings = []
for x in sorted(strKeys):
strings.append(str(x) + ": " + str(strDict[x]))
return "{" + ", ".join(strings) + "}"
strings = []
for x in sorted(keys):
strings.append(str(x) + ": " + str(dict[x]))
return "{" + ", ".join(strings) + "}"
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):
# does not work with all Python versions
# (debugging shows that Python calls the setter on the metaclass,
# not on the class itself at least on 3.12)
# # static (class) properties
# pya.A.sp_i = 17
# self.assertEqual(pya.A.sp_i, 18)
# pya.A.sp_i = -1
# self.assertEqual(pya.A.sp_i, 0)
# all references of PA are released now:
ic0 = pya.A.instance_count()
a = pya.A.new_a(100)
self.assertEqual( pya.A.instance_count(), ic0 + 1 )
a = pya.A()
self.assertEqual(a.get_n(), 17)
a.assign(pya.A(110))
self.assertEqual(a.get_n(), 110)
a = None
self.assertEqual( pya.A.instance_count(), ic0 )
a = pya.A()
self.assertEqual( pya.A.instance_count(), ic0 ) # 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.instance_count(), ic0 + 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.instance_count(), ic0 + 2 )
aa = None
self.assertEqual( pya.A.instance_count(), ic0 + 1 )
a = None
self.assertEqual( pya.A.instance_count(), ic0 )
a = pya.A()
self.assertEqual( pya.A.instance_count(), ic0 ) # 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.instance_count(), ic0 + 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.get_n(), 17 )
a.a5(-5)
self.assertEqual( a.get_n(), -5 )
a.a5(0x7fffffff)
self.assertEqual( a.get_n(), 0x7fffffff )
a.a5(-0x80000000)
self.assertEqual( a.get_n(), -0x80000000 )
self.assertEqual( a.a3("a"), 1 )
self.assertEqual( a.a3(ObjectWithStr("abcde")), 5 ) # implicitly using to_s for string conversion
self.assertEqual( a.a3("ab"), 2 )
self.assertEqual( a.a3("µ"), 2 ) # two UTF8 bytes
if "a3_qstr" in a.__dict__:
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.instance_count(), ic0 )
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.instance_count(), ic0 )
a = pya.A.new_a( 55 )
self.assertEqual( pya.A.instance_count(), ic0 + 1 )
self.assertEqual( a.get_n(), 55 )
self.assertEqual( a.a_vp1( a.a_vp2() ), "abc" )
a.destroy()
self.assertEqual( pya.A.instance_count(), ic0 )
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 )
if "Enums" in pya.__dict__:
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_10(self):
# all references of A are released now:
ic0 = pya.A.instance_count()
self.assertEqual(ic0, 0)
a = pya.A.new_a_by_variant()
self.assertEqual(pya.A.instance_count(), ic0 + 1)
self.assertEqual(a.get_n(), 17)
a.a5(-15)
self.assertEqual(a.get_n(), -15)
a = None
self.assertEqual(pya.A.instance_count(), ic0)
ic0 = pya.B.instance_count()
self.assertEqual(ic0, 0)
b = pya.B.new_b_by_variant()
self.assertEqual(pya.B.instance_count(), ic0 + 1)
b.set_str_combine("x", "y")
self.assertEqual(b.str(), "xy")
b._destroy()
self.assertEqual(pya.B.instance_count(), ic0)
def test_11(self):
# implicitly converting tuples/lists to objects by calling the constructor
b = pya.B()
b.av_cptr = [ pya.A(17), [1,2], [4,6,0.5] ]
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [17, 3, 5])
b = pya.B()
# NOTE: this gives an error (printed only) that tuples can't be modified as out parameters
b.av_ref = ( (1,2), (6,2,0.25), [42] )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [3, 2, 42])
b = pya.B()
aa = [ (1,2), (6,2,0.25), [42] ]
b.av_ptr = aa
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [3, 2, 42])
# NOTE: as we used aa in "av_ptr", it got modified as out parameter and
# now holds A object references
arr = []
for a in aa:
arr.append(a.get_n_const())
self.assertEqual(arr, [3, 2, 42])
b.av = ()
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [])
b.push_a_ref( (1, 7) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8])
b.push_a_ptr( (1, 7, 0.25) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2])
b.push_a_cref( [42] )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2, 42])
b.push_a_cptr( (1, 16) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2, 42, 17])
b.push_a( (4, 6, 0.5) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2, 42, 17, 5])
def test_12(self):
a1 = pya.A()
a1.a5( -15 )
a2 = a1
a3 = a2.dup()
self.assertEqual( a1.get_n(), -15 )
self.assertEqual( a2.get_n(), -15 )
self.assertEqual( a3.get_n(), -15 )
a1.a5( 11 )
a3.a5( -11 )
self.assertEqual( a1.get_n(), 11 )
self.assertEqual( a2.get_n(), 11 )
self.assertEqual( a3.get_n(), -11 )
self.assertEqual( a1.a10_d(5.2), "5.2" )
self.assertEqual( a1.a10_s(0x70000000), "0" )
self.assertEqual( a1.a10_s(0x7fffffff), "-1" )
self.assertEqual( a1.a10_us(0x70000000), "0" )
self.assertEqual( a1.a10_us(0x7fffffff), "65535" )
self.assertEqual( a1.a10_i(-0x80000000), "-2147483648" )
self.assertEqual( a1.a10_l(-0x80000000), "-2147483648" )
self.assertEqual( a1.a10_ll(-0x80000000), "-2147483648" )
self.assertEqual( a1.a10_ui(0xffffffff), "4294967295" )
self.assertEqual( a1.a10_ul(0xffffffff), "4294967295" )
self.assertEqual( a1.a10_ull(0xffffffff), "4294967295" )
self.assertEqual( a1.a11_s(0x70000000), 0 )
self.assertEqual( a1.a11_s(0x7fffffff), -1 )
self.assertEqual( a1.a11_us(0x70000000), 0 )
self.assertEqual( a1.a11_us(0x7fffffff), 65535 )
self.assertEqual( a1.a11_i(-0x80000000), -2147483648 )
self.assertEqual( a1.a11_l(-0x80000000), -2147483648 )
self.assertEqual( a1.a11_ll(-0x80000000), -2147483648 )
self.assertEqual( a1.a11_ui(0xffffffff), 4294967295 )
self.assertEqual( a1.a11_ul(0xffffffff), 4294967295 )
self.assertEqual( a1.a11_ull(0xffffffff), 4294967295 )
if "a10_d_qstr" in a1.__dict__:
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.amember_cptr().get_n() # cannot call non-const method on const reference
except:
err_caught = True
self.assertEqual( err_caught, True )
b.amember_cptr().a2()
self.assertEqual(b.always_5(), 5)
self.assertEqual(b.str(), "")
b.set_str("xyz")
self.assertEqual(b.str(), "xyz")
self.assertEqual(b.str_ccptr(), "xyz")
b.set_str_combine("yx", "zz")
self.assertEqual(b.str(), "yxzz")
self.assertEqual(b.str_ccptr(), "yxzz")
arr = []
err_caught = False
if not leak_check:
try:
for a in b.b10():
arr.append(a.get_n()) # 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.get_n()) # 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().get_n())
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().get_n())
self.assertEqual(arr, [100, 121, 144])
return
arr = []
for a in b.b10():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b10p():
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
# Ticket #811:
for a in b.dup().b10p():
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
bdup = b.dup()
for a in bdup.b10p():
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b10p():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b11():
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
bdup = b.dup()
for a in bdup.b11():
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b12():
arr.append(a.get_n())
self.assertEqual(arr, [7100, 7121, 7144, 7169])
arr = []
bdup = b.dup()
for a in bdup.b12():
arr.append(a.get_n())
self.assertEqual(arr, [7100, 7121, 7144, 7169])
aarr = b.b16a()
arr = []
for a in aarr:
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
aarr = b.b16b()
arr = []
for a in aarr:
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
aarr = b.b16c()
arr = []
for a in aarr:
arr.append(a.get_n())
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.get_n())
self.assertEqual(arr, [101, -122])
b.b17a( [] )
arr = []
for a in b.b11():
arr.append(a.get_n())
self.assertEqual(arr, [])
b.b17b( [ pya.A.new_a( 102 ), pya.A.new_a( -123 ) ] )
arr = []
for a in b.b11():
arr.append(a.get_n())
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.get_n())
self.assertEqual(arr, [100, 121, 144])
if not leak_check:
arr = []
try:
for a in b.b13():
arr.append(a.get_n())
except:
err_caught = True
self.assertEqual( err_caught, True )
self.assertEqual(arr, [])
arr = []
for a in b.b13():
arr.append(a.get_n_const())
self.assertEqual(arr, [-3100, -3121])
arr = []
bdup = b.dup()
for a in bdup.b13():
arr.append(a.get_n_const())
self.assertEqual(arr, [-3100, -3121])
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.each_a():
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.each_a_ref():
arr.append(a.get_n_const())
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.each_a_ref():
arr.append(a.get_n())
except:
err_caught = True
end
self.assertEqual(arr, [])
self.assertEqual(err_caught, True)
arr = []
for a in b.each_a_ptr():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
# this does not work since each_a_ptr delivers a "const *" which cannot be used to call a non-const
# method on
err_caught = False
try:
for a in b.each_a_ptr():
arr.append(a.get_n())
except:
err_caught = True
end
self.assertEqual(arr, [])
self.assertEqual(err_caught, True)
def test_13b(self):
b = pya.B()
bb = pya.B()
bb.set_str("a")
b.push_b(bb)
bb = pya.B()
bb.set_str("y")
b.push_b(bb)
bb = pya.B()
bb.set_str("uu")
b.push_b(bb)
arr = []
for bb in b.each_b_copy():
arr.append(bb.str())
self.assertEqual(arr, ["a", "y", "uu"])
arr = []
for bb in b.each_b_copy():
bb.set_str(bb.str() + "x")
arr.append(bb.str())
self.assertEqual(arr, ["ax", "yx", "uux"])
arr = []
for bb in b.each_b_copy():
arr.append(bb.str())
self.assertEqual(arr, ["a", "y", "uu"])
arr = []
for bb in b.each_b_cref():
arr.append(bb.str())
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.set_str(bb.str() + "x")
arr.append(bb.str())
self.assertEqual(arr, ["ax", "yx", "uux"])
arr = []
for bb in b.each_b_cref():
arr.append(bb.str())
self.assertEqual(arr, ["a", "y", "uu"])
arr = []
for bb in b.each_b_cptr():
arr.append(bb.str())
self.assertEqual(arr, ["a", "y", "uu"])
arr = []
# const references cannot be modified
err_caught = False
try:
for bb in b.each_b_cptr():
bb.set_str(bb.str() + "x")
arr.append(bb.str())
except:
err_caught = True
self.assertEqual(err_caught, True)
self.assertEqual(arr, [])
arr = []
for bb in b.each_b_cptr():
arr.append(bb.str())
self.assertEqual(arr, ["a", "y", "uu"])
arr = []
for bb in b.each_b_ref():
arr.append(bb.str())
self.assertEqual(arr, ["a", "y", "uu"])
arr = []
for bb in b.each_b_ref():
bb.set_str(bb.str() + "x")
arr.append(bb.str())
self.assertEqual(arr, ["ax", "yx", "uux"])
arr = []
for bb in b.each_b_ref():
arr.append(bb.str())
self.assertEqual(arr, ["ax", "yx", "uux"])
arr = []
for bb in b.each_b_ptr():
arr.append(bb.str())
self.assertEqual(arr, ["ax", "yx", "uux"])
arr = []
for bb in b.each_b_ptr():
bb.set_str(bb.str() + "x")
arr.append(bb.str())
self.assertEqual(arr, ["axx", "yxx", "uuxx"])
arr = []
for bb in b.each_b_ptr():
arr.append(bb.str())
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) for argument #1 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) for argument #1 in B.b4" );
def test_17(self):
# test copies of objects being returned
b = pya.B()
b._create() # force constructor of B to allocate some A instances internally
a_count = pya.A.instance_count()
a = b.make_a( 1971 );
self.assertEqual( pya.A.instance_count(), a_count + 1 )
self.assertEqual( a.get_n(), 1971 );
self.assertEqual( b.an( a ), 1971 );
aa = b.make_a( -61 );
self.assertEqual( pya.A.instance_count(), a_count + 2 )
self.assertEqual( b.an_cref( aa ), -61 );
self.assertEqual( a.get_n(), 1971 );
self.assertEqual( b.an( a ), 1971 );
self.assertEqual( aa.get_n(), -61 );
self.assertEqual( b.an( aa ), -61 );
aa.a5(98);
a.a5(100);
self.assertEqual( a.get_n(), 100 );
self.assertEqual( b.an( a ), 100 );
self.assertEqual( aa.get_n(), 98 );
self.assertEqual( b.an( aa ), 98 );
a._destroy()
aa = None
self.assertEqual( pya.A.instance_count(), a_count )
def test_18(self):
# Test references to objects (returned by b.amember_cptr)
b = pya.B()
b.set_an( 77 )
self.assertEqual( b.amember_cptr().get_n_const(), 77 );
b.set_an_cref( 79 )
self.assertEqual( b.amember_cptr().get_n_const(), 79 );
aref = b.amember_cptr()
err_caught = False
if not leak_check:
try:
x = aref.get_n() # cannot call non-const method on const reference (as delivered by amember_cptr)
except:
err_caught = True
self.assertEqual( err_caught, True )
self.assertEqual( aref.get_n_const(), 79 );
b.set_an( -1 )
self.assertEqual( aref.get_n_const(), -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 ] )
c4 = C_IMP4()
c4.call_vfunc(pya.CopyDetector(17))
self.assertEqual(c4.x, 17)
self.assertEqual(c4.xx, 17)
def test_20(self):
b = pya.B()
a1 = b.amember_or_nil_alt( True )
a2 = b.amember_ptr_alt()
self.assertEqual( a1.get_n(), 17 )
self.assertEqual( a2.get_n(), 17 )
a1.a5( 761 )
self.assertEqual( a1.get_n(), 761 )
self.assertEqual( a2.get_n(), 761 )
a1 = b.amember_or_nil( False )
self.assertEqual( a1, None )
self.assertEqual( b.b15( b.amember_ptr() ), True )
self.assertEqual( b.b15( b.amember_or_nil( 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()
# amember_ptr() returns a pya.A object, but it cannot be extended dynamically by a method s ...
b.amember_ptr().s( 117 )
self.assertEqual( b.amember_ptr().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()
longint = 10000000000000000
longint_as_int = (sys.maxsize > 5000000000 or (str(longint) == "10000000000000000" and type(longint) is int))
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( longint ), 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 longint_as_int:
# this fits into a long value, therefore this test returns false:
self.assertEqual( b.b20b( longint ), False )
else:
# otherwise it is converted to a double:
self.assertEqual( b.b20b( longint ), True )
self.assertEqual( b.b20c( 5.0 ), False )
self.assertEqual( b.b20c( None ), False )
if longint_as_int:
# this fits into a long value, therefore this test returns false:
self.assertEqual( b.b20c( longint ), True )
else:
# otherwise it is converted to a double and the test returns false:
self.assertEqual( b.b20c( longint ), 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( longint ), 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( longint ), 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" )
# byte arrays through Variants
if sys.version_info >= (3, 0):
self.assertEqual( b.b22a( [ bytes('abc', 'utf-8') ] ), 1 )
self.assertEqual( str(b.b22c()), "b'abc'" )
self.assertEqual( str(b.b22d()), "b'abc'" )
self.assertEqual( str(b.var()), "b'abc'" )
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.instance_count() # instance count
self.assertEqual(b.bx(a, 15), "aref+i")
self.assertEqual(pya.A.instance_count(), 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.instance_count(), 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
n[0] = 0
e.e0(f4)
e.s1()
self.assertEqual( 2, n[0] )
# remove event handler -> no events triggered anymore
n[0] = 0
e.e0 -= f4
e.s1()
self.assertEqual( 0, n[0] )
# adding again will re-activate it
e.e0 += f4
n[0] = 0
e.s1()
self.assertEqual( 2, n[0] )
# two events at once
def f5():
n[0] = n[0] + 10
n[0] = 0
e.e0 += f5
e.s1()
self.assertEqual( 12, n[0] )
# clearing events
e.e0.clear()
e.s1()
n[0] = 0
self.assertEqual( 0, n[0] )
# synonyms: add, connect
e.e0.add(f4)
e.e0.connect(f5)
n[0] = 0
e.s1()
self.assertEqual( 12, n[0] )
# synonyms: remove, disconnect
e.e0.disconnect(f4)
n[0] = 0
e.s1()
self.assertEqual( 10, n[0] )
n[0] = 0
e.e0.remove(f5)
e.s1()
self.assertEqual( 0, n[0] )
# another signal
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)
ic0 = pya.A.instance_count()
a = pya.A()
a.create()
self.assertEqual(a.destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 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.instance_count(), ic0)
a = pya.A()
a.create()
self.assertEqual(a.destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 1)
pya.A.a20(a) # install static instance of A
self.assertEqual(a.destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 1)
pya.A.a20(a) # re-install static instance of A
self.assertEqual(a.destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 1)
# install another instance
aa = pya.A()
aa.create()
self.assertEqual(aa.destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 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.instance_count(), ic0 + 1)
pya.A.a20(None) # discard installed instance
self.assertEqual(aa.destroyed(), True)
self.assertEqual(pya.A.instance_count(), ic0)
# 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.instance_count(), ic0)
pya.A.a20(a) # install static instance of A
self.assertEqual(a.destroyed(), False)
pya.A.a20(None)
self.assertEqual(pya.A.instance_count(), ic0)
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)
ic0 = pya.A.instance_count()
a = pya.A()
a._create()
self.assertEqual(a._destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 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.instance_count(), ic0)
self.assertEqual(pya.A.a20_get() == None, True)
a = pya.A()
a._create()
self.assertEqual(a.destroyed(), False)
self.assertEqual(pya.A.instance_count(), ic0 + 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.instance_count(), ic0 + 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.instance_count(), ic0)
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_29(self):
# copy/ref semantics on return
c = pya.C()
cd = pya.CopyDetector(42)
cd2 = c.pass_cd_direct(cd)
self.assertEqual(cd2.x(), 42)
# two copies: one for return statement and then one for the new object
self.assertEqual(cd2.xx(), 44)
cd2 = c.pass_cd_cref(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 43)
cd2 = c.pass_cd_cref_as_copy(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 43)
cd2 = c.pass_cd_cref_as_ref(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
cd2 = c.pass_cd_cptr(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
cd2 = c.pass_cd_cptr_as_copy(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 43)
cd2 = c.pass_cd_cptr_as_ref(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
cd2 = c.pass_cd_ptr(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
cd2 = c.pass_cd_ptr_as_copy(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 43)
cd2 = c.pass_cd_ptr_as_ref(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
cd2 = c.pass_cd_ref(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
cd2 = c.pass_cd_ref_as_copy(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 43)
cd2 = c.pass_cd_ref_as_ref(cd)
self.assertEqual(cd2.x(), 42)
self.assertEqual(cd2.xx(), 42)
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<String, String>
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<QByteArray, QByteArray>
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("<class 'klayout.pyacore.Application'>", str(type(a)))
qd = pya.QDialog()
pya.QApplication.setActiveWindow(qd)
self.assertEqual(repr(pya.QApplication.activeWindow), repr(qd))
self.assertEqual("<class 'klayout.pyacore.QDialog'>", 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):
pya.E.reset_inst()
# 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):
# maps
b = pya.B()
b.insert_map1(1, "hello")
self.assertEqual(map2str(b.map1), "{1: hello}")
b.map1 = {}
b.insert_map1(2, "hello")
self.assertEqual(map2str(b.map1_cref()), "{2: hello}")
b.map1 = {}
b.insert_map1(3, "hello")
self.assertEqual(map2str(b.map1_cptr()), "{3: hello}")
b.map1 = {}
b.insert_map1(4, "hello")
self.assertEqual(map2str(b.map1_ref()), "{4: hello}")
b.map1 = {}
b.insert_map1(5, "hello")
self.assertEqual(map2str(b.map1_ptr()), "{5: hello}")
self.assertEqual(b.map1_cptr_null() == None, True);
self.assertEqual(b.map1_ptr_null() == None, True);
b.map1 = { 42: 1, -17: True }
self.assertEqual(map2str(b.map1), "{-17: True, 42: 1}")
b.map1 = { 42: "1", -17: "True" }
self.assertEqual(map2str(b.map1), "{-17: True, 42: 1}")
b.set_map1_cref({ 42: "2", -17: "True" })
self.assertEqual(map2str(b.map1), "{-17: True, 42: 2}")
b.set_map1_cptr({ 42: "3", -17: "True" })
self.assertEqual(map2str(b.map1), "{-17: True, 42: 3}")
b.set_map1_cptr(None)
self.assertEqual(map2str(b.map1), "{-17: True, 42: 3}")
b.set_map1_ref({ 42: "4", -17: "True" })
self.assertEqual(map2str(b.map1), "{-17: True, 42: 4}")
b.set_map1_ptr({ 42: "5", -17: "True" })
self.assertEqual(map2str(b.map1), "{-17: True, 42: 5}")
b.set_map1_ptr(None)
self.assertEqual(map2str(b.map1), "{-17: True, 42: 5}")
b.map2 = { 'xy': 1, -17: True }
self.assertEqual(map2str(b.map2), "{-17: True, xy: 1}")
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(), [])
if "set_qls" in b.__dict__:
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):
if not "SQ" in pya.__dict__:
return
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):
if not "SQ" in pya.__dict__:
return
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)
def test_QByteArray(self):
# QByteArray
if "ia_cref_to_qba" in pya.A.__dict__:
qba = pya.A.ia_cref_to_qba([ 16, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qba), "bytearray(b'\\x10*\\x00\\x08')")
self.assertEqual(repr(pya.A.ft_qba(qba)), "bytearray(b'\\x10*\\x00\\x08')")
self.assertEqual(repr(pya.A.ft_var(qba)), "bytearray(b'\\x10*\\x00\\x08')")
else:
self.assertEqual(repr(qba), "b'\\x10*\\x00\\x08'")
self.assertEqual(repr(pya.A.ft_qba(qba)), "b'\\x10*\\x00\\x08'")
self.assertEqual(repr(pya.A.ft_var(qba)), "b'\\x10*\\x00\\x08'")
self.assertEqual(pya.A.qba_to_ia(qba), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qba_cref_to_ia(qba), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qba_cptr_to_ia(qba), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qba_ref_to_ia(qba), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qba_ptr_to_ia(qba), [ 16, 42, 0, 8 ])
qba = pya.A.ia_cref_to_qba_cref([ 17, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qba), "bytearray(b'\\x11*\\x00\\x08')")
else:
self.assertEqual(repr(qba), "b'\\x11*\\x00\\x08'")
qba = pya.A.ia_cref_to_qba_ref([ 18, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qba), "bytearray(b'\\x12*\\x00\\x08')")
else:
self.assertEqual(repr(qba), "b'\\x12*\\x00\\x08'")
qba = pya.A.ia_cref_to_qba_cptr([ 19, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qba), "bytearray(b'\\x13*\\x00\\x08')")
else:
self.assertEqual(repr(qba), "b'\\x13*\\x00\\x08'")
qba = pya.A.ia_cref_to_qba_ptr([ 20, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qba), "bytearray(b'\\x14*\\x00\\x08')")
else:
self.assertEqual(repr(qba), "b'\\x14*\\x00\\x08'")
self.assertEqual(pya.A.qba_to_ia(b'\x00\x01\x02'), [ 0, 1, 2 ])
def test_QByteArrayView(self):
# QByteArrayView
if "ia_cref_to_qbav" in pya.A.__dict__:
qbav = pya.A.ia_cref_to_qbav([ 16, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qbav), "bytearray(b'\\x10*\\x00\\x08')")
else:
self.assertEqual(repr(qbav), "b'\\x10*\\x00\\x08'")
self.assertEqual(pya.A.qbav_to_ia(qbav), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qbav_cref_to_ia(qbav), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qbav_cptr_to_ia(qbav), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qbav_ref_to_ia(qbav), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qbav_ptr_to_ia(qbav), [ 16, 42, 0, 8 ])
qbav = pya.A.ia_cref_to_qbav_cref([ 17, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qbav), "bytearray(b'\\x11*\\x00\\x08')")
else:
self.assertEqual(repr(qbav), "b'\\x11*\\x00\\x08'")
qbav = pya.A.ia_cref_to_qbav_ref([ 18, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qbav), "bytearray(b'\\x12*\\x00\\x08')")
else:
self.assertEqual(repr(qbav), "b'\\x12*\\x00\\x08'")
qbav = pya.A.ia_cref_to_qbav_cptr([ 19, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qbav), "bytearray(b'\\x13*\\x00\\x08')")
else:
self.assertEqual(repr(qbav), "b'\\x13*\\x00\\x08'")
qbav = pya.A.ia_cref_to_qbav_ptr([ 20, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(qbav), "bytearray(b'\\x14*\\x00\\x08')")
else:
self.assertEqual(repr(qbav), "b'\\x14*\\x00\\x08'")
self.assertEqual(pya.A.qbav_to_ia(b'\x00\x01\x02'), [ 0, 1, 2 ])
def test_QString(self):
# QString
if "ia_cref_to_qs" in pya.A.__dict__:
qs = pya.A.ia_cref_to_qs([ 16, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(qs), "'\\x10*\\x00\\x08\u03a9'")
# full cycle must preserve encoding, also for var
self.assertEqual(repr(pya.A.ft_qs(qs)), "'\\x10*\\x00\\x08\u03a9'")
self.assertEqual(repr(pya.A.ft_var(qs)), "'\\x10*\\x00\\x08\u03a9'")
self.assertEqual(pya.A.qs_to_ia(qs), [ 16, 42, 0, 8, 0x03a9 ])
self.assertEqual(pya.A.qs_cref_to_ia(qs), [ 16, 42, 0, 8, 0x03a9 ])
self.assertEqual(pya.A.qs_cptr_to_ia(qs), [ 16, 42, 0, 8, 0x03a9 ])
self.assertEqual(pya.A.qs_ref_to_ia(qs), [ 16, 42, 0, 8, 0x03a9 ])
self.assertEqual(pya.A.qs_ptr_to_ia(qs), [ 16, 42, 0, 8, 0x03a9 ])
qs = pya.A.ia_cref_to_qs_cref([ 17, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(qs), "'\\x11*\\x00\\x08\u03a9'")
qs = pya.A.ia_cref_to_qs_ref([ 18, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(qs), "'\\x12*\\x00\\x08\u03a9'")
qs = pya.A.ia_cref_to_qs_cptr([ 19, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(qs), "'\\x13*\\x00\\x08\u03a9'")
qs = pya.A.ia_cref_to_qs_ptr([ 20, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(qs), "'\\x14*\\x00\\x08\u03a9'")
self.assertEqual(pya.A.qs_to_ia('\x00\x01\x02'), [ 0, 1, 2 ])
def test_QStringView(self):
# QStringView
if "ia_cref_to_qsv" in pya.A.__dict__:
qsv = pya.A.ia_cref_to_qsv([ 16, 42, 0, 8 ])
self.assertEqual(repr(qsv), "'\\x10*\\x00\\x08'")
self.assertEqual(pya.A.qsv_to_ia(qsv), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qsv_cref_to_ia(qsv), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qsv_cptr_to_ia(qsv), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qsv_ref_to_ia(qsv), [ 16, 42, 0, 8 ])
self.assertEqual(pya.A.qsv_ptr_to_ia(qsv), [ 16, 42, 0, 8 ])
qsv = pya.A.ia_cref_to_qsv_cref([ 17, 42, 0, 8 ])
self.assertEqual(repr(qsv), "'\\x11*\\x00\\x08'")
qsv = pya.A.ia_cref_to_qsv_ref([ 18, 42, 0, 8 ])
self.assertEqual(repr(qsv), "'\\x12*\\x00\\x08'")
qsv = pya.A.ia_cref_to_qsv_cptr([ 19, 42, 0, 8 ])
self.assertEqual(repr(qsv), "'\\x13*\\x00\\x08'")
qsv = pya.A.ia_cref_to_qsv_ptr([ 20, 42, 0, 8 ])
self.assertEqual(repr(qsv), "'\\x14*\\x00\\x08'")
self.assertEqual(pya.A.qsv_to_ia('\x00\x01\x02'), [ 0, 1, 2 ])
def test_QLatin1String(self):
# QLatin1String
if "ia_cref_to_ql1s" in pya.A.__dict__:
ql1s = pya.A.ia_cref_to_ql1s([ 16, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(ql1s), "'\\x10*\\x00\\x08\u00a9'")
self.assertEqual(pya.A.ql1s_to_ia(ql1s), [ 16, 42, 0, 8, 0xa9 ])
self.assertEqual(pya.A.ql1s_cref_to_ia(ql1s), [ 16, 42, 0, 8, 0xa9 ])
self.assertEqual(pya.A.ql1s_cptr_to_ia(ql1s), [ 16, 42, 0, 8, 0xa9 ])
self.assertEqual(pya.A.ql1s_ref_to_ia(ql1s), [ 16, 42, 0, 8, 0xa9 ])
self.assertEqual(pya.A.ql1s_ptr_to_ia(ql1s), [ 16, 42, 0, 8, 0xa9 ])
ql1s = pya.A.ia_cref_to_ql1s_cref([ 17, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(ql1s), "'\\x11*\\x00\\x08\u00a9'")
ql1s = pya.A.ia_cref_to_ql1s_ref([ 18, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(ql1s), "'\\x12*\\x00\\x08\u00a9'")
ql1s = pya.A.ia_cref_to_ql1s_cptr([ 19, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(ql1s), "'\\x13*\\x00\\x08\u00a9'")
ql1s = pya.A.ia_cref_to_ql1s_ptr([ 20, 42, 0, 8, 0x03a9 ])
self.assertEqual(repr(ql1s), "'\\x14*\\x00\\x08\u00a9'")
self.assertEqual(pya.A.ql1s_to_ia('\x00\x01\x02'), [ 0, 1, 2 ])
def test_utf8Strings(self):
# UTF8 strings (non-Qt)
s = "\u0010*\u0000\b\u03a9"
self.assertEqual(repr(s), "'\\x10*\\x00\\x08\u03a9'")
# full cycle must preserve encoding, also for var
self.assertEqual(repr(pya.A.ft_str(s)), "'\\x10*\\x00\\x08\u03a9'")
self.assertEqual(repr(pya.A.ft_var(s)), "'\\x10*\\x00\\x08\u03a9'")
# NUL character terminates in const char * mode:
self.assertEqual(repr(pya.A.ft_cptr(s)), "'\\x10*'")
def test_binaryStrings(self):
# binary strings (non-Qt)
ba = pya.A.ia_cref_to_ba([ 17, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(ba), "bytearray(b'\\x11*\\x00\\x08')")
self.assertEqual(repr(pya.A.ft_cv(ba)), "bytearray(b'\\x11*\\x00\\x08')")
self.assertEqual(repr(pya.A.ft_var(ba)), "bytearray(b'\\x11*\\x00\\x08')")
else:
self.assertEqual(repr(ba), "b'\\x11*\\x00\\x08'")
self.assertEqual(repr(pya.A.ft_cv(ba)), "b'\\x11*\\x00\\x08'")
self.assertEqual(repr(pya.A.ft_var(ba)), "b'\\x11*\\x00\\x08'")
self.assertEqual(pya.A.ba_to_ia(ba), [ 17, 42, 0, 8 ])
self.assertEqual(pya.A.ba_cref_to_ia(ba), [ 17, 42, 0, 8 ])
self.assertEqual(pya.A.ba_cptr_to_ia(ba), [ 17, 42, 0, 8 ])
self.assertEqual(pya.A.ba_ref_to_ia(ba), [ 17, 42, 0, 8 ])
self.assertEqual(pya.A.ba_ptr_to_ia(ba), [ 17, 42, 0, 8 ])
ba = pya.A.ia_cref_to_ba_cref([ 17, 42, 0, 8 ])
if sys.version_info < (3, 0):
self.assertEqual(repr(ba), "bytearray(b'\\x11*\\x00\\x08')")
else:
self.assertEqual(repr(ba), "b'\\x11*\\x00\\x08'")
self.assertEqual(pya.A.ba_to_ia(b'\x00\x01\x02'), [ 0, 1, 2 ])
def test_variant_formation(self):
self.assertEqual(pya.A.var2s(1.5), "##1.5")
self.assertEqual(pya.A.var2s(-17), "#-17")
self.assertEqual(pya.A.var2s("abc"), "'abc'")
self.assertEqual(pya.A.var2s(None), "nil")
self.assertEqual(pya.A.var2s(True), "true")
self.assertEqual(pya.A.var2s(False), "false")
self.assertEqual(pya.A.var2s(pya.DBox(0, 0, 10, 20)), "[dbox:(0,0;10,20)]")
self.assertEqual(pya.A.var2s([ 0.5, "hello" ]), "(##0.5,'hello')")
self.assertEqual(pya.A.var2s(( 0.5, "hello" )), "(##0.5,'hello')")
self.assertEqual(pya.A.var2s([ 0.5, [ 1, 2 ] ]), "(##0.5,(#1,#2))")
self.assertEqual(pya.A.var2s({ 1: 'one', 'two': 17 }), "{#1=>'one','two'=>#17}")
if pya.A.ll_size() == 4:
self.assertEqual(pya.A.var2s(100000000000), "#l100000000000")
else:
self.assertEqual(pya.A.var2s(100000000000), "#100000000000")
# Tests multi-base mixins (only constants and enums available)
def test_multiBaseMixins(self):
bb = pya.BB() # base classes B1,B2,B3
bb.set1(17) # B1
self.assertEqual(bb.get1(), 17) # B1
bb.set1(21) # B1
self.assertEqual(bb.get1(), 21) # B1
self.assertEqual(pya.BB.C2, 17) # B2
self.assertEqual(pya.BB.C3, -1) # B3
self.assertEqual(pya.BB.E.E3B.to_i(), 101) # B3
self.assertEqual(bb.d3(pya.BB.E.E3C, pya.BB.E.E3A), -2) # BB with B3 enums
self.assertEqual(bb.d3(pya.BB.E.E3A, pya.BB.E.E3C), 2) # BB with B3 enums
# 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)
# fallback to __rmul__ for not implemented __mul__
def test_90(self):
# skip this test for Python 2
if sys.version_info < (3, 0):
return
class RMulObject:
def __init__(self, factor):
self.factor = factor
def __rmul__(self, point):
return point * self.factor
def __radd__(self, point):
return point + pya.Vector(1,1) * self.factor
p = pya.Point(1, 0)
fac2 = RMulObject(2)
self.assertEqual(p * 2, p * fac2) # p.__mul__(fac2) should return NotImplemented, which will call fac2.__rmul__(p)
self.assertEqual(pya.Point(3,2), p + fac2)
# copy and deepcopy
def test_91(self):
p = pya.Point(1, 0)
pc = copy.copy(p)
pdc = copy.deepcopy(p)
pdc.x = 4
pc.x = 3
p.x = 2
self.assertEqual(p.x, 2)
self.assertEqual(pc.x, 3)
self.assertEqual(pdc.x, 4)
# keyword arguments, enums and error messages
def test_92(self):
bb = pya.BB()
m = ""
try:
bb.d4()
except Exception as ex:
m = str(ex)
self.assertEqual(m, "Can't match arguments. Variants are:\n string d4(int a, string b, double c, B3::E d = E3A, variant e = nil) [no value given for argument #1 and following]\n in BB.d4")
m = ""
try:
bb.d4(1, "a")
except Exception as ex:
m = str(ex)
self.assertEqual(m, "Can't match arguments. Variants are:\n string d4(int a, string b, double c, B3::E d = E3A, variant e = nil) [no value given for argument #3]\n in BB.d4")
m = ""
try:
bb.d4(1, "a", 2.0, xxx=17)
except Exception as ex:
m = str(ex)
self.assertEqual(m, "Can't match arguments. Variants are:\n string d4(int a, string b, double c, B3::E d = E3A, variant e = nil) [unknown keyword parameter: xxx]\n in BB.d4")
m = ""
try:
bb.d4(a=1, b="a", c=2.0, xxx=17)
except Exception as ex:
m = str(ex)
self.assertEqual(m, "Can't match arguments. Variants are:\n string d4(int a, string b, double c, B3::E d = E3A, variant e = nil) [unknown keyword parameter: xxx]\n in BB.d4")
self.assertEqual(bb.d4(1, "a", 2.0), "1,a,2,100,nil")
self.assertEqual(bb.d4(1, "a", 2.0, e=42), "1,a,2,100,42")
self.assertEqual(bb.d4(1, "a", c=2.0, e=42), "1,a,2,100,42")
self.assertEqual(bb.d4(c=2.0, a=1, b="a", e=42), "1,a,2,100,42")
self.assertEqual(bb.d4(1, "a", 2.0, d=pya.BB.E.E3B), "1,a,2,101,nil")
self.assertEqual(bb.d4(1, "a", d=pya.BB.E.E3B, c=2.5), "1,a,2.5,101,nil")
self.assertEqual(bb.d4(1, "a", 2.0, pya.BB.E.E3B, 42), "1,a,2,101,42")
# constness
def test_93(self):
b = pya.B()
self.assertEqual(b.is_const_object(), False)
bc = b._to_const_object()
self.assertEqual(bc.is_const_object(), True)
m = ""
try:
bc.set_str("abc")
self.assertEqual(1, 0)
except Exception as ex:
m = str(ex)
self.assertEqual(m, "Cannot call non-const method on a const reference in B.set_str")
b = pya.B()
bc = b
self.assertEqual(b._is_const_object(), False)
self.assertEqual(bc._is_const_object(), False)
bc = bc._to_const_object()
b.set_str("abc")
self.assertEqual(b._is_const_object(), False)
self.assertEqual(bc._is_const_object(), True)
self.assertEqual(b.str(), "abc")
self.assertEqual(bc.str(), "abc")
bnc = bc._const_cast()
self.assertEqual(b._is_const_object(), False)
self.assertEqual(bc._is_const_object(), True)
self.assertEqual(bnc._is_const_object(), False)
bnc.set_str("xyz")
self.assertEqual(b.str(), "xyz")
self.assertEqual(bc.str(), "xyz")
self.assertEqual(bnc.str(), "xyz")
# weak refs
def test_94(self):
b = pya.B()
b.set_str("abc")
r = weakref.ref(b)
self.assertEqual(r() is None, False)
self.assertEqual(r().str(), "abc")
b = None
self.assertEqual(r() is None, True)
# 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)
Reference in New Issue View Git Blame Copy Permalink