/[escript]/trunk/escriptcore/test/python/test_util_base.py
ViewVC logotype

Diff of /trunk/escriptcore/test/python/test_util_base.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 6458 by jfenwick, Tue Jan 10 03:04:13 2017 UTC revision 6459 by jfenwick, Tue Jan 10 04:28:51 2017 UTC
# Line 877  class Test_util_values(unittest.TestCase Line 877  class Test_util_values(unittest.TestCase
877              ref=v[3]              ref=v[3]
878              oraclecheck=v[4]              oraclecheck=v[4]
879              description=v[5]              description=v[5]
880              with self.assertRaises(StandardError) as err:                expected_exceptions=v[6]
881                if expected_exceptions is None:
882                    expected_exceptions=(TypeError, RuntimeError)   # These are used for unsupported complex
883                with self.assertRaises(Exception) as err:  
884                  res=eval(op)                  res=eval(op)
885                    print("Succeeded in evaluating "+str(op))
886                    print("For a=")
887                    print(str(a))
888              # unfortunately, we don't return a single exception type in this case              # unfortunately, we don't return a single exception type in this case
889              self.assertTrue(isinstance(err.exception, TypeError) or isinstance(err.exception, RuntimeError), "Exception was raised but it was of unexpected type ("+str(type(err.exception))+")")              self.assertTrue(type(err.exception) in expected_exceptions, "Exception was raised but it was of unexpected type ("+str(type(err.exception))+")")
890            
891      def execute_t_params(self, pars):      def execute_t_params(self, pars):
892          for v in pars:          for v in pars:
893              description=v[0]              description=v[0]
894              a=v[1]              a=v[1]
895              tagcount=1              tagcount=1
896              for step in v[2:]:              for step in v[3:]:
897                  a.setTaggedValue(tagcount, step[0])                  a.setTaggedValue(tagcount, step[0])
898                  op=step[1]                  op=step[1]
899                  misccheck=step[2]                  misccheck=step[2]
# Line 923  class Test_util_values(unittest.TestCase Line 929  class Test_util_values(unittest.TestCase
929              description=v[0]              description=v[0]
930              a=v[1]              a=v[1]
931              tagcount=1              tagcount=1
932              for step in v[2:]:              expected_exceptions=v[2]
933                if expected_exceptions is None:
934                    expected_exceptions=(TypeError, RuntimeError)   # These are used for unsupported complex
935                for step in v[3:]:
936                  a.setTaggedValue(tagcount, step[0])                  a.setTaggedValue(tagcount, step[0])
937                  op=step[1]                  op=step[1]
938                  misccheck=step[2]                  misccheck=step[2]
939                  ref=step[3]                  ref=step[3]
940                  oraclecheck=step[4]                  oraclecheck=step[4]
941                  with self.assertRaises(StandardError) as err:                    with self.assertRaises(Exception) as err:  
942                      res=eval(op)                      res=eval(op)
943                  self.assertTrue(isinstance(err.exception, TypeError) or isinstance(err.exception, RuntimeError), "Exception was raised but it was of unexpected type ("+str(type(err.exception))+")")                                  self.assertTrue(type(err.exception) in expected_exceptions, "Exception was raised but it was of unexpected type ("+str(type(err.exception))+")")                
944                  tagcount+=1                  tagcount+=1
945    
946      def generate_operation_test_batch(self, supportcplx, opstring, misccheck, oraclecheck, opname, update1, update2, input_trans=None, data_only=False, multisteptag=True, minrank=0, maxrank=4):      def generate_operation_test_batch(self, supportcplx, opstring, misccheck, oraclecheck, opname, update1, update2, input_trans=None, data_only=False, multisteptag=True, minrank=0, maxrank=4,
947                                          expect_raise_on_ranks=None, expected_exceptions=None):
948          """          """
949          supportcplx is a boolean indicating whether complex operations should be checked for values (True)          supportcplx is a boolean indicating whether complex operations should be checked for values (True)
950               or tested to see if they raise (False)               or tested to see if they raise (False)
# Line 950  class Test_util_values(unittest.TestCase Line 960  class Test_util_values(unittest.TestCase
960          """          """
961          if input_trans is None:          if input_trans is None:
962              input_trans=lambda x: x              input_trans=lambda x: x
963            if expect_raise_on_ranks is None:
964                expect_raise_on_ranks=()
965          pars=[]          pars=[]
966          epars=[]    # operations which should throw          epars=[]    # operations which should throw
967          if not data_only:          if not data_only:
968              (f1,f2)=self.get_scalar_input1(False)              (f1,f2)=self.get_scalar_input1(False)
969              f1=input_trans(f1)              f1=input_trans(f1)
970              f2=input_trans(f2)              f2=input_trans(f2)
971              pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - scalar"))              pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - scalar", expected_exceptions))
972              if supportcplx:              if supportcplx:
973                  (f1,f2)=self.get_scalar_input1(True)                  (f1,f2)=self.get_scalar_input1(True)
974                  f1=input_trans(f1)                  f1=input_trans(f1)
975                  f2=input_trans(f2)                  f2=input_trans(f2)
976                  pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar"))                  pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar",expected_exceptions))
977              else:              else:
978                  (f1,f2)=self.get_scalar_input1(True)                  (f1,f2)=self.get_scalar_input1(True)
979                  f1=input_trans(f1)                  f1=input_trans(f1)
980                  f2=input_trans(f2)                                  f2=input_trans(f2)                
981                  epars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar"))                  epars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar", expected_exceptions))
982          for c in (False, True):          for c in (False, True):
             dest=pars  
983              if c:              if c:
984                  cs="complex "                  cs="complex "
                 if not supportcplx:  
                     dest=epars  
985              else:              else:
986                  cs=""                  cs=""
987              for rank in range(minrank, maxrank+1):              for rank in range(minrank, maxrank+1):
988                    dest=pars
989                    if rank in expect_raise_on_ranks or (c and not supportcplx):
990                        dest=epars                
991                  if not data_only:                  if not data_only:
992                      (a, r)=self.get_array_input1(rank, c)                      (a, r)=self.get_array_input1(rank, c)
993                      a=input_trans(a)                      a=input_trans(a)
994                      r=input_trans(r)                      r=input_trans(r)
995                      p=(a, opstring, misccheck, numpy.array(r), oraclecheck, opname+" - "+cs+"array rank "+str(rank))                      p=(a, opstring, misccheck, numpy.array(r), oraclecheck, opname+" - "+cs+"array rank "+str(rank), expected_exceptions)
996                      dest.append(p)                      dest.append(p)
997                  (a, r)=self.get_const_input1(rank, self.functionspace, c)                  (a, r)=self.get_const_input1(rank, self.functionspace, c)
998                  a=input_trans(a)                  a=input_trans(a)
999                  r=input_trans(numpy.array(r))                                  r=input_trans(numpy.array(r))                
1000                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Constant Data rank "+str(rank))                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Constant Data rank "+str(rank), expected_exceptions)
1001                  dest.append(p)                  dest.append(p)
1002                  (a, r)=self.get_expanded_input1(rank, self.functionspace, c)                  (a, r)=self.get_expanded_input1(rank, self.functionspace, c)
1003                  a=input_trans(a)                  a=input_trans(a)
1004                  r=input_trans(numpy.array(r))                                  r=input_trans(numpy.array(r))                
1005                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Expanded Data rank "+str(rank))                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Expanded Data rank "+str(rank), expected_exceptions)
1006                  dest.append(p)                  dest.append(p)
1007          self.execute_ce_params(pars)          self.execute_ce_params(pars)
1008          self.execute_ce_throws(epars)          self.execute_ce_throws(epars)
# Line 999  class Test_util_values(unittest.TestCase Line 1011  class Test_util_values(unittest.TestCase
1011          tpars=[]    # tagged versions          tpars=[]    # tagged versions
1012          epars=[]          epars=[]
1013          for c in (False, True):          for c in (False, True):
             dest=tpars  
1014              if c:              if c:
1015                  cs="complex "                  cs="complex "
                 if not supportcplx:  
                     dest=epars                  
1016              else:              else:
1017                  cs=""                  cs=""
1018              for rank in range(minrank, maxrank+1):              for rank in range(minrank, maxrank+1):
1019                    dest=tpars
1020                    if rank in expect_raise_on_ranks or (c and not supportcplx):
1021                        dest=epars                
1022                  test=[opname+" - "+cs+"tagged rank "+str(rank),]                  test=[opname+" - "+cs+"tagged rank "+str(rank),]
1023                  (a, r)=self.get_tagged_input1(rank, self.functionspace, c)                  (a, r)=self.get_tagged_input1(rank, self.functionspace, c)
1024                  a=input_trans(a)                  a=input_trans(a)
1025                  r=input_trans(numpy.array(r))                                                  r=input_trans(numpy.array(r))                                
1026                  test.append(a)                  test.append(a)
1027                    test.append(expected_exceptions)
1028                  # arguments are new tagged value, operation, extra check, reference_value, reference_check                  # arguments are new tagged value, operation, extra check, reference_value, reference_check
1029                  (t2, r2)=self.get_array_input2(rank, c)                  (t2, r2)=self.get_array_input2(rank, c)
1030                  t2=input_trans(t2)                  t2=input_trans(t2)
# Line 1029  class Test_util_values(unittest.TestCase Line 1042  class Test_util_values(unittest.TestCase
1042          self.execute_t_throws(epars)                  self.execute_t_throws(epars)        
1043    
1044    
1045      def generate_operation_test_batch_large(self, supportcplx, opstring, misccheck, oraclecheck, opname, update1, update2, input_trans=None, data_only=False, multisteptag=True, minrank=0, maxrank=4):      def generate_operation_test_batch_large(self, supportcplx, opstring, misccheck, oraclecheck, opname, update1, update2, input_trans=None, data_only=False, multisteptag=True, minrank=0, maxrank=4, expect_raise_on_ranks=None, expected_exceptions=None):
1046          """          """
1047          (At time of writing) This is the same as generate_operation_test_batch but using          (At time of writing) This is the same as generate_operation_test_batch but using
1048          inputL to add some large (magnitude) values into the mix.          inputL to add some large (magnitude) values into the mix.
# Line 1047  class Test_util_values(unittest.TestCase Line 1060  class Test_util_values(unittest.TestCase
1060          """          """
1061          if input_trans is None:          if input_trans is None:
1062              input_trans=lambda x: x              input_trans=lambda x: x
1063            if expect_raise_on_ranks is None:
1064                expect_raise_on_ranks=()
1065          pars=[]          pars=[]
1066          epars=[]    # operations which should throw          epars=[]    # operations which should throw
1067          if not data_only:          if not data_only:
1068              (f1,f2)=self.get_scalar_inputL(False)              (f1,f2)=self.get_scalar_inputL(False)
1069              f1=input_trans(f1)              f1=input_trans(f1)
1070              f2=input_trans(f2)              f2=input_trans(f2)
1071              pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - scalar"))              pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - scalar", expected_exceptions))
1072              if supportcplx:              if supportcplx:
1073                  (f1,f2)=self.get_scalar_inputL(True)                  (f1,f2)=self.get_scalar_inputL(True)
1074                  f1=input_trans(f1)                  f1=input_trans(f1)
1075                  f2=input_trans(f2)                                  f2=input_trans(f2)                
1076                  pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar"))                  pars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar", expected_exceptions))
1077              else:              else:
1078                  (f1,f2)=self.get_scalar_inputL(True)                  (f1,f2)=self.get_scalar_inputL(True)
1079                  f1=input_trans(f1)                  f1=input_trans(f1)
1080                  f2=input_trans(f2)                                  f2=input_trans(f2)                
1081                  epars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar"))                  epars.append((f1, opstring, misccheck, numpy.array(f2), oraclecheck, opname+" - complex scalar", expected_exceptions))    
1082          for c in (False, True):          for c in (False, True):
1083              dest=pars              dest=pars
1084              if c:              if c:
1085                  cs="complex "                  cs="complex "
                 if not supportcplx:  
                     dest=epars  
1086              else:              else:
1087                  cs=""                  cs=""
1088              for rank in range(minrank, maxrank+1):              for rank in range(minrank, maxrank+1):
1089                    dest=pars
1090                    if rank in expect_raise_on_ranks or (c and not supportcplx):
1091                        dest=epars
1092                  if not data_only:                  if not data_only:
1093                      (a, r)=self.get_array_inputL(rank, c)                      (a, r)=self.get_array_inputL(rank, c)
1094                      a=input_trans(a)                      a=input_trans(a)
1095                      r=input_trans(r)                      r=input_trans(r)
1096                      p=(a, opstring, misccheck, numpy.array(r), oraclecheck, opname+" - "+cs+"array rank "+str(rank))                      p=(a, opstring, misccheck, numpy.array(r), oraclecheck, opname+" - "+cs+"array rank "+str(rank), expected_exceptions)
1097                      dest.append(p)                      dest.append(p)                  
1098                  (a, r)=self.get_const_inputL(rank, self.functionspace, c)                  (a, r)=self.get_const_inputL(rank, self.functionspace, c)
1099                  a=input_trans(a)                  a=input_trans(a)
1100                  r=input_trans(numpy.array(r))                                  r=input_trans(numpy.array(r))                
1101                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Constant Data rank "+str(rank))                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Constant Data rank "+str(rank), expected_exceptions)
1102                  dest.append(p)                  dest.append(p)
1103                  (a, r)=self.get_expanded_inputL(rank, self.functionspace, c)                  (a, r)=self.get_expanded_inputL(rank, self.functionspace, c)
1104                  a=input_trans(a)                  a=input_trans(a)
1105                  r=input_trans(numpy.array(r))                  r=input_trans(numpy.array(r))
1106                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Expanded Data rank "+str(rank))                  p=(a, opstring, misccheck, r, oraclecheck, opname+" - "+cs+"Expanded Data rank "+str(rank), expected_exceptions)
1107                  dest.append(p)                  dest.append(p)              
1108          self.execute_ce_params(pars)          self.execute_ce_params(pars)
1109          self.execute_ce_throws(epars)          self.execute_ce_throws(epars)
1110          del pars          del pars
# Line 1104  class Test_util_values(unittest.TestCase Line 1120  class Test_util_values(unittest.TestCase
1120              else:              else:
1121                  cs=""                              cs=""            
1122              for rank in range(minrank, maxrank+1):              for rank in range(minrank, maxrank+1):
1123                    dest=tpars
1124                    if rank in expect_raise_on_ranks or (c and not supportcplx):
1125                        dest=epars                
1126                  test=[opname+" - "+cs+"tagged rank "+str(rank),]                  test=[opname+" - "+cs+"tagged rank "+str(rank),]
1127                  (a, r)=self.get_tagged_input1(rank, self.functionspace, c)                  (a, r)=self.get_tagged_input1(rank, self.functionspace, c)
1128                  a=input_trans(a)                  a=input_trans(a)
1129                  r=input_trans(numpy.array(r))                                  r=input_trans(numpy.array(r))                
1130                  test.append(a)                  test.append(a)
1131                    test.append(expected_exceptions)                
1132                  # arguments are new tagged value, operation, extra check, reference_value, reference_check                  # arguments are new tagged value, operation, extra check, reference_value, reference_check
1133                  (t2, r2)=self.get_array_inputL(rank, c)                  (t2, r2)=self.get_array_inputL(rank, c)
1134                  t2=input_trans(t2)                  t2=input_trans(t2)

Legend:
Removed from v.6458  
changed lines
  Added in v.6459

  ViewVC Help
Powered by ViewVC 1.1.26