1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
"""
PC-BASIC test.session
unit tests for values.values
(c) 2020--2023 Rob Hagemans
This file is released under the GNU GPL version 3 or later.
"""
from pcbasic import Session
from pcbasic.basic.values import values
from pcbasic.basic.values.numbers import Integer, Single, Double
from pcbasic.basic.values.strings import String
from pcbasic.basic.base import error
from tests.unit.utils import TestCase, run_tests
class ValuesTest(TestCase):
"""Unit tests for values.values module."""
tag = u'values'
def test_pass_number(self):
"""Test pass_number()."""
vm = values.Values(None, False)
i = vm.new_integer()
s = vm.new_string()
assert values.pass_number(i) == i
with self.assertRaises(error.BASICError):
values.pass_number(s)
with self.assertRaises(TypeError):
values.pass_number(None)
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_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_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_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_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_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_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_float_error_handler_soft_double(self):
"""Test FloatErrorHandler."""
class MockConsole(object):
def write_line(self, s):
pass
vm = values.Values(None, double_math=True)
vm.set_handler(values.FloatErrorHandler(MockConsole()))
# overflowerror *is* handled
def ovflerr(x):
e = OverflowError()
raise e
one = vm.new_double().from_int(1)
result = values._call_float_function(ovflerr, one)
assert isinstance(result, Double)
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_pow_double(self):
"""Test a^b with double-precision values."""
vm = values.Values(None, double_math=True)
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), Double)
assert isinstance(values.pow(d, i), Double)
assert isinstance(values.pow(s, d), Double)
assert isinstance(values.pow(d, s), Double)
assert isinstance(values.pow(s, s), Single)
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_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_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')
with self.assertRaises(ValueError):
vm.new_single().from_token(b'abc')
with self.assertRaises(ValueError):
vm.new_double().from_token(b'abc')
def test_integer_ineg(self):
"""Test in-place negate operations on integers."""
vm = values.Values(None, double_math=False)
zero = vm.new_integer().from_int(0)
one = vm.new_integer().from_int(1)
neg_one = vm.new_integer().from_int(-1)
assert vm.new_integer().from_int(1).ineg().eq(neg_one)
assert vm.new_integer().from_int(0).ineg().eq(zero)
assert vm.new_integer().from_int(-1).ineg().eq(one)
# overflow -(-32768)
with self.assertRaises(error.BASICError):
vm.new_integer().from_int(-32768).ineg()
def test_integer_iabs(self):
"""Test in-place absolute operations on integers."""
vm = values.Values(None, double_math=False)
zero = vm.new_integer().from_int(0)
one = vm.new_integer().from_int(1)
neg_one = vm.new_integer().from_int(-1)
assert one.iabs().eq(vm.new_integer().from_int(1))
assert zero.iabs().eq(vm.new_integer().from_int(0))
assert neg_one.iabs().eq(vm.new_integer().from_int(1))
def test_integer_isub(self):
"""Test in-place subtract operations on integers."""
vm = values.Values(None, double_math=False)
zero = vm.new_integer().from_int(0)
one = vm.new_integer().from_int(1)
neg_one = vm.new_integer().from_int(-1)
assert one.isub(one).eq(zero)
assert neg_one.isub(neg_one).eq(zero)
assert vm.new_integer().from_int(0).isub(vm.new_integer().from_int(-1)).eq(vm.new_integer().from_int(1))
assert vm.new_integer().from_int(0).isub(vm.new_integer().from_int(1)).eq(vm.new_integer().from_int(-1))
assert vm.new_integer().from_int(1).isub(vm.new_integer().from_int(-1)).to_int() == 2
def test_integer_comparisons(self):
"""Test comparison operations on integers."""
vm = values.Values(None, double_math=False)
zero = vm.new_integer().from_int(0)
one = vm.new_integer().from_int(1)
neg_one = vm.new_integer().from_int(-1)
twobyte = vm.new_integer().from_int(256)
assert one.gt(zero)
assert zero.gt(neg_one)
assert not neg_one.gt(zero)
assert twobyte.gt(one)
assert not one.gt(twobyte)
assert one.eq(vm.new_integer().from_int(1))
def test_integer_float_comparisons(self):
"""Test comparison operations between integers and floats."""
vm = values.Values(None, double_math=False)
zero = vm.new_integer().from_int(0)
one = vm.new_integer().from_int(1)
neg_one = vm.new_integer().from_int(-1)
d_zero = vm.new_double().from_int(0)
s_zero = vm.new_single().from_int(0)
assert zero.eq(d_zero)
assert zero.eq(s_zero)
assert one.gt(d_zero)
assert one.gt(s_zero)
def test_float_idiv(self):
"""Test in-place divide operations on floats."""
vm = values.Values(None, double_math=False)
four = vm.new_single().from_int(4)
two = vm.new_single().from_int(2)
zero = vm.new_single().from_int(0)
assert four.idiv(two).eq(two)
assert zero.idiv(two).eq(vm.new_single().from_int(0))
def test_float_ipow_int(self):
"""Test in-place power operation on floats."""
vm = values.Values(None, double_math=False)
four = vm.new_single().from_int(4)
zero = vm.new_single().from_int(0)
assert four.ipow_int(zero).to_value() == 1.
def test_float_comparisons(self):
"""Test comparison operations between floats and other types."""
vm = values.Values(None, double_math=False)
zero = vm.new_integer().from_int(0)
s_one = vm.new_single().from_int(1)
neg_one = vm.new_integer().from_int(-1)
d_zero = vm.new_double().from_int(0)
s_zero = vm.new_single().from_int(0)
assert s_zero.eq(zero)
assert s_zero.eq(s_zero)
assert s_zero.eq(d_zero)
assert s_one.gt(zero)
assert s_one.gt(s_zero)
assert s_one.gt(d_zero)
# string representations of floats
def test_from_decimal_repr(self):
"""Test converting bytes string in decimal representation to float."""
assert values.numbers.str_to_decimal(b'1.0e2a', allow_nonnum=True) == (False, 10, 1)
with self.assertRaises(ValueError):
values.numbers.str_to_decimal(b'1.0e2a', allow_nonnum=False)
assert values.numbers.str_to_decimal(b'x.0e2', allow_nonnum=True) == (False, 0, 0)
with self.assertRaises(ValueError):
values.numbers.str_to_decimal(b'x.0e2', allow_nonnum=False)
def test_to_decimal_repr(self):
"""Test converting float to bytes string in decimal representation."""
vm = values.Values(None, double_math=False)
one = vm.new_single().from_int(1)
assert one.to_decimal(digits=0) == (0, 1)
assert vm.new_single().from_value(1e-5).to_decimal(7) == (1000000, -11)
assert vm.new_single().from_value(1e38).to_decimal(7) == (1000000, 32)
def test_to_fixed_repr(self):
"""Test converting float to bytes string in fixed-point representation."""
vm = values.Values(None, double_math=False)
assert vm.new_single().from_value(0).to_str_fixed(3, False, False) == b'000'
if __name__ == '__main__':
run_tests()
|
