Add tests for turmit methods + add new RpnSymbol + some tests

gte/turmit.py

@@ -2,6 +2,7 @@ import collections
 import inspect
 
 _op_list = collections.OrderedDict()
+_var_list = collections.OrderedDict()
 
 def RpnOp(method):
     ''' @brief Decorator for RPN operation that autodetect argument count
@@ -20,13 +21,42 @@ def RpnOp(method):
             return None
         try:
             for topush in res:
+                if not isinstance(topush, int):
+                    raise ValueError('Turmit.%s() returned a list containing a\
+ %s : %s' % (method.__name__, type(topush), topush))
                 self._push(topush)
         except TypeError:
+            if not isinstance(res, int):
+                raise ValueError('Turmit.%s() returned a list containing a\
+%s : %s' % (method.__name__, type(res), res))
             self._push(res)
         return res
     _op_list[method.__name__] = (method, wrapped)
     return wrapped
 
+class RpnSymbol(object):
+    ''' @brief Designed to handle operation and operand for Turmit expr '''
+
+    OPERATION = 0x0
+    VALUE = 0x1
+    VARIABLE = 0x3
+
+
+    def __init__(self, value, optype = VALUE):
+        self.optype = optype
+        self.value = value
+        if optype == self.OPERATION:
+            self.value = list(_op_list.keys())[value % len(_op_list)]
+        elif optype == self.VARIABLE:
+            self.value %= len(_var_list)
+
+    def __str__(self):
+        if self.optype == self.OPERATION:
+            return _op_list[self.value][0].__name__.upper()
+        elif self.optype == self.VALUE:
+            return '0x%04X' % self.value
+        else:
+            return _var_list[self.value]
 
 class Turmit(object):
     ''' @brief Represent a turmit that act given an RPN expression with an
@@ -38,6 +68,8 @@ class Turmit(object):
         self._stack = [ 0 for _ in range(stack_size)]
         ## @brief Stack head index
         self._cur = stack_size - 1
+        ## @brief Stores turmit direction
+        self._dir = 0
 
     @property
     def shead(self):

tests/test_rpnsymbol.py

@@ -0,0 +1,15 @@
+import unittest
+
+from gte.turmit import RpnSymbol, _op_list
+
+class RpnSymbolTestCase(unittest.TestCase):
+    
+    def test_operations(self):
+        add_idx = list(_op_list.keys()).index('add')
+
+        sym = RpnSymbol(add_idx, RpnSymbol.OPERATION)
+        self.assertEqual(str(sym), 'ADD')
+
+    def test_value(self):
+        sym = RpnSymbol(42, RpnSymbol.VALUE)
+        self.assertEqual(str(sym), '0x002A')

tests/test_turmit.py

@@ -1,7 +1,7 @@
 import unittest
-from unittest import skip
+import inspect
 
-from gte.turmit import Turmit
+from gte.turmit import Turmit, _op_list
 
 class TurmitTestCase(unittest.TestCase):
     
@@ -20,10 +20,19 @@ class TurmitTestCase(unittest.TestCase):
         t._push(2)
         self.assertEqual(t.shead, 2)
 
+    def _rpn(self, rpn, narg = 2):
+        if rpn not in _op_list:
+            raise unittest.SkipTest('"%s" not implemented' % rpn)
+        method, wrapped = _op_list[rpn]
+        if narg != len(inspect.signature(method).parameters) - 1:
+            self.fail('Expected %s to take %d arguments, but Turmit.%s() takes \
+%d arguments' % (rpn, narg, rpn, len(inspect.signature(method).parameters) - 1))
+
     def test_add(self):
         ''' Test turmit add method '''
-        t = Turmit()
+        self._rpn('add')
 
+        t = Turmit()
         t._push(42)
         t._push(8)
         t.add()
@@ -43,6 +52,8 @@ class TurmitTestCase(unittest.TestCase):
 
     def test_mem_sz(self):
         ''' Test turmit mem_sz() operation '''
+        self._rpn('mem_sz', 1)
+
         t = Turmit(8)
         self.assertEqual(len(t._stack), 8)
 
@@ -57,10 +68,10 @@ class TurmitTestCase(unittest.TestCase):
         self.assertEqual(t._cur, 0)
         self.assertEqual(t.shead, 42)
 
-
-    @skip('Need implementation')
     def test_sub(self):
         ''' Test turmit sub() method '''
+        self._rpn('sub')
+
         t = Turmit()
 
         t._push(50)
@@ -80,9 +91,10 @@ class TurmitTestCase(unittest.TestCase):
         self.assertEqual(t._cur, 0)
         self.assertEqual(t.shead, 0)
 
-    @skip('Need implementation')
     def test_mul(self):
         ''' Test turmit mul() method '''
+        self._rpn('mul')
+
         t = Turmit()
 
         t._push(7)
@@ -102,9 +114,10 @@ class TurmitTestCase(unittest.TestCase):
         self.assertEqual(t._cur, 0)
         self.assertEqual(t.shead, 42 *42)
 
-    @skip('Need implementation')
     def test_mod(self):
         ''' Test turmit mod() method '''
+        self._rpn('mod')
+
         t = Turmit()
         t._push(42)
         t._push(4)
@@ -113,11 +126,110 @@ class TurmitTestCase(unittest.TestCase):
         self.assertEqual(t._cur, 0)
         self.assertEqual(t.shead, 2)
 
-    @skip('Need implementation')
+    def test_pow(self):
+        ''' Test turmit pow() method '''
+        self._rpn('pow')
+
+        t = Turmit()
+        t._push(2)
+        t._push(4)
+
+        t.pow()
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 16)
+
+    def test_sqrt(self):
+        ''' Test turmit sqrt() method '''
+        self._rpn('sqrt', 1)
+
+        t = Turmit()
+        t._push(42)
+
+        t.sqrt()
+
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 6)
+
+    def test_and(self):
+        ''' Test turmit binary and() method '''
+        self._rpn('and')
+
+        t = Turmit()
+        t._push(42)
+        t._push(10)
+
+        t.bin_and()
+
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 10)
+
+    def test_or(self):
+        ''' Test turmit binary or() method '''
+        self._rpn('or')
+
+        t = Turmit()
+        t._push(42)
+        t._push(7)
+
+        t.bin_or()
+        
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 47)
+
+    def test_xor(self):
+        ''' Test turmit binary xor() method '''
+        self._rpn('xor')
+
+        t = Turmit()
+        t._push(42)
+        t._push(11)
+
+        t.bin_xor()
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 33)
+
+    def test_rshift(self):
+        ''' Test turmit rshift method '''
+        self._rpn('rshift')
+
+        t = Turmit()
+        t._push(42)
+        t._push(2)
+
+        t.rshift()
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 10)
+
+    def test_lshift(self):
+        ''' Test turmit lshift method '''
+        self._rpn('lshift')
+
+        t = Turmit()
+        t._push(10)
+        t._push(2)
+        t.lshift()
+        self.assertEqual(t._cur, 0)
+        self.assertEqual(t.shead, 40)
+
     def test_dup(self):
         ''' Test turmit dup() method '''
+        self._rpn('dup')
+
         t = Turmit()
         t._push(42)
         t.dup()
         self.assertEqual(t._cur, 1)
-        sefl.assertEqual(t.shead, 42)
+        self.assertEqual(t.shead, 42)
+
+    def test_pop(self):
+        ''' Test turmit pop() method '''
+        self._rpn('pop', 0)
+
+        t = Turmit()
+        t._push(10)
+        t._push(2)
+        t.pop()
+        self.assertEqual(t._cur, 0)
+        self.asertEqual(t.shead, 10)
+        t.pop()
+        self.assertEqual(t._cur, len(t._stack) - 1)