mirror of https://github.com/KLayout/klayout.git
Tests for implict construction from tuple or list arguments
This commit is contained in:
Matthias Koefferlein
parent
b2b950041d
commit
a95706baaa
|
|
@ -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<A_NC *> (avc_nc.back ());
|
||||
avc_nc.pop_back ();
|
||||
while (! m_avc_nc.empty ()) {
|
||||
delete const_cast<A_NC *> (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 <A_NC *>::const_iterator i = d.av_nc.begin (); i != d.av_nc.end (); ++i) {
|
||||
av_nc.push_back (new A_NC (**i));
|
||||
for (std::vector <A_NC *>::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<A_NC *> (avc_nc.back ());
|
||||
avc_nc.pop_back ();
|
||||
while (! m_avc_nc.empty ()) {
|
||||
delete const_cast<A_NC *> (m_avc_nc.back ());
|
||||
m_avc_nc.pop_back ();
|
||||
}
|
||||
for (std::vector <const A_NC *>::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 A_NC *>::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<Enum> decl_qflags_enum ("", "Enums");
|
|||
|
||||
static gsi::Class<A> 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<A> 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<B> 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<B> 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) +
|
||||
|
|
|
|||
|
|
@ -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 <A>::const_iterator b10b () const
|
||||
{
|
||||
return av.begin ();
|
||||
return m_av.begin ();
|
||||
}
|
||||
|
||||
std::vector <A>::const_iterator b10e () const
|
||||
{
|
||||
return av.end ();
|
||||
return m_av.end ();
|
||||
}
|
||||
|
||||
std::vector <A>::iterator b10b_nc ()
|
||||
{
|
||||
return av.begin ();
|
||||
return m_av.begin ();
|
||||
}
|
||||
|
||||
std::vector <A>::iterator b10e_nc ()
|
||||
{
|
||||
return av.end ();
|
||||
return m_av.end ();
|
||||
}
|
||||
|
||||
ValueIter<std::vector <A>::const_iterator> b11b () const
|
||||
{
|
||||
return ValueIter<std::vector <A>::const_iterator> (av.begin ());
|
||||
return ValueIter<std::vector <A>::const_iterator> (m_av.begin ());
|
||||
}
|
||||
|
||||
ValueIter<std::vector <A>::const_iterator> b11e () const
|
||||
{
|
||||
return ValueIter<std::vector <A>::const_iterator> (av.end ());
|
||||
return ValueIter<std::vector <A>::const_iterator> (m_av.end ());
|
||||
}
|
||||
|
||||
std::vector <A_NC *>::const_iterator b12b () const
|
||||
{
|
||||
return av_nc.begin ();
|
||||
return m_av_nc.begin ();
|
||||
}
|
||||
|
||||
std::vector <A_NC *>::const_iterator b12e () const
|
||||
{
|
||||
return av_nc.end ();
|
||||
return m_av_nc.end ();
|
||||
}
|
||||
|
||||
std::vector <const A_NC *>::const_iterator b13b () const
|
||||
{
|
||||
return avc_nc.begin ();
|
||||
return m_avc_nc.begin ();
|
||||
}
|
||||
|
||||
std::vector <const A_NC *>::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 <A> b16a () const
|
||||
std::vector <A> av () const
|
||||
{
|
||||
return av;
|
||||
return m_av;
|
||||
}
|
||||
|
||||
const std::vector <A> &b16b () const
|
||||
const std::vector <A> &av_cref () const
|
||||
{
|
||||
return av;
|
||||
return m_av;
|
||||
}
|
||||
|
||||
std::vector <A> &b16c ()
|
||||
std::vector <A> &av_ref ()
|
||||
{
|
||||
return av;
|
||||
return m_av;
|
||||
}
|
||||
|
||||
void b17a (const std::vector <A> &v)
|
||||
void set_av_cref (const std::vector <A> &v)
|
||||
{
|
||||
av = v;
|
||||
m_av = v;
|
||||
}
|
||||
|
||||
void b17b (std::vector <A> &v)
|
||||
void set_av_ref (std::vector <A> &v)
|
||||
{
|
||||
av = v;
|
||||
m_av = v;
|
||||
}
|
||||
|
||||
void b17c (std::vector <A> v)
|
||||
void set_av (std::vector <A> v)
|
||||
{
|
||||
av = v;
|
||||
m_av = v;
|
||||
}
|
||||
|
||||
void b17d (const std::vector <A> *v)
|
||||
void set_av_cptr (const std::vector <A> *v)
|
||||
{
|
||||
if (v) {
|
||||
av = *v;
|
||||
m_av = *v;
|
||||
} else {
|
||||
m_av.clear ();
|
||||
}
|
||||
}
|
||||
|
||||
void b17e (std::vector <A> *v)
|
||||
void set_av_ptr (std::vector <A> *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<std::vector <A>::const_iterator> b18 () const
|
||||
{
|
||||
return FreeIter<std::vector <A>::const_iterator> (av.begin (), av.end ());
|
||||
return FreeIter<std::vector <A>::const_iterator> (m_av.begin (), m_av.end ());
|
||||
}
|
||||
|
||||
FreeIterUseRef<std::vector <A>::const_iterator> b18b () const
|
||||
{
|
||||
return FreeIterUseRef<std::vector <A>::const_iterator> (av.begin (), av.end ());
|
||||
return FreeIterUseRef<std::vector <A>::const_iterator> (m_av.begin (), m_av.end ());
|
||||
}
|
||||
|
||||
FreeIterUsePtr<std::vector <A>::const_iterator> b18c () const
|
||||
{
|
||||
return FreeIterUsePtr<std::vector <A>::const_iterator> (av.begin (), av.end ());
|
||||
return FreeIterUsePtr<std::vector <A>::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<std::vector <B>::const_iterator> each_b_copy () const
|
||||
{
|
||||
return FreeIter<std::vector <B>::const_iterator> (bv.begin (), bv.end ());
|
||||
return FreeIter<std::vector <B>::const_iterator> (m_bv.begin (), m_bv.end ());
|
||||
}
|
||||
|
||||
FreeIterUseRef<std::vector <B>::const_iterator> each_b_cref () const
|
||||
{
|
||||
return FreeIterUseRef<std::vector <B>::const_iterator> (bv.begin (), bv.end ());
|
||||
return FreeIterUseRef<std::vector <B>::const_iterator> (m_bv.begin (), m_bv.end ());
|
||||
}
|
||||
|
||||
FreeIterUsePtr<std::vector <B>::const_iterator> each_b_cptr () const
|
||||
{
|
||||
return FreeIterUsePtr<std::vector <B>::const_iterator> (bv.begin (), bv.end ());
|
||||
return FreeIterUsePtr<std::vector <B>::const_iterator> (m_bv.begin (), m_bv.end ());
|
||||
}
|
||||
|
||||
FreeIterUseRef<std::vector <B>::iterator> each_b_ref ()
|
||||
{
|
||||
return FreeIterUseRef<std::vector <B>::iterator> (bv.begin (), bv.end ());
|
||||
return FreeIterUseRef<std::vector <B>::iterator> (m_bv.begin (), m_bv.end ());
|
||||
}
|
||||
|
||||
FreeIterUsePtr<std::vector <B>::iterator> each_b_ptr ()
|
||||
{
|
||||
return FreeIterUsePtr<std::vector <B>::iterator> (bv.begin (), bv.end ());
|
||||
return FreeIterUsePtr<std::vector <B>::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<int, A *> map_iaptr () { return m_map_iaptr; }
|
||||
const std::map<int, A *> &map_iaptr_cref () { return m_map_iaptr; }
|
||||
|
|
@ -996,11 +1039,11 @@ struct B
|
|||
#endif
|
||||
|
||||
std::string m;
|
||||
A a;
|
||||
std::vector <B> bv;
|
||||
std::vector <A> av;
|
||||
std::vector <A_NC *> av_nc;
|
||||
std::vector <const A_NC *> avc_nc;
|
||||
A m_a;
|
||||
std::vector <B> m_bv;
|
||||
std::vector <A> m_av;
|
||||
std::vector <A_NC *> m_av_nc;
|
||||
std::vector <const A_NC *> m_avc_nc;
|
||||
tl::Variant m_var;
|
||||
std::vector<tl::Variant> m_vars;
|
||||
std::map<int, std::string> m_map1;
|
||||
|
|
|
|||
|
|
@ -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 )
|
||||
|
|
|
|||
Loading…
Reference in New Issue