def test_bytestack_conversion(self):
size = 50
vm = VM()
stack_int.new(vm)
for val in range(size):
vm.push(val)
vm.swap1()
stack_int.push(vm)
vm.push(size * 32)
vm.tnewn(2)
bytestack.set_val("size")(vm)
bytestack.set_val("stack")(vm)
start_stack = vm.stack[0]
sized_byterange.from_bytestack(vm)
br = sized_byterange.make()
for val in range(size):
br = sized_byterange.set_static(br, val * 32, val)
self.assertEqual(br, vm.stack[0])
sized_byterange.to_bytestack(vm)
self.assertEqual(start_stack, vm.stack[0])
def test_flip_endianness(self):
hexstr = bytearray.fromhex(
"ada5013122d395ba3c54772283fb069b10426056ef8ca54750cb9bb552a59e7d")
littleInt = int.from_bytes(hexstr, byteorder="little")
bigInt = int.from_bytes(hexstr, byteorder="big")
vm = VM()
vm.push(littleInt)
bitwise.flip_endianness(vm)
self.assertEqual(vm.stack[0], bigInt)
def test_compress_aux(self):
vm = VM()
vm.aux_stack.items = list(range(93))
stack_manip.compress_aux(vm)
vm2 = VM()
stack.new(vm2)
for i in range(93):
vm2.push(i)
stack.push(vm2)
self.assertEqual(vm.stack[:], vm2.stack[:])
def test_set(self):
bs = bigstruct.BigStruct([(i + 1, str(i + 1), i + 1)
for i in range(101)])
vm = VM()
bs.initialize(vm)
for i in range(101):
vm.push(i + 100)
vm.swap1()
bs.set_val(str(i + 1), vm)
for i in range(101):
vm.dup0()
bs.get(str(i + 1), vm)
self.assertEqual(vm.stack[0], i + 100)
vm.pop()
def test_left_shift(self):
cases = [(TT256 - 100, 2), (100, 2)]
for case in cases:
vm = VM()
vm.push(case[1])
vm.push(case[0])
bitwise.shift_left(vm)
self.assertEqual((case[0] << case[1]) & TT256M1, vm.stack[0])
vm2 = VM()
vm2.push(case[1])
vm2.push(case[0])
bitwise.shift_left(vm2)
self.assertEqual(to_signed((case[0] << case[1]) & TT256M1),
to_signed(vm2.stack[0]))
def test_set(self):
for size in sizes:
bs = bigstruct.BigStruct([(i + 1, i + 1, i + 1) for i in range(size)])
vm = VM()
bs.initialize(vm)
for i in range(size):
vm.push(i + 100)
vm.swap1()
bs.set_val(i + 1, vm)
for i in range(size):
vm.dup0()
bs.get(i + 1, vm)
self.assertEqual(vm.stack[0], i + 100)
vm.pop()
def test_set_static(self):
kvs = keyvalue.make()
for val in range(200):
kvs = keyvalue.set_static(kvs, val, val + 1000)
vm = VM()
vm.push(kvs)
for val in range(200):
vm.push(val)
vm.dup1()
keyvalue.get(vm)
self.assertEqual(vm.stack[0], val + 1000)
vm.pop()
kvs = keyvalue.set_static(kvs, 100, 2100)
self.assertEqual(keyvalue.get_static(kvs, 100), 2100)
def test_vec0(self):
vm = VM()
sha3.ctx_new(vm)
sha3.ctx_finish(vm)
real_hash = int.from_bytes(hashlib.sha3_256().digest(),
byteorder="big")
self.assertEqual(vm.stack[0], real_hash)
def test_get(self):
vm = VM()
arr = Array(100)
vm.push(Array.from_list(list(range(100))))
for i in range(100):
vm.dup0()
arr.get(i)(vm)
self.assertEqual(vm.stack[0], i)
vm.pop()
def test_pack(self):
for i in range(1, 100):
with self.subTest():
data = list(range(100))
vm = VM()
vm.stack.items = list(data)
tup.pack(i)(vm)
self.assertEqual(vm.stack[1:], data[i:])
def test_right_shift(self):
cases = [(TT256 - 100, 2), (100, 2)]
for case in cases:
vm = VM()
vm.push(case[1])
vm.push(case[0])
bitwise.shift_right(vm)
self.assertEqual(case[0] >> case[1], vm.stack[0])
def test_dup_n(self):
for i in range(100):
with self.subTest():
vm = VM()
vm.stack.items = list(range(100))
stack_manip.dup_n(i)(vm)
self.assertEqual(vm.stack[0], i)
self.assertEqual(vm.stack[1:], list(range(100)))
def test_uncompress_aux(self):
for i in [0, 97]:
with self.subTest():
vm = VM()
vm.aux_stack.items = list(range(i))
stack_manip.compress_aux(vm)
stack_manip.uncompress_aux(vm)
self.assertEqual(vm.stack[:], [])
self.assertEqual(vm.aux_stack[:], list(range(i)))
def test_arithmetic_shift_right(self):
cases = [(TT256 - 100, 2), (100, 2)]
for case in cases:
vm = VM()
vm.push(case[1])
vm.push(case[0])
bitwise.arithmetic_shift_right(vm)
self.assertEqual(
to_signed(case[0]) >> case[1], to_signed(vm.stack[0]))
def test_take_n(self):
for i in range(1, 100):
with self.subTest():
vm = VM()
orig_list = list(range(100))
vm.stack.items = list(orig_list)
stack_manip.take_n(i)(vm)
new_list = [orig_list[i]] + orig_list[:i] + orig_list[i + 1:]
self.assertEqual(vm.stack[:], new_list)
def test_swap_n(self):
for i in range(1, 100):
with self.subTest():
vm = VM()
orig_list = list(range(100))
vm.stack.items = list(orig_list)
stack_manip.swap_n(i)(vm)
orig_list[0], orig_list[i] = orig_list[i], orig_list[0]
self.assertEqual(vm.stack[:], orig_list)
def test_get8(self):
data = bytearray(random.getrandbits(8) for _ in range(100))
br = byterange.frombytes(data)
for i in range(100):
with self.subTest(index=i):
vm = VM()
vm.push(br)
vm.push(i)
vm.dup1()
byterange.get8(vm)
self.assertEqual(data[i], vm.stack[0])
def test_set(self):
vm = VM()
arr = Array(100)
vm.push(Array.from_list(list(range(100))))
for i in range(100):
vm.push(i + 100)
vm.swap1()
arr.set_val(i)(vm)
result = Array.from_list([x + 100 for x in range(100)])
self.assertEqual(vm.stack[0], result)
def test_subset(self):
for (start, stop) in [(0, 32), (0, 16), (0, 6), (100, 200), (33, 107)]:
with self.subTest(start=start, stop=stop):
data = bytearray(random.getrandbits(8) for _ in range(500))
vm = VM()
vm.push(stop)
vm.push(start)
vm.push(byterange.frombytes(data))
byterange.get_subset(vm)
self.assertEqual(byterange.frombytes(data[start:stop]),
vm.stack[0])
def test_empty(self):
vm = VM()
vm.push(10)
stack.new(vm)
vm.dup0()
stack.isempty(vm)
self.assertTrue(vm.stack[0])
vm.pop()
stack.push(vm)
stack.isempty(vm)
self.assertFalse(vm.stack[0])
def test_subset(self):
for (start, stop) in [(0, 32), (0, 16), (0, 6), (100, 200), (33, 107)]:
with self.subTest(start=start, stop=stop):
data = list(range(200))
vm = VM()
vm.push(stop)
vm.push(start)
vm.push(bigtuple.fromints(data))
bigtuple.get_subset(vm)
self.assertEqual(bigtuple.fromints(data[start:stop]),
vm.stack[0])
def test_push_to_n(self):
for i in range(1, 100):
with self.subTest():
vm = VM()
orig_list = list(range(100))
vm.stack.items = list(orig_list)
stack_manip.push_to_n(i)(vm)
new_list = orig_list[1:i + 1] + [orig_list[0]
] + orig_list[i + 1:]
self.assertEqual(vm.stack[:], new_list)
def test_simple(self):
vm = VM()
queue.new(vm)
for val in range(200):
vm.push(val)
vm.swap1()
queue.put(vm)
for val in range(200):
queue.get(vm)
self.assertEqual(vm.stack[0], val)
vm.pop()
def test_simple(self):
vm = VM()
stack.new(vm)
for val in range(200):
vm.push(val)
vm.swap1()
stack.push(vm)
for val in range(199, -1, -1):
stack.pop(vm)
self.assertEqual(vm.stack[0], val)
vm.pop()
def test_static_get(self):
vm = VM()
bigtuple.new(vm)
for val in range(200):
vm.push(val)
vm.push(val + 100)
vm.swap2()
bigtuple.set_val(vm)
tup = vm.stack.items[0]
for val in range(200):
self.assertEqual(bigtuple.get_static(tup, val), val + 100)
def test_set_byte(self):
origstring = bytearray.fromhex(
"ada5013122d395ba3c54772283fb069b10426056ef8ca54750cb9bb552a59e7d")
bigInt = int.from_bytes(origstring, byteorder="big")
for i in range(32):
new_val = random.getrandbits(8)
vm = VM()
vm.push(new_val)
vm.push(i)
vm.push(bigInt)
bitwise.set_byte(vm)
finalstring = bytearray(origstring)
finalstring[i] = new_val
self.assertEqual(vm.stack[0],
int.from_bytes(finalstring, byteorder="big"))
def test_set8(self):
data = bytearray(random.getrandbits(8) for _ in range(100))
br = byterange.frombytes(data)
update_bytes = random.getrandbits(8)
for i in range(100):
with self.subTest(index=i):
vm = VM()
vm.push(update_bytes)
vm.push(i)
vm.push(br)
byterange.set_val8(vm)
solution = bytearray(data)
solution[i] = update_bytes
self.assertEqual(solution.hex(),
sized_byterange.tohex([vm.stack[0], 100])[2:])
def test_frombytes(self):
data = bytearray(random.getrandbits(8) for _ in range(500))
data2 = bytearray(data)
if len(data2) % 32 != 0:
data2 = data2 + b"\0" * (32 - (len(data2) % 32))
chunks = [
eth_utils.big_endian_to_int(data2[i:i + 32])
for i in range(0, len(data2), 32)
]
vm = VM()
byterange.new(vm)
for i, chunk in enumerate(chunks):
vm.push(i * 32)
vm.push(chunk)
vm.swap2()
byterange.set_val(vm)
self.assertEqual(byterange.frombytes(data), vm.stack[0])
def test_byterange_keccak256(self):
for length in [64, 128, 200, 136, 135]:
data = bytearray(random.getrandbits(8) for _ in range(length))
vm = VM()
vm.push(len(data))
vm.push(byterange.frombytes(data))
sha3.hash_byterange(vm)
real_hash = int.from_bytes(eth_utils.crypto.keccak(data),
byteorder="big")
self.assertEqual(real_hash, vm.stack[0])
def test_random_keccak256(self):
data = bytearray(random.getrandbits(8) for _ in range(64))
vm = VM()
sha3.ctx_new(vm)
for v in data:
vm.push(v)
vm.swap1()
sha3.ctx_pushbyte(vm)
real_hash = int.from_bytes(eth_utils.crypto.keccak(data),
byteorder="big")
sha3.keccak_ctx_finish(vm)
self.assertEqual(real_hash, vm.stack[0])
