118 lines
3.5 KiB
Python
118 lines
3.5 KiB
Python
import pytest
|
|
from src.basic_data_handling.int_nodes import (
|
|
IntAdd,
|
|
IntSubtract,
|
|
IntMultiply,
|
|
IntDivide,
|
|
IntDivideSafe,
|
|
IntModulus,
|
|
IntPower,
|
|
IntBitLength,
|
|
IntToBytes,
|
|
IntFromBytes,
|
|
IntBitCount,
|
|
IntCreate,
|
|
IntCreateWithBase,
|
|
)
|
|
|
|
|
|
def test_int_add():
|
|
node = IntAdd()
|
|
assert node.add(10, 5) == (15,)
|
|
assert node.add(-10, 5) == (-5,)
|
|
assert node.add(0, 0) == (0,)
|
|
|
|
|
|
def test_int_subtract():
|
|
node = IntSubtract()
|
|
assert node.subtract(10, 5) == (5,)
|
|
assert node.subtract(5, 10) == (-5,)
|
|
assert node.subtract(0, 0) == (0,)
|
|
|
|
|
|
def test_int_multiply():
|
|
node = IntMultiply()
|
|
assert node.multiply(10, 5) == (50,)
|
|
assert node.multiply(-1, 5) == (-5,)
|
|
assert node.multiply(0, 5) == (0,)
|
|
|
|
|
|
def test_int_divide():
|
|
node = IntDivide()
|
|
assert node.divide(10, 2) == (5,)
|
|
assert node.divide(9, 4) == (2,) # Integer division
|
|
with pytest.raises(ValueError, match="Cannot divide by zero."):
|
|
node.divide(10, 0)
|
|
|
|
|
|
def test_int_modulus():
|
|
node = IntModulus()
|
|
assert node.modulus(10, 3) == (1,)
|
|
assert node.modulus(9, 9) == (0,)
|
|
with pytest.raises(ValueError, match="Cannot perform modulus operation by zero."):
|
|
node.modulus(10, 0)
|
|
|
|
|
|
def test_int_power():
|
|
node = IntPower()
|
|
assert node.power(2, 3) == (8,)
|
|
assert node.power(10, 0) == (1,) # Any number to the power 0 is 1
|
|
assert node.power(-2, 3) == (-8,)
|
|
|
|
|
|
def test_int_bit_length():
|
|
node = IntBitLength()
|
|
assert node.bit_length(0) == (0,) # Zero requires 0 bits
|
|
assert node.bit_length(1) == (1,)
|
|
assert node.bit_length(255) == (8,) # 255 requires 8 bits
|
|
assert node.bit_length(-255) == (8,) # Negative numbers have the same bit length
|
|
|
|
|
|
def test_int_to_bytes():
|
|
node = IntToBytes()
|
|
assert node.to_bytes(255, 2, "big", "False") == (b"\x00\xff",)
|
|
assert node.to_bytes(255, 2, "little", "False") == (b"\xff\x00",)
|
|
assert node.to_bytes(-255, 2, "big", "True") == (b"\xff\x01",)
|
|
|
|
|
|
def test_int_from_bytes():
|
|
node = IntFromBytes()
|
|
assert node.from_bytes(b"\x00\xff", "big", "False") == (255,)
|
|
assert node.from_bytes(b"\xff\x00", "little", "False") == (255,)
|
|
assert node.from_bytes(b"\xff\x01", "big", "True") == (-255,)
|
|
|
|
|
|
def test_int_bit_count():
|
|
node = IntBitCount()
|
|
assert node.bit_count(0) == (0,) # Zero has no 1 bits
|
|
assert node.bit_count(255) == (8,) # 255 is 11111111 (8 ones)
|
|
assert node.bit_count(-255) == (8,) # Negative integer has the same bit count
|
|
|
|
|
|
def test_int_create():
|
|
node = IntCreate()
|
|
assert node.create("42") == (42,)
|
|
assert node.create("-100") == (-100,)
|
|
assert node.create("0") == (0,)
|
|
assert node.create("0xFF") == (255,) # Hexadecimal
|
|
assert node.create("0b1010") == (10,) # Binary
|
|
assert node.create("0o777") == (511,) # Octal
|
|
|
|
|
|
def test_int_create_with_base():
|
|
node = IntCreateWithBase()
|
|
assert node.create("42", 10) == (42,)
|
|
assert node.create("FF", 16) == (255,)
|
|
assert node.create("1010", 2) == (10,)
|
|
assert node.create("777", 8) == (511,)
|
|
with pytest.raises(ValueError):
|
|
node.create("FF", 10) # Invalid characters for base 10
|
|
|
|
|
|
def test_int_divide_safe():
|
|
node = IntDivideSafe()
|
|
assert node.divide(10, 2, 9223372036854775807) == (5,)
|
|
assert node.divide(9, 4, 9223372036854775807) == (2,) # Integer division
|
|
assert node.divide(10, 0, 9223372036854775807) == (9223372036854775807,) # Positive infinity
|
|
assert node.divide(-10, 0, 9223372036854775807) == (-9223372036854775807,) # Negative infinity
|