7544055a94
This is because Haskell defines negate, abs and signum for Num, but they don't work with our unsigned number types. (abs would be a noop.) Haskell has Word32 / Word64, but there negate doesn't make much sense to me. Implemented neg and abs. Implemented a type class inheritance check. Removed Integral from u8 and i8 since it wasn't implemented.
174 lines
3.8 KiB
Python
174 lines
3.8 KiB
Python
import pytest
|
|
|
|
from phasm.type3.entry import Type3Exception
|
|
|
|
from ..helpers import Suite
|
|
|
|
INT_TYPES = ['u32', 'u64', 'i32', 'i64']
|
|
FLOAT_TYPES = ['f32', 'f64']
|
|
|
|
TYPE_MAP = {
|
|
'u32': int,
|
|
'u64': int,
|
|
'i32': int,
|
|
'i64': int,
|
|
'f32': float,
|
|
'f64': float,
|
|
}
|
|
|
|
@pytest.mark.integration_test
|
|
def test_addition_not_implemented():
|
|
code_py = """
|
|
class Foo:
|
|
val: i32
|
|
|
|
@exported
|
|
def testEntry(x: Foo, y: Foo) -> Foo:
|
|
return x + y
|
|
"""
|
|
|
|
with pytest.raises(Type3Exception, match='Foo does not implement the NatNum type class'):
|
|
Suite(code_py).run_code()
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', INT_TYPES)
|
|
def test_addition_int(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return 10 + 3
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 13 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', FLOAT_TYPES)
|
|
def test_addition_float(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return 32.0 + 0.125
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 32.125 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', INT_TYPES)
|
|
def test_subtraction_int(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return 10 - 3
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 7 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', FLOAT_TYPES)
|
|
def test_subtraction_float(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return 100.0 - 67.875
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 32.125 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
def test_subtraction_negative_result():
|
|
code_py = """
|
|
@exported
|
|
def testEntry() -> i32:
|
|
return 10 - 11
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert -1 == result.returned_value
|
|
|
|
@pytest.mark.integration_test
|
|
def test_subtraction_underflow():
|
|
code_py = """
|
|
@exported
|
|
def testEntry() -> u32:
|
|
return 10 - 11
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 4294967295 == result.returned_value
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', INT_TYPES)
|
|
def test_multiplication_int(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return 10 * 3
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 30 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', FLOAT_TYPES)
|
|
def test_multiplication_float(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return 32.0 * 0.125
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 4.0 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', INT_TYPES)
|
|
def test_call_with_expression_int(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return helper(10 + 20, 3 + 5)
|
|
|
|
def helper(left: {type_}, right: {type_}) -> {type_}:
|
|
return left - right
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 22 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|
|
|
|
@pytest.mark.integration_test
|
|
@pytest.mark.parametrize('type_', FLOAT_TYPES)
|
|
def test_call_with_expression_float(type_):
|
|
code_py = f"""
|
|
@exported
|
|
def testEntry() -> {type_}:
|
|
return helper(10.078125 + 90.046875, 63.0 + 5.0)
|
|
|
|
def helper(left: {type_}, right: {type_}) -> {type_}:
|
|
return left - right
|
|
"""
|
|
|
|
result = Suite(code_py).run_code()
|
|
|
|
assert 32.125 == result.returned_value
|
|
assert TYPE_MAP[type_] is type(result.returned_value)
|