def test_range_with_expr(self):
v = create_var("a")
p = create_par("b")
assert "(a - 1)..((b + 1) - 1)" == to_str(zn.range(v - 1, p + 1))
def test_range_step(self):
with pytest.raises(ValueError, match="step other then 1 isn't supported, but it is 2"):
to_str(range(1, 10, 2))
def test_range_wrong_start(self, start):
with pytest.raises(ValueError, match=re.escape(f"start({start}) should be smaller then stop(10)")):
print(to_str(range(start, 10)))
def test_flatten(self, v, expected):
assert to_str(v, flatten_arg=True) == expected
def test_range(self, r, expected):
assert to_str(r) == expected
def _set_value_as_constraint(ir, variable, flags):
# values like `var int: s = sum(a);` should be set as constraint or it won't be returned in result
ir.constraints.append(
_binary_op("==", variable.name, to_str(variable.value), flags_=flags))
def test_var_to_str(self, v, expected):
assert to_str(v) == expected
def test_invert(self):
result = ~(self.p < self.v)
assert to_str(result) == f"(not ({self.p.name} < {self.v.name}))"
def test_tuple_and_list_to_array(self, collection, expected):
assert to_str(collection) == expected
def test_pow_bracket(self):
result = -3 * self.v**(2 % self.p)
assert to_str(
result) == f"(-3 * pow({self.v.name}, (2 mod {self.p.name})))"
assert result.type is int
def test_binary_logical(self, op, sign):
result = op(self.p > self.v, 2 > self.v)
assert to_str(
result
) == f"(({self.p.name} > {self.v.name}) {sign} ({self.v.name} < 2))"
def test_long_binary_op(self):
result = 1 + self.v * 2 - self.p + self.v**self.p
assert to_str(
result
) == f"(((1 + ({self.v.name} * 2)) - {self.p.name}) + pow({self.v.name}, {self.p.name}))"
assert result.type is int
def test_complex_binary_op(self):
result = (1 - self.v) * (2 // self.p) >= 4
assert to_str(
result) == f"(((1 - {self.v.name}) * (2 div {self.p.name})) >= 4)"
assert result.type is int
def test_simple_ariph_binary_op(self, v, op: Callable, sign: str):
result = op(v, 1)
assert to_str(result) == f"({v.name} {sign} 1)"
assert result.type is int
def test_indexes(self, array, pos, expected):
assert to_str(array[pos]) == expected
def test_generator_to_str(self, gen, expected):
assert expected == to_str(gen)
def test_slice(self, array, pos, expected):
assert expected == to_str(array[pos])
def test_name(self, name, arg):
a = zn.Set(arg)
a._name = name
assert name == to_str(a)
