diff options
Diffstat (limited to 'scipy/weave/tests/test_scxx_object.py')
| -rw-r--r-- | scipy/weave/tests/test_scxx_object.py | 822 |
1 files changed, 822 insertions, 0 deletions
diff --git a/scipy/weave/tests/test_scxx_object.py b/scipy/weave/tests/test_scxx_object.py new file mode 100644 index 000000000..8e93698cf --- /dev/null +++ b/scipy/weave/tests/test_scxx_object.py @@ -0,0 +1,822 @@ +""" Test refcounting and behavior of SCXX. +""" +import unittest +import time +import os,sys + +from scipy_test.testing import * +set_package_path() +from weave import inline_tools +restore_path() + +class test_object_construct(unittest.TestCase): + #------------------------------------------------------------------------ + # Check that construction from basic types is allowed and have correct + # reference counts + #------------------------------------------------------------------------ + def check_int(self,level=5): + # strange int value used to try and make sure refcount is 2. + code = """ + py::object val = 1001; + return_val = val; + """ + res = inline_tools.inline(code) + assert sys.getrefcount(res) == 2 + assert res == 1001 + def check_float(self,level=5): + code = """ + py::object val = (float)1.0; + return_val = val; + """ + res = inline_tools.inline(code) + assert sys.getrefcount(res) == 2 + assert res == 1.0 + def check_double(self,level=5): + code = """ + py::object val = 1.0; + return_val = val; + """ + res = inline_tools.inline(code) + assert sys.getrefcount(res) == 2 + assert res == 1.0 + def check_complex(self,level=5): + code = """ + std::complex<double> num = std::complex<double>(1.0,1.0); + py::object val = num; + return_val = val; + """ + res = inline_tools.inline(code) + assert sys.getrefcount(res) == 2 + assert res == 1.0+1.0j + def check_string(self,level=5): + code = """ + py::object val = "hello"; + return_val = val; + """ + res = inline_tools.inline(code) + assert sys.getrefcount(res) == 2 + assert res == "hello" + + def check_std_string(self,level=5): + code = """ + std::string s = std::string("hello"); + py::object val = s; + return_val = val; + """ + res = inline_tools.inline(code) + assert sys.getrefcount(res) == 2 + assert res == "hello" + +class test_object_print(unittest.TestCase): + #------------------------------------------------------------------------ + # Check the object print protocol. + #------------------------------------------------------------------------ + def check_stdout(self,level=5): + code = """ + py::object val = "how now brown cow"; + val.print(stdout); + """ + res = inline_tools.inline(code) + # visual check on this one. + def check_stringio(self,level=5): + import cStringIO + file_imposter = cStringIO.StringIO() + code = """ + py::object val = "how now brown cow"; + val.print(file_imposter); + """ + res = inline_tools.inline(code,['file_imposter']) + print file_imposter.getvalue() + assert file_imposter.getvalue() == "'how now brown cow'" + + def check_failure(self,level=5): + code = """ + FILE* file = 0; + py::object val = "how now brown cow"; + val.print(file); + """ + try: + res = inline_tools.inline(code) + except: + # error was supposed to occur. + pass + + +class test_object_cast(unittest.TestCase): + def check_int_cast(self,level=5): + code = """ + py::object val = 1; + int raw_val = val; + """ + inline_tools.inline(code) + def check_double_cast(self,level=5): + code = """ + py::object val = 1.0; + double raw_val = val; + """ + inline_tools.inline(code) + def check_float_cast(self,level=5): + code = """ + py::object val = 1.0; + float raw_val = val; + """ + inline_tools.inline(code) + def check_complex_cast(self,level=5): + code = """ + std::complex<double> num = std::complex<double>(1.0,1.0); + py::object val = num; + std::complex<double> raw_val = val; + """ + inline_tools.inline(code) + def check_string_cast(self,level=5): + code = """ + py::object val = "hello"; + std::string raw_val = val; + """ + inline_tools.inline(code) + +# test class used for testing python class access from C++. +class foo: + def bar(self): + return "bar results" + def bar2(self,val1,val2): + return val1, val2 + def bar3(self,val1,val2,val3=1): + return val1, val2, val3 + +class str_obj: + def __str__(self): + return "b" + +class test_object_hasattr(unittest.TestCase): + def check_string(self,level=5): + a = foo() + a.b = 12345 + code = """ + return_val = a.hasattr("b"); + """ + res = inline_tools.inline(code,['a']) + assert res + def check_std_string(self,level=5): + a = foo() + a.b = 12345 + attr_name = "b" + code = """ + return_val = a.hasattr(attr_name); + """ + res = inline_tools.inline(code,['a','attr_name']) + assert res + def check_string_fail(self,level=5): + a = foo() + a.b = 12345 + code = """ + return_val = a.hasattr("c"); + """ + res = inline_tools.inline(code,['a']) + assert not res + def check_inline(self,level=5): + """ THIS NEEDS TO MOVE TO THE INLINE TEST SUITE + """ + a = foo() + a.b = 12345 + code = """ + throw_error(PyExc_AttributeError,"bummer"); + """ + try: + before = sys.getrefcount(a) + res = inline_tools.inline(code,['a']) + except AttributeError: + after = sys.getrefcount(a) + try: + res = inline_tools.inline(code,['a']) + except: + after2 = sys.getrefcount(a) + print "after and after2 should be equal in the following" + print 'before, after, after2:', before, after, after2 + pass + + def check_func(self,level=5): + a = foo() + a.b = 12345 + code = """ + return_val = a.hasattr("bar"); + """ + res = inline_tools.inline(code,['a']) + assert res + +class test_object_attr(unittest.TestCase): + + def generic_attr(self,code,args=['a']): + a = foo() + a.b = 12345 + + before = sys.getrefcount(a.b) + res = inline_tools.inline(code,args) + assert res == a.b + del res + after = sys.getrefcount(a.b) + assert after == before + + def check_char(self,level=5): + self.generic_attr('return_val = a.attr("b");') + + def check_char_fail(self,level=5): + try: + self.generic_attr('return_val = a.attr("c");') + except AttributeError: + pass + + def check_string(self,level=5): + self.generic_attr('return_val = a.attr(std::string("b"));') + + def check_string_fail(self,level=5): + try: + self.generic_attr('return_val = a.attr(std::string("c"));') + except AttributeError: + pass + + def check_obj(self,level=5): + code = """ + py::object name = "b"; + return_val = a.attr(name); + """ + self.generic_attr(code,['a']) + + def check_obj_fail(self,level=5): + try: + code = """ + py::object name = "c"; + return_val = a.attr(name); + """ + self.generic_attr(code,['a']) + except AttributeError: + pass + + def check_attr_call(self,level=5): + a = foo() + res = inline_tools.inline('return_val = a.attr("bar").call();',['a']) + first = sys.getrefcount(res) + del res + res = inline_tools.inline('return_val = a.attr("bar").call();',['a']) + second = sys.getrefcount(res) + assert res == "bar results" + assert first == second + +class test_object_set_attr(unittest.TestCase): + + def generic_existing(self, code, desired): + args = ['a'] + a = foo() + a.b = 12345 + res = inline_tools.inline(code,args) + assert a.b == desired + + def generic_new(self, code, desired): + args = ['a'] + a = foo() + res = inline_tools.inline(code,args) + assert a.b == desired + + def check_existing_char(self,level=5): + self.generic_existing('a.set_attr("b","hello");',"hello") + def check_new_char(self,level=5): + self.generic_new('a.set_attr("b","hello");',"hello") + def check_existing_string(self,level=5): + self.generic_existing('a.set_attr("b",std::string("hello"));',"hello") + def check_new_string(self,level=5): + self.generic_new('a.set_attr("b",std::string("hello"));',"hello") + def check_existing_object(self,level=5): + code = """ + py::object obj = "hello"; + a.set_attr("b",obj); + """ + self.generic_existing(code,"hello") + def check_new_object(self,level=5): + code = """ + py::object obj = "hello"; + a.set_attr("b",obj); + """ + self.generic_new(code,"hello") + def check_new_fail(self,level=5): + try: + code = """ + py::object obj = 1; + a.set_attr(obj,"hello"); + """ + self.generic_new(code,"hello") + except: + pass + + def check_existing_int(self,level=5): + self.generic_existing('a.set_attr("b",1);',1) + def check_existing_double(self,level=5): + self.generic_existing('a.set_attr("b",1.0);',1.0) + def check_existing_complex(self,level=5): + code = """ + std::complex<double> obj = std::complex<double>(1,1); + a.set_attr("b",obj); + """ + self.generic_existing(code,1+1j) + def check_existing_char1(self,level=5): + self.generic_existing('a.set_attr("b","hello");',"hello") + def check_existing_string1(self,level=5): + code = """ + std::string obj = std::string("hello"); + a.set_attr("b",obj); + """ + self.generic_existing(code,"hello") + +class test_object_del(unittest.TestCase): + def generic(self, code): + args = ['a'] + a = foo() + a.b = 12345 + res = inline_tools.inline(code,args) + assert not hasattr(a,"b") + + def check_char(self,level=5): + self.generic('a.del("b");') + def check_string(self,level=5): + code = """ + std::string name = std::string("b"); + a.del(name); + """ + self.generic(code) + def check_object(self,level=5): + code = """ + py::object name = py::object("b"); + a.del(name); + """ + self.generic(code) + +class test_object_cmp(unittest.TestCase): + def check_equal(self,level=5): + a,b = 1,1 + res = inline_tools.inline('return_val = (a == b);',['a','b']) + assert res == (a == b) + def check_equal_objects(self,level=5): + class foo: + def __init__(self,x): + self.x = x + def __cmp__(self,other): + return cmp(self.x,other.x) + a,b = foo(1),foo(2) + res = inline_tools.inline('return_val = (a == b);',['a','b']) + assert res == (a == b) + def check_lt(self,level=5): + a,b = 1,2 + res = inline_tools.inline('return_val = (a < b);',['a','b']) + assert res == (a < b) + def check_gt(self,level=5): + a,b = 1,2 + res = inline_tools.inline('return_val = (a > b);',['a','b']) + assert res == (a > b) + def check_gte(self,level=5): + a,b = 1,2 + res = inline_tools.inline('return_val = (a >= b);',['a','b']) + assert res == (a >= b) + def check_lte(self,level=5): + a,b = 1,2 + res = inline_tools.inline('return_val = (a <= b);',['a','b']) + assert res == (a <= b) + def check_not_equal(self,level=5): + a,b = 1,2 + res = inline_tools.inline('return_val = (a != b);',['a','b']) + assert res == (a != b) + def check_int(self,level=5): + a = 1 + res = inline_tools.inline('return_val = (a == 1);',['a']) + assert res == (a == 1) + def check_int2(self,level=5): + a = 1 + res = inline_tools.inline('return_val = (1 == a);',['a']) + assert res == (a == 1) + def check_unsigned_long(self,level=5): + a = 1 + res = inline_tools.inline('return_val = (a == (unsigned long)1);',['a']) + assert res == (a == 1) + def check_double(self,level=5): + a = 1 + res = inline_tools.inline('return_val = (a == 1.0);',['a']) + assert res == (a == 1.0) + def check_char(self,level=5): + a = "hello" + res = inline_tools.inline('return_val = (a == "hello");',['a']) + assert res == (a == "hello") + def check_std_string(self,level=5): + a = "hello" + code = """ + std::string hello = std::string("hello"); + return_val = (a == hello); + """ + res = inline_tools.inline(code,['a']) + assert res == (a == "hello") + +class test_object_repr(unittest.TestCase): + def check_repr(self,level=5): + class foo: + def __str__(self): + return "str return" + def __repr__(self): + return "repr return" + a = foo() + res = inline_tools.inline('return_val = a.repr();',['a']) + first = sys.getrefcount(res) + del res + res = inline_tools.inline('return_val = a.repr();',['a']) + second = sys.getrefcount(res) + assert first == second + assert res == "repr return" + +class test_object_str(unittest.TestCase): + def check_str(self,level=5): + class foo: + def __str__(self): + return "str return" + def __repr__(self): + return "repr return" + a = foo() + res = inline_tools.inline('return_val = a.str();',['a']) + first = sys.getrefcount(res) + del res + res = inline_tools.inline('return_val = a.str();',['a']) + second = sys.getrefcount(res) + assert first == second + print res + assert res == "str return" + +class test_object_unicode(unittest.TestCase): + # This ain't going to win awards for test of the year... + def check_unicode(self,level=5): + class foo: + def __repr__(self): + return "repr return" + def __str__(self): + return "unicode" + a= foo() + res = inline_tools.inline('return_val = a.unicode();',['a']) + first = sys.getrefcount(res) + del res + res = inline_tools.inline('return_val = a.unicode();',['a']) + second = sys.getrefcount(res) + assert first == second + assert res == "unicode" + +class test_object_is_callable(unittest.TestCase): + def check_true(self,level=5): + class foo: + def __call__(self): + return 0 + a= foo() + res = inline_tools.inline('return_val = a.is_callable();',['a']) + assert res + def check_false(self,level=5): + class foo: + pass + a= foo() + res = inline_tools.inline('return_val = a.is_callable();',['a']) + assert not res + +class test_object_call(unittest.TestCase): + def check_noargs(self,level=5): + def foo(): + return (1,2,3) + res = inline_tools.inline('return_val = foo.call();',['foo']) + assert res == (1,2,3) + assert sys.getrefcount(res) == 2 + def check_args(self,level=5): + def foo(val1,val2): + return (val1,val2) + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + return_val = foo.call(args); + """ + res = inline_tools.inline(code,['foo']) + assert res == (1,"hello") + assert sys.getrefcount(res) == 2 + def check_args_kw(self,level=5): + def foo(val1,val2,val3=1): + return (val1,val2,val3) + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + py::dict kw; + kw["val3"] = 3; + return_val = foo.call(args,kw); + """ + res = inline_tools.inline(code,['foo']) + assert res == (1,"hello",3) + assert sys.getrefcount(res) == 2 + def check_noargs_with_args(self,level=5): + # calling a function that does take args with args + # should fail. + def foo(): + return "blah" + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + return_val = foo.call(args); + """ + try: + first = sys.getrefcount(foo) + res = inline_tools.inline(code,['foo']) + except TypeError: + second = sys.getrefcount(foo) + try: + res = inline_tools.inline(code,['foo']) + except TypeError: + third = sys.getrefcount(foo) + # first should == second, but the weird refcount error + assert second == third + +class test_object_mcall(unittest.TestCase): + def check_noargs(self,level=5): + a = foo() + res = inline_tools.inline('return_val = a.mcall("bar");',['a']) + assert res == "bar results" + first = sys.getrefcount(res) + del res + res = inline_tools.inline('return_val = a.mcall("bar");',['a']) + assert res == "bar results" + second = sys.getrefcount(res) + assert first == second + def check_args(self,level=5): + a = foo() + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + return_val = a.mcall("bar2",args); + """ + res = inline_tools.inline(code,['a']) + assert res == (1,"hello") + assert sys.getrefcount(res) == 2 + def check_args_kw(self,level=5): + a = foo() + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + py::dict kw; + kw["val3"] = 3; + return_val = a.mcall("bar3",args,kw); + """ + res = inline_tools.inline(code,['a']) + assert res == (1,"hello",3) + assert sys.getrefcount(res) == 2 + def check_std_noargs(self,level=5): + a = foo() + method = "bar" + res = inline_tools.inline('return_val = a.mcall(method);',['a','method']) + assert res == "bar results" + first = sys.getrefcount(res) + del res + res = inline_tools.inline('return_val = a.mcall(method);',['a','method']) + assert res == "bar results" + second = sys.getrefcount(res) + assert first == second + def check_std_args(self,level=5): + a = foo() + method = "bar2" + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + return_val = a.mcall(method,args); + """ + res = inline_tools.inline(code,['a','method']) + assert res == (1,"hello") + assert sys.getrefcount(res) == 2 + def check_std_args_kw(self,level=5): + a = foo() + method = "bar3" + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + py::dict kw; + kw["val3"] = 3; + return_val = a.mcall(method,args,kw); + """ + res = inline_tools.inline(code,['a','method']) + assert res == (1,"hello",3) + assert sys.getrefcount(res) == 2 + def check_noargs_with_args(self,level=5): + # calling a function that does take args with args + # should fail. + a = foo() + code = """ + py::tuple args(2); + args[0] = 1; + args[1] = "hello"; + return_val = a.mcall("bar",args); + """ + try: + first = sys.getrefcount(a) + res = inline_tools.inline(code,['a']) + except TypeError: + second = sys.getrefcount(a) + try: + res = inline_tools.inline(code,['a']) + except TypeError: + third = sys.getrefcount(a) + # first should == second, but the weird refcount error + assert second == third + +class test_object_hash(unittest.TestCase): + def check_hash(self,level=5): + class foo: + def __hash__(self): + return 123 + a= foo() + res = inline_tools.inline('return_val = a.hash(); ',['a']) + print 'hash:', res + assert res == 123 + +class test_object_is_true(unittest.TestCase): + def check_true(self,level=5): + class foo: + pass + a= foo() + res = inline_tools.inline('return_val = a.is_true();',['a']) + assert res == 1 + def check_false(self,level=5): + a= None + res = inline_tools.inline('return_val = a.is_true();',['a']) + assert res == 0 + +class test_object_is_true(unittest.TestCase): + def check_false(self,level=5): + class foo: + pass + a= foo() + res = inline_tools.inline('return_val = a.not();',['a']) + assert res == 0 + def check_true(self,level=5): + a= None + res = inline_tools.inline('return_val = a.not();',['a']) + assert res == 1 + +class test_object_type(unittest.TestCase): + def check_type(self,level=5): + class foo: + pass + a= foo() + res = inline_tools.inline('return_val = a.type();',['a']) + assert res == type(a) + +class test_object_size(unittest.TestCase): + def check_size(self,level=5): + class foo: + def __len__(self): + return 10 + a= foo() + res = inline_tools.inline('return_val = a.size();',['a']) + assert res == len(a) + def check_len(self,level=5): + class foo: + def __len__(self): + return 10 + a= foo() + res = inline_tools.inline('return_val = a.len();',['a']) + assert res == len(a) + def check_length(self,level=5): + class foo: + def __len__(self): + return 10 + a= foo() + res = inline_tools.inline('return_val = a.length();',['a']) + assert res == len(a) + +from UserList import UserList +class test_object_set_item_op_index(unittest.TestCase): + def check_list_refcount(self,level=5): + a = UserList([1,2,3]) + # temporary refcount fix until I understand why it incs by one. + inline_tools.inline("a[1] = 1234;",['a']) + before1 = sys.getrefcount(a) + after1 = sys.getrefcount(a) + assert after1 == before1 + def check_set_int(self,level=5): + a = UserList([1,2,3]) + inline_tools.inline("a[1] = 1234;",['a']) + assert sys.getrefcount(a[1]) == 2 + assert a[1] == 1234 + def check_set_double(self,level=5): + a = UserList([1,2,3]) + inline_tools.inline("a[1] = 123.0;",['a']) + assert sys.getrefcount(a[1]) == 2 + assert a[1] == 123.0 + def check_set_char(self,level=5): + a = UserList([1,2,3]) + inline_tools.inline('a[1] = "bubba";',['a']) + assert sys.getrefcount(a[1]) == 2 + assert a[1] == 'bubba' + def check_set_string(self,level=5): + a = UserList([1,2,3]) + inline_tools.inline('a[1] = std::string("sissy");',['a']) + assert sys.getrefcount(a[1]) == 2 + assert a[1] == 'sissy' + def check_set_string(self,level=5): + a = UserList([1,2,3]) + inline_tools.inline('a[1] = std::complex<double>(1,1);',['a']) + assert sys.getrefcount(a[1]) == 2 + assert a[1] == 1+1j + +from UserDict import UserDict +class test_object_set_item_op_key(unittest.TestCase): + def check_key_refcount(self,level=5): + a = UserDict() + code = """ + py::object one = 1; + py::object two = 2; + py::tuple ref_counts(3); + py::tuple obj_counts(3); + py::tuple val_counts(3); + py::tuple key_counts(3); + obj_counts[0] = a.refcount(); + key_counts[0] = one.refcount(); + val_counts[0] = two.refcount(); + a[1] = 2; + obj_counts[1] = a.refcount(); + key_counts[1] = one.refcount(); + val_counts[1] = two.refcount(); + a[1] = 2; + obj_counts[2] = a.refcount(); + key_counts[2] = one.refcount(); + val_counts[2] = two.refcount(); + + ref_counts[0] = obj_counts; + ref_counts[1] = key_counts; + ref_counts[2] = val_counts; + return_val = ref_counts; + """ + obj,key,val = inline_tools.inline(code,['a']) + assert obj[0] == obj[1] and obj[1] == obj[2] + assert key[0] + 1 == key[1] and key[1] == key[2] + assert val[0] + 1 == val[1] and val[1] == val[2] + + def check_set_double_exists(self,level=5): + a = UserDict() + key = 10.0 + a[key] = 100.0 + inline_tools.inline('a[key] = 123.0;',['a','key']) + first = sys.getrefcount(key) + inline_tools.inline('a[key] = 123.0;',['a','key']) + second = sys.getrefcount(key) + assert first == second + # !! I think the following should be 3 + assert sys.getrefcount(key) == 5 + assert sys.getrefcount(a[key]) == 2 + assert a[key] == 123.0 + def check_set_double_new(self,level=5): + a = UserDict() + key = 1.0 + inline_tools.inline('a[key] = 123.0;',['a','key']) + assert sys.getrefcount(key) == 4 # should be 3 + assert sys.getrefcount(a[key]) == 2 + assert a[key] == 123.0 + def check_set_complex(self,level=5): + a = UserDict() + key = 1+1j + inline_tools.inline("a[key] = 1234;",['a','key']) + assert sys.getrefcount(key) == 3 + assert sys.getrefcount(a[key]) == 2 + assert a[key] == 1234 + def check_set_char(self,level=5): + a = UserDict() + inline_tools.inline('a["hello"] = 123.0;',['a']) + assert sys.getrefcount(a["hello"]) == 2 + assert a["hello"] == 123.0 + + def check_set_class(self,level=5): + a = UserDict() + class foo: + def __init__(self,val): + self.val = val + def __hash__(self): + return self.val + key = foo(4) + inline_tools.inline('a[key] = "bubba";',['a','key']) + first = sys.getrefcount(key) + inline_tools.inline('a[key] = "bubba";',['a','key']) + second = sys.getrefcount(key) + # I don't think we're leaking if this is true + assert first == second + # !! BUT -- I think this should be 3 + assert sys.getrefcount(key) == 4 + assert sys.getrefcount(a[key]) == 2 + assert a[key] == 'bubba' + def check_set_from_member(self,level=5): + a = UserDict() + a['first'] = 1 + a['second'] = 2 + inline_tools.inline('a["first"] = a["second"];',['a']) + assert a['first'] == a['second'] + +if __name__ == "__main__": + ScipyTest('weave.scxx').run() |