Preliminary check for test breaks

Author: Bhargavasomu

eth/vm/computation.py

@@ -19,11 +19,15 @@
 )
 from eth_utils import (
     encode_hex,
+    int_to_big_endian,
 )
 
 from eth.constants import (
+    ANY,
+    BYTES,
     GAS_MEMORY,
     GAS_MEMORY_QUADRATIC_DENOMINATOR,
+    UINT256,
 )
 from eth.exceptions import (
     Halt,
@@ -319,7 +323,41 @@ def stack_pop(self, num_items: int=1, type_hint: str=None) -> Any:
         Raise `eth.exceptions.InsufficientStack` if there are not enough items on
         the stack.
         """
-        return self._stack.pop(num_items, type_hint)
+        if num_items == 1:
+            stack_item = self._stack.pop()
+            if type_hint == UINT256 or type_hint == ANY:
+                return stack_item
+            elif type_hint == BYTES:
+                return int_to_big_endian(stack_item)
+
+        else:
+            popped_items = tuple(self._stack.pop_n(num_items))
+            if type_hint == UINT256 or type_hint == ANY:
+                return popped_items
+            elif type_hint == BYTES:
+                return tuple(int_to_big_endian(item) for item in popped_items)
+                # for item in popped_items:
+                #     yield int_to_big_endian(item)
+
+        # elif num_items == 2:
+        #     stack_item1, stack_item2 = self._stack.pop2()
+        #     if type_hint == UINT256 or type_hint == ANY:
+        #         return stack_item1, stack_item2
+        #     elif type_hint == BYTES:
+        #         return (int_to_big_endian(stack_item1), int_to_big_endian(stack_item2))
+        # elif num_items == 3:
+        #     stack_item1, stack_item2, stack_item3 = self._stack.pop3()
+        #     if type_hint == UINT256 or type_hint == ANY:
+        #         return stack_item1, stack_item2, stack_item3
+        #     elif type_hint == BYTES:
+        #         return (
+        #             int_to_big_endian(stack_item1),
+        #             int_to_big_endian(stack_item2),
+        #             int_to_big_endian(stack_item3),
+        #         )
+        # else:
+        #     # TODO: Replace with suitable customized Exception
+        #     raise Exception("Cannot pop more than 3 elements from stack")
 
     def stack_push(self, value: Union[int, bytes]) -> None:
         """

eth/vm/stack.py

@@ -30,7 +30,7 @@ class Stack(object):
     logger = logging.getLogger('eth.vm.stack.Stack')
 
     def __init__(self) -> None:
-        self.values = []  # type: List[Union[int, bytes]]
+        self.values = []  # type: List[int]
 
     def __len__(self) -> int:
         return len(self.values)
@@ -44,47 +44,81 @@ def push(self, value: Union[int, bytes]) -> None:
 
         validate_stack_item(value)
 
-        self.values.append(value)
+        if isinstance(value, int):
+            stack_value = value
+        elif isinstance(value, bytes):
+            stack_value = big_endian_to_int(value)
+        else:
+            raise Exception(
+                "Stack supports only Int or Byte objects, got {} type object".format(type(value))
+            )
 
-    def pop(self,
-            num_items: int,
-            type_hint: str) -> Union[int, bytes, Tuple[Union[int, bytes], ...]]:
-        """
-        Pop an item off the stack.
+        self.values.append(stack_value)
 
-        Note: This function is optimized for speed over readability.
-        """
+    # def pop(self,
+    #         num_items: int,
+    #         type_hint: str) -> Union[int, bytes, Tuple[Union[int, bytes], ...]]:
+    #     """
+    #     Pop an item off the stack.
+    #
+    #     Note: This function is optimized for speed over readability.
+    #     """
+    #     try:
+    #         if num_items == 1:
+    #             return next(self._pop(num_items, type_hint))
+    #         else:
+    #             return tuple(self._pop(num_items, type_hint))
+    #     except IndexError:
+    #         raise InsufficientStack("No stack items")
+    #
+    # def _pop(self, num_items: int, type_hint: str) -> Generator[Union[int, bytes], None, None]:
+    #     for _ in range(num_items):
+    #         if type_hint == constants.UINT256:
+    #             value = self.values.pop()
+    #             if isinstance(value, int):
+    #                 yield value
+    #             else:
+    #                 yield big_endian_to_int(value)
+    #         elif type_hint == constants.BYTES:
+    #             value = self.values.pop()
+    #             if isinstance(value, bytes):
+    #                 yield value
+    #             else:
+    #                 yield int_to_big_endian(value)
+    #         elif type_hint == constants.ANY:
+    #             yield self.values.pop()
+    #         else:
+    #             raise TypeError(
+    #                 "Unknown type_hint: {0}.  Must be one of {1}".format(
+    #                     type_hint,
+    #                     ", ".join((constants.UINT256, constants.BYTES)),
+    #                 )
+    #             )
+
+    def pop(self) -> int:
         try:
-            if num_items == 1:
-                return next(self._pop(num_items, type_hint))
-            else:
-                return tuple(self._pop(num_items, type_hint))
+            return self.values.pop()
         except IndexError:
             raise InsufficientStack("No stack items")
 
-    def _pop(self, num_items: int, type_hint: str) -> Generator[Union[int, bytes], None, None]:
+    def pop_n(self, num_items: int) -> Tuple[int, ...]:
         for _ in range(num_items):
-            if type_hint == constants.UINT256:
-                value = self.values.pop()
-                if isinstance(value, int):
-                    yield value
-                else:
-                    yield big_endian_to_int(value)
-            elif type_hint == constants.BYTES:
-                value = self.values.pop()
-                if isinstance(value, bytes):
-                    yield value
-                else:
-                    yield int_to_big_endian(value)
-            elif type_hint == constants.ANY:
+            try:
                 yield self.values.pop()
-            else:
-                raise TypeError(
-                    "Unknown type_hint: {0}.  Must be one of {1}".format(
-                        type_hint,
-                        ", ".join((constants.UINT256, constants.BYTES)),
-                    )
-                )
+            except IndexError:
+                raise InsufficientStack("No stack items")
+
+    def pop2(self) -> Tuple[int, int]:
+        try:
+            return (self.values.pop(), self.values.pop())
+        except IndexError:
+            raise InsufficientStack("No stack items")
+
+    def pop3(self) -> Tuple[int, int, int]:
+        try:
+            return (self.values.pop(), self.values.pop(), self.values.pop())
+        except IndexError:
+            raise InsufficientStack("No stack items")
 
     def swap(self, position: int) -> None:
         """

tests/core/stack/test_stack.py

@@ -1,6 +1,7 @@
 import pytest
 
 from eth_utils import (
+    big_endian_to_int,
     ValidationError,
 )
 
@@ -39,7 +40,10 @@ def stack():
 def test_push_only_pushes_valid_stack_items(stack, value, is_valid):
     if is_valid:
         stack.push(value)
-        assert stack.values == [value]
+        if isinstance(value, int):
+            assert stack.values == [value]
+        else:
+            assert stack.values == [big_endian_to_int(value)]
     else:
         with pytest.raises(ValidationError):
             stack.push(value)
@@ -67,30 +71,30 @@ def test_dup_does_not_allow_stack_to_exceed_1024_items(stack):
     (
         ([1], UINT256),
         ([1, 2, 3], UINT256),
-        ([b'1', b'10', b'101', b'1010'], BYTES)
+        # ([b'1', b'10', b'101', b'1010'], BYTES)
     )
 )
 def test_pop_returns_latest_stack_item(stack, items, type_hint):
     for each in items:
         stack.push(each)
-    assert stack.pop(num_items=1, type_hint=type_hint) == items[-1]
-
-
-@pytest.mark.parametrize(
-    ("value,type_hint,type,is_valid"),
-    (
-        (1, UINT256, int, True),
-        (b'101', BYTES, bytes, True),
-        (1, SECPK1_N, int, False)
-    )
-)
-def test_pop_typecasts_correctly_based_off_type_hint(stack, value, type_hint, type, is_valid):
-    stack.push(value)
-    if is_valid:
-        assert isinstance(stack.pop(num_items=1, type_hint=type_hint), type)
-    else:
-        with pytest.raises(TypeError):
-            stack.pop(type_hint=type_hint)
+    assert stack.pop() == items[-1]
+
+
+# @pytest.mark.parametrize(
+#     ("value,type_hint,type,is_valid"),
+#     (
+#         (1, UINT256, int, True),
+#         (b'101', BYTES, bytes, True),
+#         (1, SECPK1_N, int, False)
+#     )
+# )
+# def test_pop_typecasts_correctly_based_off_type_hint(stack, value, type_hint, type, is_valid):
+#     stack.push(value)
+#     if is_valid:
+#         assert isinstance(stack.pop(num_items=1, type_hint=type_hint), type)
+#     else:
+#         with pytest.raises(TypeError):
+#             stack.pop(type_hint=type_hint)
 
 
 def test_swap_operates_correctly(stack):
@@ -115,7 +119,9 @@ def test_dup_operates_correctly(stack):
 
 def test_pop_raises_InsufficientStack_appropriately(stack):
     with pytest.raises(InsufficientStack):
-        stack.pop(num_items=1, type_hint=UINT256)
+        stack.pop()
+        stack.pop_n(2)
+        stack.pop_n(5)
 
 
 def test_swap_raises_InsufficientStack_appropriately(stack):