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])