def test_min_value_should_reject_comparison_with_ints(self):
with pytest.raises(ArithmeticError):
Wad.min(Wad(10), 20)
with pytest.raises(ArithmeticError):
Wad.min(20, Wad(10))
def boomable_amount_in_sai(self, tap: Tap):
return Wad.max(tap.joy() - tap.woe(), Wad.from_number(0))
def profit(self, token: Address) -> Wad:
"""Calculates the expected profit brought by executing this sequence (in token `token`)."""
return sum(map(lambda s: s.target_amount, filter(lambda s: s.target_token == token, self.steps)), Wad(0)) \
- sum(map(lambda s: s.source_amount, filter(lambda s: s.source_token == token, self.steps)), Wad(0))
def test_multiply(self):
assert Wad.from_number(2) * Wad.from_number(3) == Wad.from_number(6)
assert Wad.from_number(2) * Wad(3) == Wad(6)
assert Wad.from_number(2.5) * Wad(3) == Wad(7)
assert Wad.from_number(2.99999) * Wad(3) == Wad(8)
def test_multiply_by_int(self):
assert Wad.from_number(2) * 3 == Wad.from_number(6)
assert Wad.from_number(2) * 1 == Wad.from_number(2)
def test_add(self):
assert Wad(1) + Wad(2) == Wad(3)
def test_subtract(self):
assert Wad(10) - Wad(2) == Wad(8)
assert Wad(1) - Wad(2) == Wad(-1)
def test_should_support_values_greater_than_uint256(self):
Wad(2**256)
Wad(2**256 + 1)
Wad(2**512)
def test_add_should_not_work_with_wads(self):
with pytest.raises(ArithmeticError):
Ray(1) + Wad(2)
def test_should_support_negative_values(self):
Wad(-1)
def test_should_instantiate_from_a_wad(self):
assert Ray(
Wad(10000000000000000000)) == Ray(10000000000000000000000000000)
def test_round(self):
assert round(Wad.from_number(123.4567), 2) == Wad.from_number(123.46)
assert round(Wad.from_number(123.4567), 0) == Wad.from_number(123.0)
assert round(Wad.from_number(123.4567), -2) == Wad.from_number(100.0)
def test_max_value_should_reject_comparison_with_ints(self):
with pytest.raises(ArithmeticError):
Wad.max(Wad(10), 20)
with pytest.raises(ArithmeticError):
Wad.max(15, Wad(25))
def test_max_value(self):
assert Wad.max(Wad(10), Wad(20)) == Wad(20)
assert Wad.max(Wad(25), Wad(15)) == Wad(25)
assert Wad.max(Wad(25), Wad(15), Wad(40)) == Wad(40)
def test_should_fail_to_instantiate_from_a_float(self):
with pytest.raises(ArithmeticError):
assert Wad(10.5)
def test_subtract_should_not_work_with_wads(self):
with pytest.raises(ArithmeticError):
Ray(10) - Wad(2)
def test_should_have_nice_printable_representation(self):
for wad in [Wad(1), Wad(100), Wad.from_number(2.5), Wad(-1)]:
assert repr(wad) == f"Wad({wad.value})"
def test_multiply_by_wad(self):
assert Ray.from_number(2) * Wad.from_number(3) == Ray.from_number(6)
assert Ray.from_number(2) * Wad(3) == Ray(6000000000)
assert Ray(2) * Wad(3) == Ray(0)
assert Ray(2) * Wad(999999999999999999) == Ray(1)
assert Ray(2) * Wad(1000000000000000000) == Ray(2)
def test_add_should_not_work_with_ints(self):
with pytest.raises(ArithmeticError):
Wad(1) + 2
def test_should_fail_to_divide_by_wads(self):
with pytest.raises(ArithmeticError):
Ray(4) / Wad(2)
def test_subtract_should_not_work_with_rays(self):
with pytest.raises(ArithmeticError):
Wad(10) - Ray(2)
def test_should_instantiate_from_a_wad(self):
assert Wad(Wad(1)) == Wad(1)
def test_multiply_by_ray(self):
assert Wad.from_number(2) * Ray.from_number(3) == Wad.from_number(6)
assert Wad.from_number(2) * Ray(3) == Wad(0)
assert Wad(2) * Ray(499999999999999999999999999) == Wad(0)
assert Wad(2) * Ray(500000000000000000000000000) == Wad(1)
assert Wad(2) * Ray(999999999999999999999999999) == Wad(1)
assert Wad(2) * Ray(1000000000000000000000000000) == Wad(2)
def test_should_instantiate_from_a_ray(self):
assert Wad(
Ray(10000000000000001010101010101)) == Wad(10000000000000001010)
assert Wad(
Ray(10000000000000001019999999999)) == Wad(10000000000000001019)
def test_should_fail_to_multiply_by_float(self):
with pytest.raises(ArithmeticError):
Wad(2) * 3.0
def test_should_instantiate_from_an_int(self):
assert Wad(10).value == 10
def boomable_amount_in_skr(self, tap: Tap):
# we deduct 0.000001 in order to avoid rounding errors
return Wad.max(
Wad(self.boomable_amount_in_sai(tap) / (tap.bid())) -
Wad.from_number(0.000001), Wad.from_number(0))
def test_max_value_should_reject_comparison_with_wads(self):
with pytest.raises(ArithmeticError):
Ray.max(Ray(10), Wad(20))
with pytest.raises(ArithmeticError):
Ray.max(Ray(25), Wad(15))
def tx_costs(self) -> Wad:
"""Calculates the transaction costs that this sequence will take to execute."""
# TODO transaction costs are still in a fixed currency (SAI) here
return Wad.from_number(0.25) * Wad.from_number(len(self.steps))
def test_min_value_should_reject_comparison_with_rays(self):
with pytest.raises(ArithmeticError):
Wad.min(Wad(10), Ray(20))
with pytest.raises(ArithmeticError):
Wad.min(Ray(25), Wad(15))
