From a95706baaad680913bebf138024c56c609e83748 Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sat, 25 Nov 2023 21:42:50 +0100 Subject: [PATCH] Tests for implict construction from tuple or list arguments --- src/gsi/gsi_test/gsiTest.cc | 123 +++++++++++++-------- src/gsi/gsi_test/gsiTest.h | 143 +++++++++++++++--------- testdata/python/basic.py | 215 ++++++++++++++++++++++++------------ 3 files changed, 317 insertions(+), 164 deletions(-) diff --git a/src/gsi/gsi_test/gsiTest.cc b/src/gsi/gsi_test/gsiTest.cc index be3b3921f..370f055f2 100644 --- a/src/gsi/gsi_test/gsiTest.cc +++ b/src/gsi/gsi_test/gsiTest.cc @@ -65,6 +65,20 @@ A::A (int nn) { f = false; } +A::A (int n1, int n2) { + ++a_count; + e = Enum (0); + n = n1 + n2; + f = false; +} + +A::A (int n1, int n2, double n3) { + ++a_count; + e = Enum (0); + n = (n1 + n2) * n3; + f = false; +} + A::A (const A &a) : gsi::ObjectBase (a) { @@ -339,7 +353,17 @@ static A *a_ctor (int i) return new A (i); } -void A::a20 (A *ptr) +static A *a_ctor2 (int i, int j) +{ + return new A (i, j); +} + +static A *a_ctor3 (int i, int j, double f) +{ + return new A (i, j, f); +} + +void A::a20 (A *ptr) { if (a_inst.get () != ptr) { a_inst.reset (ptr); @@ -360,26 +384,26 @@ static int b_count = 0; B::B () { ++b_count; - av.push_back (A (100)); - av.push_back (A (121)); - av.push_back (A (144)); - avc_nc.push_back (new A_NC (-3100)); - avc_nc.push_back (new A_NC (-3121)); - av_nc.push_back (new A_NC (7100)); - av_nc.push_back (new A_NC (7121)); - av_nc.push_back (new A_NC (7144)); - av_nc.push_back (new A_NC (7169)); + m_av.push_back (A (100)); + m_av.push_back (A (121)); + m_av.push_back (A (144)); + m_avc_nc.push_back (new A_NC (-3100)); + m_avc_nc.push_back (new A_NC (-3121)); + m_av_nc.push_back (new A_NC (7100)); + m_av_nc.push_back (new A_NC (7121)); + m_av_nc.push_back (new A_NC (7144)); + m_av_nc.push_back (new A_NC (7169)); } B::~B () { - while (! av_nc.empty ()) { - delete av_nc.back (); - av_nc.pop_back (); + while (! m_av_nc.empty ()) { + delete m_av_nc.back (); + m_av_nc.pop_back (); } - while (! avc_nc.empty ()) { - delete const_cast (avc_nc.back ()); - avc_nc.pop_back (); + while (! m_avc_nc.empty ()) { + delete const_cast (m_avc_nc.back ()); + m_avc_nc.pop_back (); } if (b_inst == this) { b_inst = 0; @@ -405,22 +429,22 @@ B &B::operator=(const B &d) } m = d.m; - a = d.a; - bv = d.bv; - av = d.av; - while (! av_nc.empty ()) { - delete av_nc.back (); - av_nc.pop_back (); + m_a = d.m_a; + m_bv = d.m_bv; + m_av = d.m_av; + while (! m_av_nc.empty ()) { + delete m_av_nc.back (); + m_av_nc.pop_back (); } - for (std::vector ::const_iterator i = d.av_nc.begin (); i != d.av_nc.end (); ++i) { - av_nc.push_back (new A_NC (**i)); + for (std::vector ::const_iterator i = d.m_av_nc.begin (); i != d.m_av_nc.end (); ++i) { + m_av_nc.push_back (new A_NC (**i)); } - while (! avc_nc.empty ()) { - delete const_cast (avc_nc.back ()); - avc_nc.pop_back (); + while (! m_avc_nc.empty ()) { + delete const_cast (m_avc_nc.back ()); + m_avc_nc.pop_back (); } - for (std::vector ::const_iterator i = d.avc_nc.begin (); i != d.avc_nc.end (); ++i) { - avc_nc.push_back (new A_NC (**i)); + for (std::vector ::const_iterator i = d.m_avc_nc.begin (); i != d.m_avc_nc.end (); ++i) { + m_avc_nc.push_back (new A_NC (**i)); } m_var = d.m_var; m_vars = d.m_vars; @@ -461,7 +485,7 @@ std::string B::addr () const return c; } -static int b3_ext (const B *b, A *aptr) +static int aptr_to_n_ext (const B *b, A *aptr) { return b->b3 (aptr); } @@ -1030,6 +1054,8 @@ static gsi::QFlagsClass decl_qflags_enum ("", "Enums"); static gsi::Class decl_a ("", "A", gsi::constructor ("new_a|new", &a_ctor) + + gsi::constructor ("new", &a_ctor2) + + gsi::constructor ("new", &a_ctor3) + gsi::method ("instance_count", &A::instance_count) + gsi::method ("new_a_by_variant", &A::new_a_by_variant) + @@ -1146,8 +1172,8 @@ static gsi::Class decl_a ("", "A", gsi::method ("af?|af", &A::af1) + gsi::method ("aa", &A::a) + gsi::method ("aa", &A::a_static) + - gsi::method ("a1", &A::a1) + - gsi::method ("a1c", &A::a1c) + + gsi::method ("a1|get_n", &A::a1) + + gsi::method ("a1c|get_n_const", &A::a1c) + gsi::method ("a2", &A::a2) + gsi::method ("a3", &A::a3) + #if defined(HAVE_QT) @@ -1262,8 +1288,8 @@ static gsi::Class decl_b ("", "B", gsi::method ("set_str", &B::set_str) + gsi::method ("str_ccptr", &B::str_ccptr) + gsi::method ("set_str_combine", &B::set_str_combine) + - gsi::method_ext ("b3|aptr_to_n", &b3_ext) + - gsi::method ("b4|aref_to_s", &B::b4) + + gsi::method_ext ("b3|aptr_to_n", &aptr_to_n_ext) + + gsi::method ("b4|aref_to_s", &B::aref_to_s) + gsi::method ("make_a", &B::make_a) + gsi::method ("set_an", &B::set_an) + gsi::method ("an", &B::an) + @@ -1280,18 +1306,23 @@ static gsi::Class decl_b ("", "B", gsi::method ("xxx|amember_cptr", &B::amember_cptr) + gsi::method ("yyy|amember_cref", &B::amember_cref) + gsi::method ("zzz|amember_ref", &B::amember_ref) + - gsi::method ("b15|arg_is_not_nil", &B::b15) + - gsi::method ("b16a|av", &B::b16a) + - gsi::method ("b16b|av_cref", &B::b16b) + - gsi::method ("b16c|av_ref", &B::b16c) + - gsi::method ("b17a|av_cref=", &B::b17a) + - gsi::method ("b17b|av_ref=", &B::b17b) + - gsi::method ("b17c|av=", &B::b17c) + - gsi::method ("b17d|av_cptr=", &B::b17d) + - gsi::method ("b17e|av_ptr=", &B::b17e) + - gsi::iterator ("b18", &B::b18) + - gsi::iterator ("b18b", &B::b18b) + - gsi::iterator ("b18c", &B::b18b) + + gsi::method ("b15|arg_is_not_nil", &B::arg_is_not_nil) + + gsi::method ("b16a|av", &B::av) + + gsi::method ("b16b|av_cref", &B::av_cref) + + gsi::method ("b16c|av_ref", &B::av_ref) + + gsi::method ("push_a", &B::push_a) + + gsi::method ("push_a_cref", &B::push_a_cref) + + gsi::method ("push_a_cptr", &B::push_a_cptr) + + gsi::method ("push_a_ref", &B::push_a_ref) + + gsi::method ("push_a_ptr", &B::push_a_ptr) + + gsi::method ("b17a|av_cref=", &B::set_av_cref) + + gsi::method ("b17b|av_ref=", &B::set_av_ref) + + gsi::method ("b17c|av=", &B::set_av) + + gsi::method ("b17d|av_cptr=", &B::set_av_cptr) + + gsi::method ("b17e|av_ptr=", &B::set_av_ptr) + + gsi::iterator ("b18|each_a", &B::b18) + + gsi::iterator ("b18b|each_a_ref", &B::b18b) + + gsi::iterator ("b18c|each_a_ptr", &B::b18c) + gsi::method ("b20a|var_is_nil", &B::b20a) + gsi::method ("b20b|var_is_double", &B::b20b) + gsi::method ("b20c|var_is_long", &B::b20c) + diff --git a/src/gsi/gsi_test/gsiTest.h b/src/gsi/gsi_test/gsiTest.h index 204d4ae82..fe7f47b54 100644 --- a/src/gsi/gsi_test/gsiTest.h +++ b/src/gsi/gsi_test/gsiTest.h @@ -73,7 +73,17 @@ struct A */ A (int nn); - /** + /** + * @brief Parametrized constructor 2 + */ + A (int n1, int n2); + + /** + * @brief Parametrized constructor 3 + */ + A (int n1, int n2, double n3); + + /** * @brief Copy constructor */ A (const A &a); @@ -640,7 +650,7 @@ struct B return aptr->n; } - std::string b4 (const A &aref) { + std::string aref_to_s (const A &aref) { return tl::sprintf ("b4_result: %d", aref.n); } @@ -650,7 +660,7 @@ struct B void set_an (int n) { - a.n = n; + m_a.n = n; } int an (A a) @@ -660,7 +670,7 @@ struct B void set_an_cref (const int &n) { - a.n = n; + m_a.n = n; } const int &an_cref (const A &a) @@ -670,122 +680,155 @@ struct B std::vector ::const_iterator b10b () const { - return av.begin (); + return m_av.begin (); } std::vector ::const_iterator b10e () const { - return av.end (); + return m_av.end (); } std::vector ::iterator b10b_nc () { - return av.begin (); + return m_av.begin (); } std::vector ::iterator b10e_nc () { - return av.end (); + return m_av.end (); } ValueIter::const_iterator> b11b () const { - return ValueIter::const_iterator> (av.begin ()); + return ValueIter::const_iterator> (m_av.begin ()); } ValueIter::const_iterator> b11e () const { - return ValueIter::const_iterator> (av.end ()); + return ValueIter::const_iterator> (m_av.end ()); } std::vector ::const_iterator b12b () const { - return av_nc.begin (); + return m_av_nc.begin (); } std::vector ::const_iterator b12e () const { - return av_nc.end (); + return m_av_nc.end (); } std::vector ::const_iterator b13b () const { - return avc_nc.begin (); + return m_avc_nc.begin (); } std::vector ::const_iterator b13e () const { - return avc_nc.end (); + return m_avc_nc.end (); } - A *amember_or_nil (bool nn) { return nn ? &a : 0; } - A *amember_ptr () { return &a; } - A &amember_ref () { return a; } - const A *amember_cptr () const { return &a; } - const A &amember_cref () const { return a; } + A *amember_or_nil (bool nn) { return nn ? &m_a : 0; } + A *amember_ptr () { return &m_a; } + A &amember_ref () { return m_a; } + const A *amember_cptr () const { return &m_a; } + const A &amember_cref () const { return m_a; } - bool b15 (A *a) + bool arg_is_not_nil (A *a) { return a != 0; } - std::vector b16a () const + std::vector av () const { - return av; + return m_av; } - const std::vector &b16b () const + const std::vector &av_cref () const { - return av; + return m_av; } - std::vector &b16c () + std::vector &av_ref () { - return av; + return m_av; } - void b17a (const std::vector &v) + void set_av_cref (const std::vector &v) { - av = v; + m_av = v; } - void b17b (std::vector &v) + void set_av_ref (std::vector &v) { - av = v; + m_av = v; } - void b17c (std::vector v) + void set_av (std::vector v) { - av = v; + m_av = v; } - void b17d (const std::vector *v) + void set_av_cptr (const std::vector *v) { if (v) { - av = *v; + m_av = *v; + } else { + m_av.clear (); } } - void b17e (std::vector *v) + void set_av_ptr (std::vector *v) { if (v) { - av = *v; + m_av = *v; + } else { + m_av.clear (); + } + } + + void push_a (A a) + { + m_av.push_back (a); + } + + void push_a_cref (const A &a) + { + m_av.push_back (a); + } + + void push_a_ref (A &a) + { + m_av.push_back (a); + } + + void push_a_cptr (const A *a) + { + if (a) { + m_av.push_back (*a); + } + } + + void push_a_ptr (A *a) + { + if (a) { + m_av.push_back (*a); } } FreeIter::const_iterator> b18 () const { - return FreeIter::const_iterator> (av.begin (), av.end ()); + return FreeIter::const_iterator> (m_av.begin (), m_av.end ()); } FreeIterUseRef::const_iterator> b18b () const { - return FreeIterUseRef::const_iterator> (av.begin (), av.end ()); + return FreeIterUseRef::const_iterator> (m_av.begin (), m_av.end ()); } FreeIterUsePtr::const_iterator> b18c () const { - return FreeIterUsePtr::const_iterator> (av.begin (), av.end ()); + return FreeIterUsePtr::const_iterator> (m_av.begin (), m_av.end ()); } bool b20a (const tl::Variant &var) const { return var.is_nil (); } @@ -862,30 +905,30 @@ struct B FreeIter::const_iterator> each_b_copy () const { - return FreeIter::const_iterator> (bv.begin (), bv.end ()); + return FreeIter::const_iterator> (m_bv.begin (), m_bv.end ()); } FreeIterUseRef::const_iterator> each_b_cref () const { - return FreeIterUseRef::const_iterator> (bv.begin (), bv.end ()); + return FreeIterUseRef::const_iterator> (m_bv.begin (), m_bv.end ()); } FreeIterUsePtr::const_iterator> each_b_cptr () const { - return FreeIterUsePtr::const_iterator> (bv.begin (), bv.end ()); + return FreeIterUsePtr::const_iterator> (m_bv.begin (), m_bv.end ()); } FreeIterUseRef::iterator> each_b_ref () { - return FreeIterUseRef::iterator> (bv.begin (), bv.end ()); + return FreeIterUseRef::iterator> (m_bv.begin (), m_bv.end ()); } FreeIterUsePtr::iterator> each_b_ptr () { - return FreeIterUsePtr::iterator> (bv.begin (), bv.end ()); + return FreeIterUsePtr::iterator> (m_bv.begin (), m_bv.end ()); } - void push_b (const B &b) { bv.push_back (b); } + void push_b (const B &b) { m_bv.push_back (b); } std::map map_iaptr () { return m_map_iaptr; } const std::map &map_iaptr_cref () { return m_map_iaptr; } @@ -996,11 +1039,11 @@ struct B #endif std::string m; - A a; - std::vector bv; - std::vector av; - std::vector av_nc; - std::vector avc_nc; + A m_a; + std::vector m_bv; + std::vector m_av; + std::vector m_av_nc; + std::vector m_avc_nc; tl::Variant m_var; std::vector m_vars; std::map m_map1; diff --git a/testdata/python/basic.py b/testdata/python/basic.py index 3c64efbb7..66e1e730b 100644 --- a/testdata/python/basic.py +++ b/testdata/python/basic.py @@ -35,7 +35,7 @@ class AEXT(pya.A): def g(self): return self.offset def m(self): - return self.offset+self.a1() + 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) @@ -43,7 +43,7 @@ class AEXT(pya.A): return str(self.offset) def repr_of_a(self): - return "a1=" + str(self.a1()) + return "a1=" + str(self.get_n()) pya.A.__repr__ = repr_of_a @@ -150,9 +150,9 @@ class BasicTest(unittest.TestCase): self.assertEqual( pya.A.instance_count(), ic0 + 1 ) a = pya.A() - self.assertEqual(a.a1(), 17) + self.assertEqual(a.get_n(), 17) a.assign(pya.A(110)) - self.assertEqual(a.a1(), 110) + self.assertEqual(a.get_n(), 110) a = None self.assertEqual( pya.A.instance_count(), ic0 ) @@ -182,13 +182,13 @@ class BasicTest(unittest.TestCase): self.assertEqual( pya.A.aa(), "static_a" ) self.assertEqual( a.aa(), "a" ) - self.assertEqual( a.a1(), 17 ) + self.assertEqual( a.get_n(), 17 ) a.a5(-5) - self.assertEqual( a.a1(), -5 ) + self.assertEqual( a.get_n(), -5 ) a.a5(0x7fffffff) - self.assertEqual( a.a1(), 0x7fffffff ) + self.assertEqual( a.get_n(), 0x7fffffff ) a.a5(-0x80000000) - self.assertEqual( a.a1(), -0x80000000 ) + self.assertEqual( a.get_n(), -0x80000000 ) self.assertEqual( a.a3("a"), 1 ) self.assertEqual( a.a3("ab"), 2 ) @@ -249,7 +249,7 @@ class BasicTest(unittest.TestCase): self.assertEqual( pya.A.instance_count(), ic0 ) a = pya.A.new_a( 55 ) self.assertEqual( pya.A.instance_count(), ic0 + 1 ) - self.assertEqual( a.a1(), 55 ) + self.assertEqual( a.get_n(), 55 ) self.assertEqual( a.a_vp1( a.a_vp2() ), "abc" ) a.destroy() self.assertEqual( pya.A.instance_count(), ic0 ) @@ -403,9 +403,9 @@ class BasicTest(unittest.TestCase): a = pya.A.new_a_by_variant() self.assertEqual(pya.A.instance_count(), ic0 + 1) - self.assertEqual(a.a1(), 17) + self.assertEqual(a.get_n(), 17) a.a5(-15) - self.assertEqual(a.a1(), -15) + self.assertEqual(a.get_n(), -15) a = None self.assertEqual(pya.A.instance_count(), ic0) @@ -422,6 +422,85 @@ class BasicTest(unittest.TestCase): 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() @@ -429,16 +508,16 @@ class BasicTest(unittest.TestCase): a2 = a1 a3 = a2.dup() - self.assertEqual( a1.a1(), -15 ) - self.assertEqual( a2.a1(), -15 ) - self.assertEqual( a3.a1(), -15 ) + 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.a1(), 11 ) - self.assertEqual( a2.a1(), 11 ) - self.assertEqual( a3.a1(), -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" ) @@ -651,7 +730,7 @@ class BasicTest(unittest.TestCase): err_caught = False try: - b.amember_cptr().a1() # cannot call non-const method on const reference + b.amember_cptr().get_n() # cannot call non-const method on const reference except: err_caught = True self.assertEqual( err_caught, True ) @@ -675,7 +754,7 @@ class BasicTest(unittest.TestCase): try: for a in b.b10(): - arr.append(a.a1()) # b10 is a const iterator - cannot call a1 on it + arr.append(a.get_n()) # b10 is a const iterator - cannot call a1 on it except: err_caught = True self.assertEqual( err_caught, True ) @@ -687,7 +766,7 @@ class BasicTest(unittest.TestCase): try: for a in b.b10p(): - arr.append(a.a1()) # b10p is a const iterator - cannot call a1 on it + arr.append(a.get_n()) # b10p is a const iterator - cannot call a1 on it except: err_caught = True self.assertEqual( err_caught, True ) @@ -695,7 +774,7 @@ class BasicTest(unittest.TestCase): arr = [] for a in b.b10(): - arr.append(a.dup().a1()) + arr.append(a.dup().get_n()) self.assertEqual(arr, [100, 121, 144]) arr = [] @@ -706,99 +785,99 @@ class BasicTest(unittest.TestCase): # destroyed too early. bdup = b.dup() for a in bdup.b10(): - arr.append(a.dup().a1()) + arr.append(a.dup().get_n()) self.assertEqual(arr, [100, 121, 144]) return arr = [] for a in b.b10(): - arr.append(a.a1c()) + arr.append(a.get_n_const()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b10p(): - arr.append(a.dup().a1()) + 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().a1()) + 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().a1()) + arr.append(a.dup().get_n()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b10p(): - arr.append(a.a1c()) + arr.append(a.get_n_const()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b11(): - arr.append(a.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [100, 121, 144]) arr = [] bdup = b.dup() for a in bdup.b11(): - arr.append(a.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [100, 121, 144]) arr = [] for a in b.b12(): - arr.append(a.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [7100, 7121, 7144, 7169]) arr = [] bdup = b.dup() for a in bdup.b12(): - arr.append(a.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [7100, 7121, 7144, 7169]) aarr = b.b16a() arr = [] for a in aarr: - arr.append(a.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [100, 121, 144]) aarr = b.b16b() arr = [] for a in aarr: - arr.append(a.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [100, 121, 144]) aarr = b.b16c() arr = [] for a in aarr: - arr.append(a.a1()) + 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.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [101, -122]) b.b17a( [] ) arr = [] for a in b.b11(): - arr.append(a.a1()) + 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.a1()) + 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.a1()) + arr.append(a.get_n()) self.assertEqual(arr, [100, 121, 144]) if not leak_check: @@ -806,7 +885,7 @@ class BasicTest(unittest.TestCase): arr = [] try: for a in b.b13(): - arr.append(a.a1()) + arr.append(a.get_n()) except: err_caught = True self.assertEqual( err_caught, True ) @@ -814,28 +893,28 @@ class BasicTest(unittest.TestCase): arr = [] for a in b.b13(): - arr.append(a.a1c()) + arr.append(a.get_n_const()) self.assertEqual(arr, [-3100, -3121]) arr = [] bdup = b.dup() for a in bdup.b13(): - arr.append(a.a1c()) + arr.append(a.get_n_const()) self.assertEqual(arr, [-3100, -3121]) arr = [] - for a in b.b18(): - arr.append(a.a1c()) + for a in b.each_a(): + arr.append(a.get_n_const()) self.assertEqual(arr, [100, 121, 144]) arr = [] - for a in b.b18(): - arr.append(a.a1()) + for a in b.each_a(): + arr.append(a.get_n()) self.assertEqual(arr, [100, 121, 144]) arr = [] - for a in b.b18b(): - arr.append(a.a1c()) + for a in b.each_a_ref(): + arr.append(a.get_n_const()) self.assertEqual(arr, [100, 121, 144]) arr = [] @@ -843,8 +922,8 @@ class BasicTest(unittest.TestCase): # 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()) + for a in b.each_a_ref(): + arr.append(a.get_n()) except: err_caught = True end @@ -852,17 +931,17 @@ class BasicTest(unittest.TestCase): self.assertEqual(err_caught, True) arr = [] - for a in b.b18c(): - arr.append(a.a1c()) + 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 b18c delivers a "const *" which cannot be used to call a non-const + # 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.b18c(): - arr.append(a.a1()) + for a in b.each_a_ptr(): + arr.append(a.get_n()) except: err_caught = True end @@ -1035,23 +1114,23 @@ class BasicTest(unittest.TestCase): a_count = pya.A.instance_count() a = b.make_a( 1971 ); self.assertEqual( pya.A.instance_count(), a_count + 1 ) - self.assertEqual( a.a1(), 1971 ); + 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.a1(), 1971 ); + self.assertEqual( a.get_n(), 1971 ); self.assertEqual( b.an( a ), 1971 ); - self.assertEqual( aa.a1(), -61 ); + self.assertEqual( aa.get_n(), -61 ); self.assertEqual( b.an( aa ), -61 ); aa.a5(98); a.a5(100); - self.assertEqual( a.a1(), 100 ); + self.assertEqual( a.get_n(), 100 ); self.assertEqual( b.an( a ), 100 ); - self.assertEqual( aa.a1(), 98 ); + self.assertEqual( aa.get_n(), 98 ); self.assertEqual( b.an( aa ), 98 ); a._destroy() @@ -1064,10 +1143,10 @@ class BasicTest(unittest.TestCase): b = pya.B() b.set_an( 77 ) - self.assertEqual( b.amember_cptr().a1c(), 77 ); + self.assertEqual( b.amember_cptr().get_n_const(), 77 ); b.set_an_cref( 79 ) - self.assertEqual( b.amember_cptr().a1c(), 79 ); + self.assertEqual( b.amember_cptr().get_n_const(), 79 ); aref = b.amember_cptr() err_caught = False @@ -1075,14 +1154,14 @@ class BasicTest(unittest.TestCase): if not leak_check: try: - x = aref.a1() # cannot call non-const method on const reference (as delivered by amember_cptr) + 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.a1c(), 79 ); + self.assertEqual( aref.get_n_const(), 79 ); b.set_an( -1 ) - self.assertEqual( aref.a1c(), -1 ); + self.assertEqual( aref.get_n_const(), -1 ); def test_19(self): @@ -1140,11 +1219,11 @@ class BasicTest(unittest.TestCase): a1 = b.amember_or_nil_alt( True ) a2 = b.amember_ptr_alt() - self.assertEqual( a1.a1(), 17 ) - self.assertEqual( a2.a1(), 17 ) + self.assertEqual( a1.get_n(), 17 ) + self.assertEqual( a2.get_n(), 17 ) a1.a5( 761 ) - self.assertEqual( a1.a1(), 761 ) - self.assertEqual( a2.a1(), 761 ) + self.assertEqual( a1.get_n(), 761 ) + self.assertEqual( a2.get_n(), 761 ) a1 = b.amember_or_nil( False ) self.assertEqual( a1, None )