diff options
Diffstat (limited to 'numpy/f2py/lib/tests')
| -rw-r--r-- | numpy/f2py/lib/tests/test_derived_scalar.py | 74 | ||||
| -rw-r--r-- | numpy/f2py/lib/tests/test_module_module.py | 61 | ||||
| -rw-r--r-- | numpy/f2py/lib/tests/test_module_scalar.py | 58 | ||||
| -rw-r--r-- | numpy/f2py/lib/tests/test_scalar_function_in.py | 532 | ||||
| -rw-r--r-- | numpy/f2py/lib/tests/test_scalar_in_out.py | 529 |
5 files changed, 1254 insertions, 0 deletions
diff --git a/numpy/f2py/lib/tests/test_derived_scalar.py b/numpy/f2py/lib/tests/test_derived_scalar.py new file mode 100644 index 000000000..c57778020 --- /dev/null +++ b/numpy/f2py/lib/tests/test_derived_scalar.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python +""" +Tests for intent(in,out) derived type arguments in Fortran subroutine's. + +----- +Permission to use, modify, and distribute this software is given under the +terms of the NumPy License. See http://scipy.org. + +NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. +Author: Pearu Peterson <pearu@cens.ioc.ee> +Created: Oct 2006 +----- +""" + +import os +import sys +from numpy.testing import * +set_package_path() +from lib.main import build_extension, compile +restore_path() + +fortran_code = ''' +subroutine foo(a) + type myt + integer flag + end type myt + type(myt) a +!f2py intent(in,out) a + a % flag = a % flag + 1 +end +function foo2(a) + type myt + integer flag + end type myt + type(myt) a + type(myt) foo2 + foo2 % flag = a % flag + 2 +end +''' + +m, = compile(fortran_code, 'test_derived_scalar_ext') + +from numpy import * + +class test_m(NumpyTestCase): + + def check_foo_simple(self, level=1): + a = m.myt(2) + assert_equal(a.flag,2) + assert isinstance(a,m.myt),`a` + r = m.foo(a) + assert isinstance(r,m.myt),`r` + assert r is a + assert_equal(r.flag,3) + assert_equal(a.flag,3) + + a.flag = 5 + assert_equal(r.flag,5) + + #s = m.foo((5,)) + + def check_foo2_simple(self, level=1): + a = m.myt(2) + assert_equal(a.flag,2) + assert isinstance(a,m.myt),`a` + r = m.foo2(a) + assert isinstance(r,m.myt),`r` + assert r is not a + assert_equal(a.flag,2) + assert_equal(r.flag,4) + + +if __name__ == "__main__": + NumpyTest().run() diff --git a/numpy/f2py/lib/tests/test_module_module.py b/numpy/f2py/lib/tests/test_module_module.py new file mode 100644 index 000000000..4d242ed54 --- /dev/null +++ b/numpy/f2py/lib/tests/test_module_module.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python +""" +Tests for module with scalar derived types and subprograms. + +----- +Permission to use, modify, and distribute this software is given under the +terms of the NumPy License. See http://scipy.org. + +NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. +Author: Pearu Peterson <pearu@cens.ioc.ee> +Created: Oct 2006 +----- +""" + +import os +import sys +from numpy.testing import * + +set_package_path() +from lib.main import build_extension, compile +restore_path() + +fortran_code = ''' +module test_module_module_ext2 + type rat + integer n,d + end type rat + contains + subroutine foo2() + print*,"In foo2" + end subroutine foo2 +end module +module test_module_module_ext + contains + subroutine foo + use test_module_module_ext2 + print*,"In foo" + call foo2 + end subroutine foo + subroutine bar(a) + use test_module_module_ext2 + type(rat) a + print*,"In bar,a=",a + end subroutine bar +end module test_module_module_ext +''' + +m,m2 = compile(fortran_code, modulenames=['test_module_module_ext', + 'test_module_module_ext2', + ]) + +from numpy import * + +class test_m(NumpyTestCase): + + def check_foo_simple(self, level=1): + foo = m.foo + foo() + +if __name__ == "__main__": + NumpyTest().run() diff --git a/numpy/f2py/lib/tests/test_module_scalar.py b/numpy/f2py/lib/tests/test_module_scalar.py new file mode 100644 index 000000000..e11a1e0ae --- /dev/null +++ b/numpy/f2py/lib/tests/test_module_scalar.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python +""" +Tests for module with scalar derived types and subprograms. + +----- +Permission to use, modify, and distribute this software is given under the +terms of the NumPy License. See http://scipy.org. + +NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. +Author: Pearu Peterson <pearu@cens.ioc.ee> +Created: Oct 2006 +----- +""" + +import os +import sys +from numpy.testing import * +set_package_path() +from lib.main import build_extension, compile +restore_path() + +fortran_code = ''' +module test_module_scalar_ext + + contains + subroutine foo(a) + integer a +!f2py intent(in,out) a + a = a + 1 + end subroutine foo + function foo2(a) + integer a + integer foo2 + foo2 = a + 2 + end function foo2 +end module test_module_scalar_ext +''' + +m, = compile(fortran_code, modulenames = ['test_module_scalar_ext']) + +from numpy import * + +class test_m(NumpyTestCase): + + def check_foo_simple(self, level=1): + foo = m.foo + r = foo(2) + assert isinstance(r,int32),`type(r)` + assert_equal(r,3) + + def check_foo2_simple(self, level=1): + foo2 = m.foo2 + r = foo2(2) + assert isinstance(r,int32),`type(r)` + assert_equal(r,4) + +if __name__ == "__main__": + NumpyTest().run() diff --git a/numpy/f2py/lib/tests/test_scalar_function_in.py b/numpy/f2py/lib/tests/test_scalar_function_in.py new file mode 100644 index 000000000..9c5cd8aba --- /dev/null +++ b/numpy/f2py/lib/tests/test_scalar_function_in.py @@ -0,0 +1,532 @@ +#!/usr/bin/env python +""" +Tests for intent(in) arguments in subroutine-wrapped Fortran functions. + +----- +Permission to use, modify, and distribute this software is given under the +terms of the NumPy License. See http://scipy.org. + +NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. +Author: Pearu Peterson <pearu@cens.ioc.ee> +Created: Oct 2006 +----- +""" + +import os +import sys +from numpy.testing import * + +set_package_path() +from lib.main import build_extension, compile +restore_path() + +fortran_code = '''\ +! -*- f77 -*- + function fooint1(a) + integer*1 a + integer*1 fooint1 + fooint1 = a + 1 + end + function fooint2(a) + integer*2 a + integer*2 fooint2 + fooint2 = a + 1 + end + function fooint4(a) + integer*4 a + integer*4 fooint4 + fooint4 = a + 1 + end + function fooint8(a) + integer*8 a + integer*8 fooint8 + fooint8 = a + 1 + end + function foofloat4(a) + real*4 a + real*4 foofloat4 + foofloat4 = a + 1.0e0 + end + function foofloat8(a) + real*8 a + real*8 foofloat8 + foofloat8 = a + 1.0d0 + end + function foocomplex8(a) + complex*8 a + complex*8 foocomplex8 + foocomplex8 = a + 1.0e0 + end + function foocomplex16(a) + complex*16 a + complex*16 foocomplex16 + foocomplex16 = a + 1.0d0 + end + function foobool1(a) + logical*1 a + logical*1 foobool1 + foobool1 = .not. a + end + function foobool2(a) + logical*2 a + logical*2 foobool2 + foobool2 = .not. a + end + function foobool4(a) + logical*4 a + logical*4 foobool4 + foobool4 = .not. a + end + function foobool8(a) + logical*8 a + logical*8 foobool8 + foobool8 = .not. a + end + function foostring1(a) + character*1 a + character*1 foostring1 + foostring1 = "1" + end + function foostring5(a) + character*5 a + character*5 foostring5 + foostring5 = a + foostring5(1:2) = "12" + end +! function foostringstar(a) +! character*(*) a +! character*(*) foostringstar +! if (len(a).gt.0) then +! foostringstar = a +! foostringstar(1:1) = "1" +! endif +! end +''' + +m, = compile(fortran_code, 'test_scalar_function_in_ext') + +from numpy import * + +class test_m(NumpyTestCase): + + def check_foo_integer1(self, level=1): + i = int8(2) + e = int8(3) + func = m.fooint1 + assert isinstance(i,int8),`type(i)` + r = func(i) + assert isinstance(r,int8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + for intx in [int64,int16,int32]: + r = func(intx(2)) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_integer2(self, level=1): + i = int16(2) + e = int16(3) + func = m.fooint2 + assert isinstance(i,int16),`type(i)` + r = func(i) + assert isinstance(r,int16),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + for intx in [int8,int64,int32]: + r = func(intx(2)) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_integer4(self, level=1): + i = int32(2) + e = int32(3) + func = m.fooint4 + assert isinstance(i,int32),`type(i)` + r = func(i) + assert isinstance(r,int32),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + for intx in [int8,int16,int64]: + r = func(intx(2)) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_integer8(self, level=1): + i = int64(2) + e = int64(3) + func = m.fooint8 + assert isinstance(i,int64),`type(i)` + r = func(i) + assert isinstance(r,int64),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + for intx in [int8,int16,int32]: + r = func(intx(2)) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_real4(self, level=1): + i = float32(2) + e = float32(3) + func = m.foofloat4 + assert isinstance(i,float32),`type(i)` + r = func(i) + assert isinstance(r,float32),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e+float32(0.2)) + + r = func(float64(2.0)) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_real8(self, level=1): + i = float64(2) + e = float64(3) + func = m.foofloat8 + assert isinstance(i,float64),`type(i)` + r = func(i) + assert isinstance(r,float64),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e+float64(0.2)) + + r = func(float32(2.0)) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_complex8(self, level=1): + i = complex64(2) + e = complex64(3) + func = m.foocomplex8 + assert isinstance(i,complex64),`type(i)` + r = func(i) + assert isinstance(r,complex64),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e+complex64(0.2)) + + r = func(2+1j) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e+complex64(1j)) + + r = func(complex128(2.0)) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func([2,3]) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e+complex64(3j)) + + self.assertRaises(TypeError,lambda :func([2,1,3])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_complex16(self, level=1): + i = complex128(2) + e = complex128(3) + func = m.foocomplex16 + assert isinstance(i,complex128),`type(i)` + r = func(i) + assert isinstance(r,complex128),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e+complex128(0.2)) + + r = func(2+1j) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e+complex128(1j)) + + r = func([2]) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + r = func([2,3]) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e+complex128(3j)) + + r = func(complex64(2.0)) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func([2,1,3])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_bool1(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool1 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_bool2(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool2 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_bool4(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool4 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_bool8(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool8 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_string1(self, level=1): + i = string0('a') + e = string0('1') + func = m.foostring1 + assert isinstance(i,string0),`type(i)` + r = func(i) + assert isinstance(r,string0),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func('ab') + assert isinstance(r,string0),`type(r)` + assert_equal(r,e) + + r = func('') + assert isinstance(r,string0),`type(r)` + assert_equal(r,e) + + def check_foo_string5(self, level=1): + i = string0('abcde') + e = string0('12cde') + func = m.foostring5 + assert isinstance(i,string0),`type(i)` + r = func(i) + assert isinstance(r,string0),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func('abc') + assert isinstance(r,string0),`type(r)` + assert_equal(r,'12c ') + + r = func('abcdefghi') + assert isinstance(r,string0),`type(r)` + assert_equal(r,'12cde') + + r = func([1]) + assert isinstance(r,string0),`type(r)` + assert_equal(r,'12] ') + + def _check_foo_string0(self, level=1): + i = string0('abcde') + e = string0('12cde') + func = m.foostringstar + r = func('abcde') + assert_equal(r,'1bcde') + r = func('') + assert_equal(r,'') + +if __name__ == "__main__": + NumpyTest().run() diff --git a/numpy/f2py/lib/tests/test_scalar_in_out.py b/numpy/f2py/lib/tests/test_scalar_in_out.py new file mode 100644 index 000000000..b73036848 --- /dev/null +++ b/numpy/f2py/lib/tests/test_scalar_in_out.py @@ -0,0 +1,529 @@ +#!/usr/bin/env python +""" +Tests for intent(in,out) arguments in Fortran subroutine's. + +----- +Permission to use, modify, and distribute this software is given under the +terms of the NumPy License. See http://scipy.org. + +NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. +Author: Pearu Peterson <pearu@cens.ioc.ee> +Created: Oct 2006 +----- +""" + +import os +import sys +from numpy.testing import * + +set_package_path() +from lib.main import build_extension, compile +restore_path() + +fortran_code = ''' + subroutine fooint1(a) + integer*1 a +!f2py intent(in,out) a + a = a + 1 + end + subroutine fooint2(a) + integer*2 a +!f2py intent(in,out) a + a = a + 1 + end + subroutine fooint4(a) + integer*4 a +!f2py intent(in,out) a + a = a + 1 + end + subroutine fooint8(a) + integer*8 a +!f2py intent(in,out) a + a = a + 1 + end + subroutine foofloat4(a) + real*4 a +!f2py intent(in,out) a + a = a + 1.0e0 + end + subroutine foofloat8(a) + real*8 a +!f2py intent(in,out) a + a = a + 1.0d0 + end + subroutine foocomplex8(a) + complex*8 a +!f2py intent(in,out) a + a = a + 1.0e0 + end + subroutine foocomplex16(a) + complex*16 a +!f2py intent(in,out) a + a = a + 1.0d0 + end + subroutine foobool1(a) + logical*1 a +!f2py intent(in,out) a + a = .not. a + end + subroutine foobool2(a) + logical*2 a +!f2py intent(in,out) a + a = .not. a + end + subroutine foobool4(a) + logical*4 a +!f2py intent(in,out) a + a = .not. a + end + subroutine foobool8(a) + logical*8 a +!f2py intent(in,out) a + a = .not. a + end + subroutine foostring1(a) + character*1 a +!f2py intent(in,out) a + a = "1" + end + subroutine foostring5(a) + character*5 a +!f2py intent(in,out) a + a(1:2) = "12" + end + subroutine foostringstar(a) + character*(*) a +!f2py intent(in,out) a + if (len(a).gt.0) then + a(1:1) = "1" + endif + end +''' + +m, = compile(fortran_code, 'test_scalar_in_out_ext', source_ext = '.f') + +from numpy import * + +class test_m(NumpyTestCase): + + def check_foo_integer1(self, level=1): + i = int8(2) + e = int8(3) + func = m.fooint1 + assert isinstance(i,int8),`type(i)` + r = func(i) + assert isinstance(r,int8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + for intx in [int64,int16,int32]: + r = func(intx(2)) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int8),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_integer2(self, level=1): + i = int16(2) + e = int16(3) + func = m.fooint2 + assert isinstance(i,int16),`type(i)` + r = func(i) + assert isinstance(r,int16),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + for intx in [int8,int64,int32]: + r = func(intx(2)) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int16),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_integer4(self, level=1): + i = int32(2) + e = int32(3) + func = m.fooint4 + assert isinstance(i,int32),`type(i)` + r = func(i) + assert isinstance(r,int32),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + for intx in [int8,int16,int64]: + r = func(intx(2)) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int32),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_integer8(self, level=1): + i = int64(2) + e = int64(3) + func = m.fooint8 + assert isinstance(i,int64),`type(i)` + r = func(i) + assert isinstance(r,int64),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + for intx in [int8,int16,int32]: + r = func(intx(2)) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,int64),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_real4(self, level=1): + i = float32(2) + e = float32(3) + func = m.foofloat4 + assert isinstance(i,float32),`type(i)` + r = func(i) + assert isinstance(r,float32),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e+float32(0.2)) + + r = func(float64(2.0)) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,float32),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_real8(self, level=1): + i = float64(2) + e = float64(3) + func = m.foofloat8 + assert isinstance(i,float64),`type(i)` + r = func(i) + assert isinstance(r,float64),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e+float64(0.2)) + + r = func(float32(2.0)) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,float64),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func(2.2j)) + self.assertRaises(TypeError,lambda :func([2,1])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_complex8(self, level=1): + i = complex64(2) + e = complex64(3) + func = m.foocomplex8 + assert isinstance(i,complex64),`type(i)` + r = func(i) + assert isinstance(r,complex64),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e+complex64(0.2)) + + r = func(2+1j) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e+complex64(1j)) + + r = func(complex128(2.0)) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func([2]) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e) + + r = func([2,3]) + assert isinstance(r,complex64),`type(r)` + assert_equal(r,e+complex64(3j)) + + self.assertRaises(TypeError,lambda :func([2,1,3])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_complex16(self, level=1): + i = complex128(2) + e = complex128(3) + func = m.foocomplex16 + assert isinstance(i,complex128),`type(i)` + r = func(i) + assert isinstance(r,complex128),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func(2) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + r = func(2.0) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + r = func(2.2) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e+complex128(0.2)) + + r = func(2+1j) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e+complex128(1j)) + + r = func([2]) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + r = func([2,3]) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e+complex128(3j)) + + r = func(complex64(2.0)) + assert isinstance(r,complex128),`type(r)` + assert_equal(r,e) + + self.assertRaises(TypeError,lambda :func([2,1,3])) + self.assertRaises(TypeError,lambda :func({})) + + def check_foo_bool1(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool1 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_bool2(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool2 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_bool4(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool4 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_bool8(self, level=1): + i = bool8(True) + e = bool8(False) + func = m.foobool8 + assert isinstance(i,bool8),`type(i)` + r = func(i) + assert isinstance(r,bool8),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + for tv in [1,2,2.1,-1j,[0],True]: + r = func(tv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,e) + + for fv in [0,0.0,0j,False,(),{},[]]: + r = func(fv) + assert isinstance(r,bool8),`type(r)` + assert_equal(r,not e) + + def check_foo_string1(self, level=1): + i = string0('a') + e = string0('1') + func = m.foostring1 + assert isinstance(i,string0),`type(i)` + r = func(i) + assert isinstance(r,string0),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func('ab') + assert isinstance(r,string0),`type(r)` + assert_equal(r,e) + + r = func('') + assert isinstance(r,string0),`type(r)` + assert_equal(r,e) + + def check_foo_string5(self, level=1): + i = string0('abcde') + e = string0('12cde') + func = m.foostring5 + assert isinstance(i,string0),`type(i)` + r = func(i) + assert isinstance(r,string0),`type(r)` + assert i is not r,`id(i),id(r)` + assert_equal(r,e) + + r = func('abc') + assert isinstance(r,string0),`type(r)` + assert_equal(r,'12c ') + + r = func('abcdefghi') + assert isinstance(r,string0),`type(r)` + assert_equal(r,'12cde') + + r = func([1]) + assert isinstance(r,string0),`type(r)` + assert_equal(r,'12] ') + + def check_foo_string0(self, level=1): + i = string0('abcde') + e = string0('12cde') + func = m.foostringstar + r = func('abcde') + assert_equal(r,'1bcde') + r = func('') + assert_equal(r,'') + +if __name__ == "__main__": + NumpyTest().run() |