def test_to_type_errors(self): """Test to_type() error cases.""" vm = values.Values(None, False) s = vm.new_string() with self.assertRaises(TypeError): values.to_repr(None, True, True) with self.assertRaises(error.BASICError): values.to_repr(s, True, True)
def test_from_token_errors(self): """Test from_token error cases.""" vm = values.Values(None, True) with self.assertRaises(ValueError): # no token vm.from_token(None) with self.assertRaises(ValueError): # not a number token vm.from_token(b'\0\0')
def test_call_float_function_errors(self): """Test call_float_function error cases.""" vm = values.Values(None, False) vm.set_handler(values.FloatErrorHandler(None)) def itimes(x): return complex(0, x) with self.assertRaises(error.BASICError): values._call_float_function(itimes, vm.new_single().from_int(1))
def test_pass_string(self): """Test pass_string().""" vm = values.Values(None, False) i = vm.new_integer() s = vm.new_string() assert values.pass_string(s) == s with self.assertRaises(error.BASICError): values.pass_string(i) with self.assertRaises(TypeError): values.pass_string(None)
def test_float_error_handler_errors(self): """Test FloatErrorHandler error cases.""" vm = values.Values(None, False) vm.set_handler(values.FloatErrorHandler(None)) # use an exception class not supported by FloatErrorHandler def typerr(x): raise TypeError() with self.assertRaises(TypeError): values._call_float_function(typerr, vm.new_single().from_int(1))
def test_match_types_errors(self): """Test match_types() error cases.""" vm = values.Values(None, False) i = vm.new_integer() s = vm.new_string() with self.assertRaises(error.BASICError): values.match_types(s, i) with self.assertRaises(TypeError): values.match_types(s, None) with self.assertRaises(TypeError): values.match_types(None, None)
def test_repr(self): """Test representation.""" vm = values.Values(None, double_math=False) i = vm.new_integer().from_int(1) s = vm.new_single().from_int(1) d = vm.new_double().from_int(1) st = vm.new_string() assert isinstance(repr(i), type('')) assert isinstance(repr(s), type('')) assert isinstance(repr(d), type('')) assert isinstance(repr(st), type(''))
def test_pow_single(self): """Test a^b with double-precision values but -d not set.""" vm = values.Values(None, double_math=False) i = vm.new_integer().from_int(1) s = vm.new_single().from_int(1) d = vm.new_double().from_int(1) assert isinstance(values.pow(i, d), Single) assert isinstance(values.pow(d, i), Single) assert isinstance(values.pow(s, d), Single) assert isinstance(values.pow(d, s), Single) assert isinstance(values.pow(s, s), Single)
def test_float_error_handler_soft(self): """Test FloatErrorHandler.""" class MockConsole(object): def write_line(self, s): pass vm = values.Values(None, double_math=False) vm.set_handler(values.FloatErrorHandler(MockConsole())) # overflowerror *is* handled def ovflerr(x): e = OverflowError() raise e assert isinstance( values._call_float_function(ovflerr, vm.new_double().from_int(1)), Single)
def test_to_repr_errors(self): """Test to_repr() error cases.""" vm = values.Values(None, False) i = vm.new_integer() with self.assertRaises(ValueError): values.to_type("&", i)
def test_integer_from_token_error(self): """Test Integer.from_token().""" vm = values.Values(None, double_math=False) with self.assertRaises(ValueError): vm.new_integer().from_token(b'abc')