Switched to use nose to run tests. Added test and bench functions to all modules.

1 files changed, 72 insertions, 71 deletions

diff --git a/numpy/f2py/lib/parser/test_parser.py b/numpy/f2py/lib/parser/test_parser.py
index e7dd4f971..6770ac4a5 100644
--- a/numpy/f2py/lib/parser/test_parser.py
+++ b/numpy/f2py/lib/parser/test_parser.py
@@ -34,25 +34,25 @@ def parse(cls, line, label='',
         return r
     raise ValueError, 'parsing %r with %s pattern failed' % (line, cls.__name__)
 
-class TestStatements(NumpyTestCase):
+class TestStatements(TestCase):
 
-    def check_assignment(self):
+    def test_assignment(self):
         assert_equal(parse(Assignment,'a=b'), 'a = b')
         assert_equal(parse(PointerAssignment,'a=>b'), 'a => b')
         assert_equal(parse(Assignment,'a (2)=b(n,m)'), 'a(2) = b(n,m)')
         assert_equal(parse(Assignment,'a % 2(2,4)=b(a(i))'), 'a%2(2,4) = b(a(i))')
 
-    def check_assign(self):
+    def test_assign(self):
         assert_equal(parse(Assign,'assign 10 to a'),'ASSIGN 10 TO a')
 
-    def check_call(self):
+    def test_call(self):
         assert_equal(parse(Call,'call a'),'CALL a')
         assert_equal(parse(Call,'call a()'),'CALL a')
         assert_equal(parse(Call,'call a(1)'),'CALL a(1)')
         assert_equal(parse(Call,'call a(1,2)'),'CALL a(1, 2)')
         assert_equal(parse(Call,'call a % 2 ( n , a+1 )'),'CALL a % 2(n, a+1)')
 
-    def check_goto(self):
+    def test_goto(self):
         assert_equal(parse(Goto,'go to 19'),'GO TO 19')
         assert_equal(parse(Goto,'goto 19'),'GO TO 19')
         assert_equal(parse(ComputedGoto,'goto (1, 2 ,3) a+b(2)'),
@@ -63,29 +63,29 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(AssignedGoto,'goto a ( 1 )'),'GO TO a (1)')
         assert_equal(parse(AssignedGoto,'goto a ( 1 ,2)'),'GO TO a (1, 2)')
 
-    def check_continue(self):
+    def test_continue(self):
         assert_equal(parse(Continue,'continue'),'CONTINUE')
 
-    def check_return(self):
+    def test_return(self):
         assert_equal(parse(Return,'return'),'RETURN')
         assert_equal(parse(Return,'return a'),'RETURN a')
         assert_equal(parse(Return,'return a+1'),'RETURN a+1')
         assert_equal(parse(Return,'return a(c, a)'),'RETURN a(c, a)')
 
-    def check_stop(self):
+    def test_stop(self):
         assert_equal(parse(Stop,'stop'),'STOP')
         assert_equal(parse(Stop,'stop 1'),'STOP 1')
         assert_equal(parse(Stop,'stop "a"'),'STOP "a"')
         assert_equal(parse(Stop,'stop "a b"'),'STOP "a b"')
 
-    def check_print(self):
+    def test_print(self):
         assert_equal(parse(Print, 'print*'),'PRINT *')
         assert_equal(parse(Print, 'print "a b( c )"'),'PRINT "a b( c )"')
         assert_equal(parse(Print, 'print 12, a'),'PRINT 12, a')
         assert_equal(parse(Print, 'print 12, a , b'),'PRINT 12, a, b')
         assert_equal(parse(Print, 'print 12, a(c,1) , b'),'PRINT 12, a(c,1), b')
 
-    def check_read(self):
+    def test_read(self):
         assert_equal(parse(Read, 'read ( 10 )'),'READ (10)')
         assert_equal(parse(Read, 'read ( 10 ) a '),'READ (10) a')
         assert_equal(parse(Read, 'read ( 10 ) a , b'),'READ (10) a, b')
@@ -98,44 +98,44 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Read, 'read * , a  , b'),'READ *, a, b')
         assert_equal(parse(Read, 'read ( unit  =10 )'),'READ (UNIT = 10)')
 
-    def check_write(self):
+    def test_write(self):
         assert_equal(parse(Write, 'write ( 10 )'),'WRITE (10)')
         assert_equal(parse(Write, 'write ( 10 , a )'),'WRITE (10, a)')
         assert_equal(parse(Write, 'write ( 10 ) b'),'WRITE (10) b')
         assert_equal(parse(Write, 'write ( 10 ) a(1) , b+2'),'WRITE (10) a(1), b+2')
         assert_equal(parse(Write, 'write ( unit=10 )'),'WRITE (UNIT = 10)')
 
-    def check_flush(self):
+    def test_flush(self):
         assert_equal(parse(Flush, 'flush 10'),'FLUSH (10)')
         assert_equal(parse(Flush, 'flush (10)'),'FLUSH (10)')
         assert_equal(parse(Flush, 'flush (UNIT = 10)'),'FLUSH (UNIT = 10)')
         assert_equal(parse(Flush, 'flush (10, err=  23)'),'FLUSH (10, ERR = 23)')
 
-    def check_wait(self):
+    def test_wait(self):
         assert_equal(parse(Wait, 'wait(10)'),'WAIT (10)')
         assert_equal(parse(Wait, 'wait(10,err=129)'),'WAIT (10, ERR = 129)')
 
-    def check_contains(self):
+    def test_contains(self):
         assert_equal(parse(Contains, 'contains'),'CONTAINS')
 
-    def check_allocate(self):
+    def test_allocate(self):
         assert_equal(parse(Allocate, 'allocate (a)'), 'ALLOCATE (a)')
         assert_equal(parse(Allocate, \
                            'allocate (a, stat=b)'), 'ALLOCATE (a, STAT = b)')
         assert_equal(parse(Allocate, 'allocate (a,b(:1))'), 'ALLOCATE (a, b(:1))')
         assert_equal(parse(Allocate, \
                            'allocate (real(8)::a)'), 'ALLOCATE (REAL(KIND=8) :: a)')
-    def check_deallocate(self):
+    def test_deallocate(self):
         assert_equal(parse(Deallocate, 'deallocate (a)'), 'DEALLOCATE (a)')
         assert_equal(parse(Deallocate, 'deallocate (a, stat=b)'), 'DEALLOCATE (a, STAT = b)')
 
-    def check_moduleprocedure(self):
+    def test_moduleprocedure(self):
         assert_equal(parse(ModuleProcedure,\
                            'ModuleProcedure a'), 'MODULE PROCEDURE a')
         assert_equal(parse(ModuleProcedure,\
                            'module procedure a , b'), 'MODULE PROCEDURE a, b')
 
-    def check_access(self):
+    def test_access(self):
         assert_equal(parse(Public,'Public'),'PUBLIC')
         assert_equal(parse(Public,'public a'),'PUBLIC a')
         assert_equal(parse(Public,'public :: a'),'PUBLIC a')
@@ -144,45 +144,45 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Private,'private'),'PRIVATE')
         assert_equal(parse(Private,'private :: a'),'PRIVATE a')
 
-    def check_close(self):
+    def test_close(self):
         assert_equal(parse(Close,'close (12)'),'CLOSE (12)')
         assert_equal(parse(Close,'close (12, err=99)'),'CLOSE (12, ERR = 99)')
         assert_equal(parse(Close,'close (12, status = a(1,2))'),'CLOSE (12, STATUS = a(1,2))')
 
-    def check_cycle(self):
+    def test_cycle(self):
         assert_equal(parse(Cycle,'cycle'),'CYCLE')
         assert_equal(parse(Cycle,'cycle ab'),'CYCLE ab')
 
-    def check_rewind(self):
+    def test_rewind(self):
         assert_equal(parse(Rewind,'rewind 1'),'REWIND (1)')
         assert_equal(parse(Rewind,'rewind (1)'),'REWIND (1)')
         assert_equal(parse(Rewind,'rewind (1, err =  123)'),'REWIND (1, ERR = 123)')
 
-    def check_backspace(self):
+    def test_backspace(self):
         assert_equal(parse(Backspace,'backspace 1'),'BACKSPACE (1)')
         assert_equal(parse(Backspace,'backspace (1)'),'BACKSPACE (1)')
         assert_equal(parse(Backspace,'backspace (1, err =  123)'),'BACKSPACE (1, ERR = 123)')
 
-    def check_endfile(self):
+    def test_endfile(self):
         assert_equal(parse(Endfile,'endfile 1'),'ENDFILE (1)')
         assert_equal(parse(Endfile,'endfile (1)'),'ENDFILE (1)')
         assert_equal(parse(Endfile,'endfile (1, err =  123)'),'ENDFILE (1, ERR = 123)')
 
-    def check_open(self):
+    def test_open(self):
         assert_equal(parse(Open,'open (1)'),'OPEN (1)')
         assert_equal(parse(Open,'open (1, err =  123)'),'OPEN (1, ERR = 123)')
 
-    def check_format(self):
+    def test_format(self):
         assert_equal(parse(Format,'1: format ()'),'1: FORMAT ()')
         assert_equal(parse(Format,'199 format (1)'),'199: FORMAT (1)')
         assert_equal(parse(Format,'2 format (1 , SS)'),'2: FORMAT (1, ss)')
 
-    def check_save(self):
+    def test_save(self):
         assert_equal(parse(Save,'save'), 'SAVE')
         assert_equal(parse(Save,'save :: a'), 'SAVE a')
         assert_equal(parse(Save,'save a,b'), 'SAVE a, b')
 
-    def check_data(self):
+    def test_data(self):
         assert_equal(parse(Data,'data a /b/'), 'DATA a / b /')
         assert_equal(parse(Data,'data a , c /b/'), 'DATA a, c / b /')
         assert_equal(parse(Data,'data a /b ,c/'), 'DATA a / b, c /')
@@ -190,11 +190,11 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Data,'data a(1,2) /b/'), 'DATA a(1,2) / b /')
         assert_equal(parse(Data,'data a /b, c(1)/'), 'DATA a / b, c(1) /')
 
-    def check_nullify(self):
+    def test_nullify(self):
         assert_equal(parse(Nullify,'nullify(a)'),'NULLIFY (a)')
         assert_equal(parse(Nullify,'nullify(a  ,b)'),'NULLIFY (a, b)')
 
-    def check_use(self):
+    def test_use(self):
         assert_equal(parse(Use, 'use a'), 'USE a')
         assert_equal(parse(Use, 'use :: a'), 'USE a')
         assert_equal(parse(Use, 'use, intrinsic:: a'), 'USE INTRINSIC :: a')
@@ -205,79 +205,79 @@ class TestStatements(NumpyTestCase):
                            'use :: a , only: operator(+) , b'),\
                      'USE a, ONLY: operator(+), b')
 
-    def check_exit(self):
+    def test_exit(self):
         assert_equal(parse(Exit,'exit'),'EXIT')
         assert_equal(parse(Exit,'exit ab'),'EXIT ab')
 
-    def check_parameter(self):
+    def test_parameter(self):
         assert_equal(parse(Parameter,'parameter (a = b(1,2))'),
                      'PARAMETER (a = b(1,2))')
         assert_equal(parse(Parameter,'parameter (a = b(1,2) , b=1)'),
                      'PARAMETER (a = b(1,2), b=1)')
 
-    def check_equivalence(self):
+    def test_equivalence(self):
         assert_equal(parse(Equivalence,'equivalence (a , b)'),'EQUIVALENCE (a, b)')
         assert_equal(parse(Equivalence,'equivalence (a , b) , ( c, d(1) , g  )'),
                      'EQUIVALENCE (a, b), (c, d(1), g)')
 
-    def check_dimension(self):
+    def test_dimension(self):
         assert_equal(parse(Dimension,'dimension a(b)'),'DIMENSION a(b)')
         assert_equal(parse(Dimension,'dimension::a(b)'),'DIMENSION a(b)')
         assert_equal(parse(Dimension,'dimension a(b)  , c(d)'),'DIMENSION a(b), c(d)')
         assert_equal(parse(Dimension,'dimension a(b,c)'),'DIMENSION a(b,c)')
 
-    def check_target(self):
+    def test_target(self):
         assert_equal(parse(Target,'target a(b)'),'TARGET a(b)')
         assert_equal(parse(Target,'target::a(b)'),'TARGET a(b)')
         assert_equal(parse(Target,'target a(b)  , c(d)'),'TARGET a(b), c(d)')
         assert_equal(parse(Target,'target a(b,c)'),'TARGET a(b,c)')
 
-    def check_pointer(self):
+    def test_pointer(self):
         assert_equal(parse(Pointer,'pointer a=b'),'POINTER a=b')
         assert_equal(parse(Pointer,'pointer :: a=b'),'POINTER a=b')
         assert_equal(parse(Pointer,'pointer a=b, c=d(1,2)'),'POINTER a=b, c=d(1,2)')
 
-    def check_protected(self):
+    def test_protected(self):
         assert_equal(parse(Protected,'protected a'),'PROTECTED a')
         assert_equal(parse(Protected,'protected::a'),'PROTECTED a')
         assert_equal(parse(Protected,'protected a , b'),'PROTECTED a, b')
 
-    def check_volatile(self):
+    def test_volatile(self):
         assert_equal(parse(Volatile,'volatile a'),'VOLATILE a')
         assert_equal(parse(Volatile,'volatile::a'),'VOLATILE a')
         assert_equal(parse(Volatile,'volatile a , b'),'VOLATILE a, b')
 
-    def check_value(self):
+    def test_value(self):
         assert_equal(parse(Value,'value a'),'VALUE a')
         assert_equal(parse(Value,'value::a'),'VALUE a')
         assert_equal(parse(Value,'value a , b'),'VALUE a, b')
 
-    def check_arithmeticif(self):
+    def test_arithmeticif(self):
         assert_equal(parse(ArithmeticIf,'if (a) 1,2,3'),'IF (a) 1, 2, 3')
         assert_equal(parse(ArithmeticIf,'if (a(1)) 1,2,3'),'IF (a(1)) 1, 2, 3')
         assert_equal(parse(ArithmeticIf,'if (a(1,2)) 1,2,3'),'IF (a(1,2)) 1, 2, 3')
 
-    def check_intrinsic(self):
+    def test_intrinsic(self):
         assert_equal(parse(Intrinsic,'intrinsic a'),'INTRINSIC a')
         assert_equal(parse(Intrinsic,'intrinsic::a'),'INTRINSIC a')
         assert_equal(parse(Intrinsic,'intrinsic a , b'),'INTRINSIC a, b')
 
-    def check_inquire(self):
+    def test_inquire(self):
         assert_equal(parse(Inquire, 'inquire (1)'),'INQUIRE (1)')
         assert_equal(parse(Inquire, 'inquire (1, err=123)'),'INQUIRE (1, ERR = 123)')
         assert_equal(parse(Inquire, 'inquire (iolength=a) b'),'INQUIRE (IOLENGTH = a) b')
         assert_equal(parse(Inquire, 'inquire (iolength=a) b  ,c(1,2)'),
                      'INQUIRE (IOLENGTH = a) b, c(1,2)')
 
-    def check_sequence(self):
+    def test_sequence(self):
         assert_equal(parse(Sequence, 'sequence'),'SEQUENCE')
 
-    def check_external(self):
+    def test_external(self):
         assert_equal(parse(External,'external a'),'EXTERNAL a')
         assert_equal(parse(External,'external::a'),'EXTERNAL a')
         assert_equal(parse(External,'external a , b'),'EXTERNAL a, b')
 
-    def check_common(self):
+    def test_common(self):
         assert_equal(parse(Common, 'common a'),'COMMON a')
         assert_equal(parse(Common, 'common a , b'),'COMMON a, b')
         assert_equal(parse(Common, 'common a , b(1,2)'),'COMMON a, b(1,2)')
@@ -289,18 +289,18 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Common, 'common / name/ a, /foo/ c(1) ,d'),
                      'COMMON / name / a / foo / c(1), d')
 
-    def check_optional(self):
+    def test_optional(self):
         assert_equal(parse(Optional,'optional a'),'OPTIONAL a')
         assert_equal(parse(Optional,'optional::a'),'OPTIONAL a')
         assert_equal(parse(Optional,'optional a , b'),'OPTIONAL a, b')
 
-    def check_intent(self):
+    def test_intent(self):
         assert_equal(parse(Intent,'intent (in) a'),'INTENT (IN) a')
         assert_equal(parse(Intent,'intent(in)::a'),'INTENT (IN) a')
         assert_equal(parse(Intent,'intent(in) a , b'),'INTENT (IN) a, b')
         assert_equal(parse(Intent,'intent (in, out) a'),'INTENT (IN, OUT) a')
 
-    def check_entry(self):
+    def test_entry(self):
         assert_equal(parse(Entry,'entry a'), 'ENTRY a')
         assert_equal(parse(Entry,'entry a()'), 'ENTRY a')
         assert_equal(parse(Entry,'entry a(b)'), 'ENTRY a (b)')
@@ -315,13 +315,13 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Entry,'entry a(b,*) result (g)'),
                      'ENTRY a (b, *) RESULT (g)')
 
-    def check_import(self):
+    def test_import(self):
         assert_equal(parse(Import,'import'),'IMPORT')
         assert_equal(parse(Import,'import a'),'IMPORT a')
         assert_equal(parse(Import,'import::a'),'IMPORT a')
         assert_equal(parse(Import,'import a , b'),'IMPORT a, b')
 
-    def check_forall(self):
+    def test_forall(self):
         assert_equal(parse(ForallStmt,'forall (i = 1:n(k,:) : 2) a(i) = i*i*b(i)'),
                      'FORALL (i = 1 : n(k,:) : 2) a(i) = i*i*b(i)')
         assert_equal(parse(ForallStmt,'forall (i=1:n,j=2:3) a(i) = b(i,i)'),
@@ -329,7 +329,7 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(ForallStmt,'forall (i=1:n,j=2:3, 1+a(1,2)) a(i) = b(i,i)'),
                      'FORALL (i = 1 : n, j = 2 : 3, 1+a(1,2)) a(i) = b(i,i)')
 
-    def check_specificbinding(self):
+    def test_specificbinding(self):
         assert_equal(parse(SpecificBinding,'procedure a'),'PROCEDURE a')
         assert_equal(parse(SpecificBinding,'procedure :: a'),'PROCEDURE a')
         assert_equal(parse(SpecificBinding,'procedure , NOPASS :: a'),'PROCEDURE , NOPASS :: a')
@@ -343,29 +343,29 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(SpecificBinding,'procedure(n),pass :: a =>c'),
                      'PROCEDURE (n) , PASS :: a => c')
 
-    def check_genericbinding(self):
+    def test_genericbinding(self):
         assert_equal(parse(GenericBinding,'generic :: a=>b'),'GENERIC :: a => b')
         assert_equal(parse(GenericBinding,'generic, public :: a=>b'),'GENERIC, PUBLIC :: a => b')
         assert_equal(parse(GenericBinding,'generic, public :: a(1,2)=>b ,c'),
                      'GENERIC, PUBLIC :: a(1,2) => b, c')
 
-    def check_finalbinding(self):
+    def test_finalbinding(self):
         assert_equal(parse(FinalBinding,'final a'),'FINAL a')
         assert_equal(parse(FinalBinding,'final::a'),'FINAL a')
         assert_equal(parse(FinalBinding,'final a , b'),'FINAL a, b')
 
-    def check_allocatable(self):
+    def test_allocatable(self):
         assert_equal(parse(Allocatable,'allocatable a'),'ALLOCATABLE a')
         assert_equal(parse(Allocatable,'allocatable :: a'),'ALLOCATABLE a')
         assert_equal(parse(Allocatable,'allocatable a (1,2)'),'ALLOCATABLE a (1,2)')
         assert_equal(parse(Allocatable,'allocatable a (1,2) ,b'),'ALLOCATABLE a (1,2), b')
 
-    def check_asynchronous(self):
+    def test_asynchronous(self):
         assert_equal(parse(Asynchronous,'asynchronous a'),'ASYNCHRONOUS a')
         assert_equal(parse(Asynchronous,'asynchronous::a'),'ASYNCHRONOUS a')
         assert_equal(parse(Asynchronous,'asynchronous a , b'),'ASYNCHRONOUS a, b')
 
-    def check_bind(self):
+    def test_bind(self):
         assert_equal(parse(Bind,'bind(c) a'),'BIND (C) a')
         assert_equal(parse(Bind,'bind(c) :: a'),'BIND (C) a')
         assert_equal(parse(Bind,'bind(c) a ,b'),'BIND (C) a, b')
@@ -373,13 +373,13 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Bind,'bind(c) /a/ ,b'),'BIND (C) / a /, b')
         assert_equal(parse(Bind,'bind(c,name="hey") a'),'BIND (C, NAME = "hey") a')
 
-    def check_else(self):
+    def test_else(self):
         assert_equal(parse(Else,'else'),'ELSE')
         assert_equal(parse(ElseIf,'else if (a) then'),'ELSE IF (a) THEN')
         assert_equal(parse(ElseIf,'else if (a.eq.b(1,2)) then'),
                      'ELSE IF (a.eq.b(1,2)) THEN')
 
-    def check_case(self):
+    def test_case(self):
         assert_equal(parse(Case,'case (1)'),'CASE ( 1 )')
         assert_equal(parse(Case,'case (1:)'),'CASE ( 1 : )')
         assert_equal(parse(Case,'case (:1)'),'CASE ( : 1 )')
@@ -391,56 +391,56 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Case,'case (a(1,:):)'),'CASE ( a(1,:) : )')
         assert_equal(parse(Case,'case default'),'CASE DEFAULT')
 
-    def check_where(self):
+    def test_where(self):
         assert_equal(parse(WhereStmt,'where (1) a=1'),'WHERE ( 1 ) a = 1')
         assert_equal(parse(WhereStmt,'where (a(1,2)) a=1'),'WHERE ( a(1,2) ) a = 1')
 
-    def check_elsewhere(self):
+    def test_elsewhere(self):
         assert_equal(parse(ElseWhere,'else where'),'ELSE WHERE')
         assert_equal(parse(ElseWhere,'elsewhere (1)'),'ELSE WHERE ( 1 )')
         assert_equal(parse(ElseWhere,'elsewhere(a(1,2))'),'ELSE WHERE ( a(1,2) )')
 
-    def check_enumerator(self):
+    def test_enumerator(self):
         assert_equal(parse(Enumerator,'enumerator a'), 'ENUMERATOR a')
         assert_equal(parse(Enumerator,'enumerator:: a'), 'ENUMERATOR a')
         assert_equal(parse(Enumerator,'enumerator a,b'), 'ENUMERATOR a, b')
         assert_equal(parse(Enumerator,'enumerator a=1'), 'ENUMERATOR a=1')
         assert_equal(parse(Enumerator,'enumerator a=1 , b=c(1,2)'), 'ENUMERATOR a=1, b=c(1,2)')
 
-    def check_fortranname(self):
+    def test_fortranname(self):
         assert_equal(parse(FortranName,'fortranname a'),'FORTRANNAME a')
 
-    def check_threadsafe(self):
+    def test_threadsafe(self):
         assert_equal(parse(Threadsafe,'threadsafe'),'THREADSAFE')
 
-    def check_depend(self):
+    def test_depend(self):
         assert_equal(parse(Depend,'depend( a) b'), 'DEPEND ( a ) b')
         assert_equal(parse(Depend,'depend( a) ::b'), 'DEPEND ( a ) b')
         assert_equal(parse(Depend,'depend( a,c) b,e'), 'DEPEND ( a, c ) b, e')
 
-    def check_check(self):
+    def test_check(self):
         assert_equal(parse(Check,'check(1) a'), 'CHECK ( 1 ) a')
         assert_equal(parse(Check,'check(1) :: a'), 'CHECK ( 1 ) a')
         assert_equal(parse(Check,'check(b(1,2)) a'), 'CHECK ( b(1,2) ) a')
         assert_equal(parse(Check,'check(a>1) :: a'), 'CHECK ( a>1 ) a')
 
-    def check_callstatement(self):
+    def test_callstatement(self):
         assert_equal(parse(CallStatement,'callstatement (*func)()',isstrict=1),
                      'CALLSTATEMENT (*func)()')
         assert_equal(parse(CallStatement,'callstatement i=1;(*func)()',isstrict=1),
                      'CALLSTATEMENT i=1;(*func)()')
 
-    def check_callprotoargument(self):
+    def test_callprotoargument(self):
         assert_equal(parse(CallProtoArgument,'callprotoargument int(*), double'),
                      'CALLPROTOARGUMENT int(*), double')
 
-    def check_pause(self):
+    def test_pause(self):
         assert_equal(parse(Pause,'pause'),'PAUSE')
         assert_equal(parse(Pause,'pause 1'),'PAUSE 1')
         assert_equal(parse(Pause,'pause "hey"'),'PAUSE "hey"')
         assert_equal(parse(Pause,'pause "hey pa"'),'PAUSE "hey pa"')
 
-    def check_integer(self):
+    def test_integer(self):
         assert_equal(parse(Integer,'integer'),'INTEGER')
         assert_equal(parse(Integer,'integer*4'),'INTEGER*4')
         assert_equal(parse(Integer,'integer*4 a'),'INTEGER*4 a')
@@ -460,7 +460,7 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Integer,'integer(kind=2+2)'),'INTEGER(KIND=2+2)')
         assert_equal(parse(Integer,'integer(kind=f(4,5))'),'INTEGER(KIND=f(4,5))')
 
-    def check_character(self):
+    def test_character(self):
         assert_equal(parse(Character,'character'),'CHARACTER')
         assert_equal(parse(Character,'character*2'),'CHARACTER(LEN=2)')
         assert_equal(parse(Character,'character**'),'CHARACTER(LEN=*)')
@@ -482,7 +482,7 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Character,'character(len=3,kind=fA(1,2))'),
                      'CHARACTER(LEN=3, KIND=fa(1,2))')
 
-    def check_implicit(self):
+    def test_implicit(self):
         assert_equal(parse(Implicit,'implicit none'),'IMPLICIT NONE')
         assert_equal(parse(Implicit,'implicit'),'IMPLICIT NONE')
         assert_equal(parse(Implicit,'implicit integer (i-m)'),
@@ -492,5 +492,6 @@ class TestStatements(NumpyTestCase):
         assert_equal(parse(Implicit,'implicit integer (i-m), real (z)'),
                      'IMPLICIT INTEGER ( i-m ), REAL ( z )')
 
+
 if __name__ == "__main__":
-    NumpyTest().run()
+    nose.run(argv=['', __file__])