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_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_getset(self):
vm = VM()
bs = bigstruct.BigStruct([(i + 1, i + 1, i + 1) for i in range(101)])
bs.initialize(vm)
vm.dup0()
bs.get(13, vm)
self.assertEqual(vm.stack[0], 13)
vm.pop()
vm.push(666)
vm.swap1()
bs.set_val(25, vm)
vm.pop()
def test_vec1(self):
vm = VM()
sha3.ctx_new(vm)
hasher = hashlib.sha3_256()
for i in range(200):
vm.push(0xa3)
vm.swap1()
sha3.ctx_pushbyte(vm)
hasher.update(bytes([0xa3]))
real_hash = int.from_bytes(hasher.digest(), byteorder="big")
sha3.ctx_finish(vm)
self.assertEqual(vm.stack[0], real_hash)
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_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_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])
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_random_sha3(self):
data = bytearray(random.getrandbits(8) for _ in range(64))
vm = VM()
sha3.ctx_new(vm)
hasher = hashlib.sha3_256()
hasher.update(data)
for v in data:
vm.push(v)
vm.swap1()
sha3.ctx_pushbyte(vm)
real_hash = int.from_bytes(hasher.digest(), byteorder="big")
sha3.ctx_finish(vm)
self.assertEqual(vm.stack[0], real_hash)
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_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_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_getset(self):
vm = VM()
keyvalue.new(vm)
for val in range(200):
vm.push(val)
vm.push(val + 1000)
vm.swap2()
keyvalue.set_val(vm)
for val in range(200):
vm.push(val)
vm.dup1()
keyvalue.get(vm)
self.assertEqual(val + 1000, vm.stack.items[0])
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_getset(self):
indexes = [1, 10, 5, 6, 20, 100, 7, 5]
vm = VM()
sized_byterange.new(vm)
for val in indexes:
vm.push(val * 58)
vm.push(val + 100)
vm.swap2()
sized_byterange.set_val(vm)
for val in indexes:
vm.push(val * 58)
vm.dup1()
sized_byterange.get(vm)
self.assertEqual(val + 100, vm.stack.items[0])
vm.pop()
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_static_get(self):
vm = VM()
sized_byterange.new(vm)
for val in range(200):
vm.push(val * 58)
vm.push(val + 100)
vm.swap2()
sized_byterange.set_val(vm)
tup = vm.stack.items[0]
for val in range(200):
vm.push(val * 58)
vm.dup1()
sized_byterange.get(vm)
self.assertEqual(sized_byterange.get_static(tup, val * 58),
vm.stack.items[0])
vm.pop()
def test_get136(self):
data = bytearray(random.getrandbits(8) for _ in range(200))
vm = VM()
vm.push(0)
vm.push(byterange.frombytes(data))
sha3.byterange_get136(vm)
self.assertEqual(
vm.stack[0],
value.Tuple([
int.from_bytes(data[0:32], byteorder="little"),
int.from_bytes(data[32:64], byteorder="little"),
int.from_bytes(data[64:96], byteorder="little"),
int.from_bytes(data[96:128], byteorder="little"),
int.from_bytes(data[128:136] +
bytearray([0 for x in range(24)]),
byteorder="little")
]))
def test_get_static(self):
vm = VM()
keyvalue.new(vm)
for val in range(200):
vm.push(val)
vm.push(val + 1000)
vm.swap2()
keyvalue.set_val(vm)
kvs = vm.stack.items[0]
for val in range(200):
vm.push(val)
vm.dup1()
keyvalue.get(vm)
self.assertEqual(keyvalue.get_static(kvs, val), vm.stack.items[0])
vm.pop()
self.assertEqual(keyvalue.get_static(kvs, 100000), value.Tuple([]))
def test_copy(self):
indexes = [(0, 32, 0), (0, 16, 0), (0, 32, 32), (0, 6, 0),
(37, 108, 42)]
for (source_start, source_end, dest_start) in indexes:
with self.subTest(source_start=source_start,
source_end=source_end,
dest_start=dest_start):
source = bytearray(random.getrandbits(8) for _ in range(500))
dest = bytearray(random.getrandbits(8) for _ in range(500))
size = source_end - source_start
vm = VM()
vm.push(dest_start)
vm.push(byterange.frombytes(dest))
vm.push(source_end)
vm.push(source_start)
vm.push(byterange.frombytes(source))
byterange.copy(vm)
result = (dest[:dest_start] + source[source_start:source_end] +
dest[dest_start + size:])
self.assertEqual(byterange.frombytes(result), vm.stack[0])
def test_copy(self):
indexes = [(0, 32, 0), (0, 16, 0), (0, 32, 32), (0, 6, 0),
(37, 108, 42)]
for (source_start, source_end, dest_start) in indexes:
with self.subTest(source_start=source_start,
source_end=source_end,
dest_start=dest_start):
source = list(range(200))
dest = [x + 1000 for x in range(200)]
size = source_end - source_start
vm = VM()
vm.push(dest_start)
vm.push(bigtuple.fromints(dest))
vm.push(source_end)
vm.push(source_start)
vm.push(bigtuple.fromints(source))
bigtuple.copy(vm)
result = (dest[:dest_start] + source[source_start:source_end] +
dest[dest_start + size:])
self.assertEqual(bigtuple.fromints(result), vm.stack[0])
def test_min(self):
vm = VM()
vm.push(10)
vm.push(15)
arith.min(vm)
self.assertEqual(vm.stack[0], 10)
