def test_udiv(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.udiv(y)
v = x.udiv(1)
self.assertEqual(z.value, "(bvudiv x y)")
self.assertEqual(v.value, "(bvudiv x #x00000001)")
def test_umod(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.umod(y)
v = x.umod(1)
self.assertEqual(z.value, "(bvurem x y)")
self.assertEqual(v.value, "(bvurem x #x00000001)")
def test_umod(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.umod(y)
v = x.umod(1)
self.assertEqual(z.value, "(bvurem x y)")
self.assertEqual(v.value, "(bvurem x #x00000001)")
def test_udiv(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.udiv(y)
v = x.udiv(1)
self.assertEqual(z.value, "(bvudiv x y)")
self.assertEqual(v.value, "(bvudiv x #x00000001)")
def test_greater_than_equal_unsigned(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.uge(y)
v = x.uge(1)
self.assertEqual(z.value, "(bvuge x y)")
self.assertEqual(v.value, "(bvuge x #x00000001)")
def test_concat(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = concat(32, x, y)
v = concat(32, x)
self.assertEqual(z.value, "(concat x y)")
self.assertEqual(v.value, "x")
def test_less_than_unsigned(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.ult(y)
v = x.ult(1)
self.assertEqual(z.value, "(bvult x y)")
self.assertEqual(v.value, "(bvult x #x00000001)")
def test_less_than_unsigned(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.ult(y)
v = x.ult(1)
self.assertEqual(z.value, "(bvult x y)")
self.assertEqual(v.value, "(bvult x #x00000001)")
def test_greater_than_equal_unsigned(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x.uge(y)
v = x.uge(1)
self.assertEqual(z.value, "(bvuge x y)")
self.assertEqual(v.value, "(bvuge x #x00000001)")
def test_or(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x | y
v = x | 1
w = 1 | x
self.assertEqual(z.value, "(bvor x y)")
self.assertEqual(v.value, "(bvor x #x00000001)")
self.assertEqual(w.value, "(bvor #x00000001 x)")
def test_xor(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x ^ y
v = x ^ 1
w = 1 ^ x
self.assertEqual(z.value, "(bvxor x y)")
self.assertEqual(v.value, "(bvxor x #x00000001)")
self.assertEqual(w.value, "(bvxor #x00000001 x)")
def test_and(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x & y
v = x & 1
w = 1 & x
self.assertEqual(z.value, "(bvand x y)")
self.assertEqual(v.value, "(bvand x #x00000001)")
self.assertEqual(w.value, "(bvand #x00000001 x)")
def test_mod(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x % y
v = x % 1
w = 1 % x
self.assertEqual(z.value, "(bvsmod x y)")
self.assertEqual(v.value, "(bvsmod x #x00000001)")
self.assertEqual(w.value, "(bvsmod #x00000001 x)")
def test_greater_than(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x > y
v = x > 1
w = 1 > x
self.assertEqual(z.value, "(bvsgt x y)")
self.assertEqual(v.value, "(bvsgt x #x00000001)")
self.assertEqual(w.value, "(bvslt x #x00000001)")
def test_equal(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x == y
v = x == 1
w = 1 == x
self.assertEqual(z.value, "(= x y)")
self.assertEqual(v.value, "(= x #x00000001)")
self.assertEqual(w.value, "(= x #x00000001)")
def test_less_than(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x < y
v = x < 1
w = 1 < x
self.assertEqual(z.value, "(bvslt x y)")
self.assertEqual(v.value, "(bvslt x #x00000001)")
self.assertEqual(w.value, "(bvsgt x #x00000001)")
def test_ite(self):
b = Bool("b")
x = BitVec(32, "x")
y = BitVec(32, "y")
z = BitVec(32, "z")
v = ite(32, x == 0, y, z)
w = ite(32, b, y, z)
self.assertEqual(v.value, "(ite (= x #x00000000) y z)")
self.assertEqual(w.value, "(ite b y z)")
def test_rshift(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x >> y
v = x >> 1
w = 1 >> x
self.assertEqual(z.value, "(bvlshr x y)")
self.assertEqual(v.value, "(bvlshr x #x00000001)")
self.assertEqual(w.value, "(bvlshr #x00000001 x)")
def test_add(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x + y
v = x + 1
w = 1 + x
self.assertEqual(z.value, "(bvadd x y)")
self.assertEqual(v.value, "(bvadd x #x00000001)")
self.assertEqual(w.value, "(bvadd #x00000001 x)")
def test_less_than_equal(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x <= y
v = x <= 1
w = 1 <= x
self.assertEqual(z.value, "(bvsle x y)")
self.assertEqual(v.value, "(bvsle x #x00000001)")
self.assertEqual(w.value, "(bvsge x #x00000001)")
def test_sub(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x - y
v = x - 1
w = 1 - x
self.assertEqual(z.value, "(bvsub x y)")
self.assertEqual(v.value, "(bvsub x #x00000001)")
self.assertEqual(w.value, "(bvsub #x00000001 x)")
def test_not_equal(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x != y
v = x != 1
w = 1 != x
self.assertEqual(z.value, "(not (= x y))")
self.assertEqual(v.value, "(not (= x #x00000001))")
self.assertEqual(w.value, "(not (= x #x00000001))")
def test_mul(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x * y
v = x * 1
w = 1 * x
self.assertEqual(z.value, "(bvmul x y)")
self.assertEqual(v.value, "(bvmul x #x00000001)")
self.assertEqual(w.value, "(bvmul #x00000001 x)")
def test_greater_than_equal(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x >= y
v = x >= 1
w = 1 >= x
self.assertEqual(z.value, "(bvsge x y)")
self.assertEqual(v.value, "(bvsge x #x00000001)")
self.assertEqual(w.value, "(bvsle x #x00000001)")
def test_div(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x / y
v = x / 1
w = 1 / x
self.assertEqual(z.value, "(bvsdiv x y)")
self.assertEqual(v.value, "(bvsdiv x #x00000001)")
self.assertEqual(w.value, "(bvsdiv #x00000001 x)")
def test_lshift(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = x << y
v = x << 1
w = 1 << x
self.assertEqual(z.value, "(bvshl x y)")
self.assertEqual(v.value, "(bvshl x #x00000001)")
self.assertEqual(w.value, "(bvshl #x00000001 x)")
def test_store(self):
a = BitVecArray(32, 8, "a")
k = BitVec(32, "k")
v = BitVec(8, "v")
b = a.store(k, v)
c = a.store(k, 1)
d = a.store(1, v)
e = a.store(1, 1)
self.assertEqual(b.value, "(store a k v)")
self.assertEqual(c.value, "(store a k #x01)")
self.assertEqual(d.value, "(store a #x00000001 v)")
self.assertEqual(e.value, "(store a #x00000001 #x01)")
def sign_extend(s, size):
assert type(s) in (Constant, BitVec) and size - s.size >= 0
if size == s.size:
return s
return BitVec(size, "(_ sign_extend {})".format(size - s.size), s)
def test_select(self):
a = BitVecArray(32, 8, "a")
k = BitVec(32, "k")
b = a.select(k)
c = a.select(1)
self.assertEqual(b.value, "(select a k)")
self.assertEqual(c.value, "(select a #x00000001)")
def extract(s, offset, size):
assert type(s) in (Constant, BitVec)
if offset == 0 and size == s.size:
return s
return BitVec(size, "(_ extract {} {})".format(offset + size - 1, offset),
s)
def test_neg(self):
x = BitVec(32, "x")
z = BitVec(32, "z")
self._solver.declare_fun("x", x)
self._solver.declare_fun("z", z)
self._solver.add(-x == z)
# Add constraints to avoid trivial solutions.
self._solver.add(x > 1)
self.assertEqual(self._solver.check(), "sat")
x_val = self._solver.get_value(x)
z_val = self._solver.get_value(z)
self.assertTrue(-x_val & 0xffffffff == z_val)
def test_ge(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
self._solver.declare_fun("x", x)
self._solver.declare_fun("y", y)
self._solver.add(x >= y)
# Add constraints to avoid trivial solutions.
self._solver.add(x > 1)
self._solver.add(y > 1)
self.assertEqual(self._solver.check(), "sat")
x_val = self._solver.get_value(x)
y_val = self._solver.get_value(y)
self.assertTrue(x_val >= y_val)
def test_extract(self):
x = BitVec(32, "x")
x0 = extract(x, 0, 8)
x1 = extract(x, 8, 8)
x2 = extract(x, 16, 8)
x3 = extract(x, 24, 8)
self.assertEqual(x0.value, "((_ extract 7 0) x)")
self.assertEqual(x1.value, "((_ extract 15 8) x)")
self.assertEqual(x2.value, "((_ extract 23 16) x)")
self.assertEqual(x3.value, "((_ extract 31 24) x)")
def test_mul(self):
x = BitVec(32, "x")
y = BitVec(32, "y")
z = BitVec(32, "z")
self._solver.declare_fun("x", x)
self._solver.declare_fun("y", y)
self._solver.declare_fun("z", z)
self._solver.add(x * y == z)
# Add constraints to avoid trivial solutions.
self._solver.add(x > 1)
self._solver.add(y > 1)
self._solver.add(x != y)
self.assertEqual(self._solver.check(), "sat")
x_val = self._solver.get_value(x)
y_val = self._solver.get_value(y)
z_val = self._solver.get_value(z)
self.assertTrue(x_val * y_val == z_val)
