PageRenderTime 144ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/bfc/tests/cond_test.py

https://bitbucket.org/lifthrasiir/esotope-bfc
Python | 204 lines | 178 code | 25 blank | 1 comment | 25 complexity | 0f452b112480b96213cd6a318c32e38d MD5 | raw file
    

  1. # This is a part of Esotope Brainfuck Compiler.
    2. 

  2. 

  3. from bfc.expr import *
    4. 

  4. from bfc.cond import *
    5. 

  5. 

  6. class TestCondOps:
    7. 

  7.     def test_always_never(self):
    8. 

  8.         always = Always()
    9. 

  9.         never = Never()
    10. 

  10.         assert always and not never
    11. 

  11.         assert always == Always()
    12. 

  12.         assert always != never
    13. 

  13.         assert Never() == never
    14. 

  14.         assert ~always == never and always == ~never
    15. 

  15. 

  16.         assert always.references() == frozenset()
    17. 

  17.         assert always.movepointer(42) == always
    18. 

  18.         assert always.withmemory({0: 42}) == always
    19. 

  19.         assert never.references() == frozenset()
    20. 

  20.         assert never.movepointer(42) == never
    21. 

  21.         assert never.withmemory({0: 42}) == never
    22. 

  22. 

  23.     def test_memequality(self):
    24. 

  24.         m0e2 = MemEqual(0, 2); m0ne2 = MemNotEqual(0, 2)
    25. 

  25.         m0e4 = MemEqual(0, 4); m0ne4 = MemNotEqual(0, 4)
    26. 

  26.         m1e4 = MemEqual(1, 4); m1ne4 = MemNotEqual(1, 4)
    27. 

  27.         assert m0e2 and m0ne2 and m0e4 and m0ne4 and m1e4 and m1ne4
    28. 

  28.         assert m0e2 != m0e4 != m1e4 != m1ne4 != m0ne4 != m0ne2
    29. 

  29.         assert ~m0e2 == m0ne2 and ~m0e4 == m0ne4 and ~m1e4 == m1ne4
    30. 

  30.         assert m0e2 == ~m0ne2 and m0e4 == ~m0ne4 and m1e4 == ~m1ne4
    31. 

  31.         assert m0e2 == MemEqual(0, 2) and m0ne2 == MemNotEqual(0, 2)
    32. 

  32.         assert type(m1e4) is MemEqual and type(m1ne4) is MemNotEqual
    33. 

  33.         assert m1e4.target == m1ne4.target == 1
    34. 

  34.         assert m1e4.expr == m1ne4.expr == Expr[1]
    35. 

  35. 

  36.         assert m0e4.references() == m0ne4.references() == frozenset([0])
    37. 

  37.         assert m0e4.movepointer(1) == m1e4 and m0ne4.movepointer(1) == m1ne4
    38. 

  38.         assert m1e4.references() == m1ne4.references() == frozenset([1])
    39. 

  39.         assert m1e4.movepointer(-1) == m0e4 and m1ne4.movepointer(-1) == m0ne4
    40. 

  40.         assert m0e4.withmemory({0: 4}) == m0ne4.withmemory({0: 7}) == Always()
    41. 

  41.         assert m0e4.withmemory({0: 7}) == m0ne4.withmemory({0: 4}) == Never()
    42. 

  42.         assert m0e4.withmemory({0: Expr[3] * Expr[4]}) not in (Always(), Never())
    43. 

  43.         assert m0ne4.withmemory({0: Expr[3] * Expr[4]}) not in (Always(), Never())
    44. 

  44. 

  45.     def test_equality(self):
    46. 

  46.         assert NotEqual(5, 6) == Equal(6, 6) == Always()
    47. 

  47.         assert NotEqual(6, 6) == Equal(5, 6) == Never()
    48. 

  48.         assert NotEqual(Expr[1] * 4 + 3, -13) == NotEqual(Expr[1] * 4, -16) \
    49. 

  49.                                               == NotEqual(Expr[1], -4)
    50. 

  50.         assert Equal(Expr[1] * 4 + 3, -13) == Equal(Expr[1] * 4, -16) \
    51. 

  51.                                            == Equal(Expr[1], -4)
    52. 

  52.         assert ~NotEqual(Expr[1] * 4 + 3, -13) == Equal(Expr[1] * 4 + 3, -13)
    53. 

  53.         assert NotEqual(Expr[1] * 4 + 3, -13) == ~Equal(Expr[1] * 4 + 3, -13)
    54. 

  54.         assert NotEqual(Expr[1] * 4 + 3, 5) == NotEqual(Expr[1] * 4, 2) == Always()
    55. 

  55.         assert Equal(Expr[1] * 4 + 3, 5) == Equal(Expr[1] * 4, 2) == Never()
    56. 

  56.         assert NotEqual(Expr[1] / 8, 6) == NotEqual(Expr[1], 48)
    57. 

  57.         assert NotEqual(Expr[1] / 8, 0) == NotEqual(Expr[1], 0)
    58. 

  58.         assert Equal(Expr[1] / 8, 6) == Equal(Expr[1], 48)
    59. 

  59.         assert Equal(Expr[1] / 8, 0) == Equal(Expr[1], 0)
    60. 

  60. 

  61.         m6p3e5 = Equal(Expr[6] + 3, 5); m6p3ne5 = NotEqual(Expr[6] + 3, 5)
    62. 

  62.         assert type(m6p3e5) is MemEqual and type(m6p3ne5) is MemNotEqual
    63. 

  63.         assert m6p3e5 == MemEqual(6, 2) and m6p3ne5 == MemNotEqual(6, 2)
    64. 

  64. 

  65.         mm7e5 = MemEqual(Expr[7], 5); mm7ne5 = MemNotEqual(Expr[7], 5)
    66. 

  66.         assert type(mm7e5) is Equal and type(mm7ne5) is NotEqual
    67. 

  67.         assert mm7e5.expr == mm7ne5.expr == Expr[Expr[7]]
    68. 

  68. 

  69.         assert mm7e5.references() == mm7ne5.references() == frozenset([7, Expr[7]])
    70. 

  70.         assert mm7e5.movepointer(1) == Equal(Expr[Expr[8]+1], 5)
    71. 

  71.         assert mm7ne5.movepointer(1) == NotEqual(Expr[Expr[8]+1], 5)
    72. 

  72.         assert mm7e5.movepointer(-1) == Equal(Expr[Expr[6]-1], 5)
    73. 

  73.         assert mm7ne5.movepointer(-1) == NotEqual(Expr[Expr[6]-1], 5)
    74. 

  74.         assert mm7e5.withmemory({7:9}) == MemEqual(9, 5)
    75. 

  75.         assert mm7ne5.withmemory({7:9}) == MemNotEqual(9, 5)
    76. 

  76.         assert type(mm7e5.withmemory({7:9})) is MemEqual
    77. 

  77.         assert type(mm7ne5.withmemory({7:9})) is MemNotEqual
    78. 

  78. 

  79.     def test_range(self):
    80. 

  80.         assert Range(Expr[5]) == Never()
    81. 

  81.         assert Range(Expr[5], 15) == MemEqual(5, 15)
    82. 

  82.         assert Range(Expr[5], (None,14), (16,None)) == MemNotEqual(5, 15)
    83. 

  83.         assert Range(Expr[5], (None,10), (5,None)) == Always()
    84. 

  84. 

  85.         m3pm4 = Expr[3+Expr[4]];             m6pm7 = Expr[6+Expr[7]]
    86. 

  86.         m3pm4lt5 = Less(m3pm4, 5);           m6pm7lt5 = Less(m6pm7, 5)
    87. 

  87.         m3pm4le5 = LessOrEqual(m3pm4, 5);    m6pm7le5 = LessOrEqual(m6pm7, 5)
    88. 

  88.         m3pm4e5 = Equal(m3pm4, 5);           m6pm7e5 = Equal(m6pm7, 5)
    89. 

  89.         m3pm4ge5 = GreaterOrEqual(m3pm4, 5); m6pm7ge5 = GreaterOrEqual(m6pm7, 5)
    90. 

  90.         m3pm4gt5 = Greater(m3pm4, 5);        m6pm7gt5 = Greater(m6pm7, 5)
    91. 

  91. 

  92.         assert m3pm4lt5 and m3pm4le5 and m3pm4e5 and m3pm4ge5 and m3pm4gt5
    93. 

  93.         assert m3pm4lt5 == LessOrEqual(m3pm4, 4) and m3pm4gt5 == GreaterOrEqual(m3pm4, 6)
    94. 

  94.         assert m3pm4lt5 == ~m3pm4ge5 and ~m3pm4lt5 == m3pm4ge5
    95. 

  95.         assert m3pm4le5 == ~m3pm4gt5 and ~m3pm4le5 == m3pm4gt5
    96. 

  96.         assert (m3pm4lt5.references() == m3pm4le5.references() == m3pm4e5.references() ==
    97. 

  97.                 m3pm4ge5.references() == m3pm4gt5.references() == m3pm4.references())
    98. 

  98.         assert m3pm4lt5.movepointer(3) == m6pm7lt5
    99. 

  99.         assert m3pm4le5.movepointer(3) == m6pm7le5
    100. 

  100.         assert m3pm4ge5.movepointer(3) == m6pm7ge5
    101. 

  101.         assert m3pm4gt5.movepointer(3) == m6pm7gt5
    102. 

  102.         assert m3pm4lt5.withmemory({4: 5, 8: 15, 15: 23}) == Never()
    103. 

  103.         assert m3pm4le5.withmemory({4: 5, 8: 15, 15: 23}) == Never()
    104. 

  104.         assert m3pm4ge5.withmemory({4: 5, 8: 15, 15: 23}) == Always()
    105. 

  105.         assert m3pm4gt5.withmemory({4: 5, 8: 15, 15: 23}) == Always()
    106. 

  106. 

  107.         m7e13579 = Range(Expr[7], 1, 3, 5, 7, 9)
    108. 

  108.         assert m7e13579
    109. 

  109.         assert m7e13579.expr == Expr[7]
    110. 

  110.         assert m7e13579.ranges == ((1,1), (3,3), (5,5), (7,7), (9,9))
    111. 

  111.         assert ~m7e13579 == Range(Expr[7], (None,0), 2, 4, 6, 8, (10,None))
    112. 

  112.         assert m7e13579 == Range(Expr[7]+1, 2, 4, 6, 8, 10)
    113. 

  113.         assert m7e13579 == Range(Expr[7]*2+3, 9, 5, 13, 21, 17)
    114. 

  114.         assert m7e13579 == Range(-Expr[7]*2+3, 1, -3, -7, -11, -15)
    115. 

  115.         assert m7e13579 == Range((Expr[7]-1)/2*7, 0, 7, 14, 21, 28)
    116. 

  116. 

  117.     def test_conjunction(self):
    118. 

  118.         assert (Always() & Always()) == Always()
    119. 

  119.         assert ((Always() & Never()) == (Never() & Always()) ==
    120. 

  120.                 (Never() & Never()) == Never())
    121. 

  121. 

  122.         m1lt5 = Less(Expr[1], 5); m1le5 = LessOrEqual(Expr[1], 5)
    123. 

  123.         m1e5 = Equal(Expr[1], 5); m1ne5 = NotEqual(Expr[1], 5)
    124. 

  124.         m1ge5 = GreaterOrEqual(Expr[1], 5); m1gt5 = Greater(Expr[1], 5)
    125. 

  125.         assert (m1lt5 & m1le5) == (m1ne5 & m1le5) == m1lt5
    126. 

  126.         assert (m1gt5 & m1ge5) == (m1ne5 & m1ge5) == m1gt5
    127. 

  127.         assert (m1le5 & m1ge5) == m1e5
    128. 

  128.         assert (m1lt5 & m1ge5) == (m1gt5 & m1le5) == (m1lt5 & m1gt5) == Never()
    129. 

  129.         assert (m1e5 & m1ne5) == Never()
    130. 

  130. 

  131.         assert ((Range(Expr[3], (None,-5), (0,4), (7,9), (13,25), (48,None)) &
    132. 

  132.                  Range(Expr[3], (None,1), (6,12), 21, (37,49), (53,68), (70,None))) ==
    133. 

  133.                 Range(Expr[3], (None,-5), (0,1), (7,9), 21, (48,49), (53,68), (70,None)))
    134. 

  134. 

  135.         m3e5andm4ne7 = MemEqual(3, 5) & MemNotEqual(4, 7)
    136. 

  136.         assert ~m3e5andm4ne7 == (MemNotEqual(3, 5) | MemEqual(4, 7))
    137. 

  137.         assert m3e5andm4ne7.references() == frozenset([3, 4])
    138. 

  138.         assert m3e5andm4ne7.movepointer(-1) == (MemNotEqual(3, 7) & MemEqual(2, 5))
    139. 

  139.         assert m3e5andm4ne7.withmemory({3: 5}) == MemNotEqual(4, 7)
    140. 

  140.         assert m3e5andm4ne7.withmemory({3: 5, 4: 6}) == Always()
    141. 

  141.         assert m3e5andm4ne7.withmemory({3: 8}) == Never()
    142. 

  142. 

  143.     def test_disjunction(self):
    144. 

  144.         assert ((Always() | Always()) == (Always() | Never()) ==
    145. 

  145.                 (Never() | Always()) == Always())
    146. 

  146.         assert (Never() | Never()) == Never()
    147. 

  147. 

  148.         m1lt5 = Less(Expr[1], 5); m1le5 = LessOrEqual(Expr[1], 5)
    149. 

  149.         m1e5 = Equal(Expr[1], 5); m1ne5 = NotEqual(Expr[1], 5)
    150. 

  150.         m1ge5 = GreaterOrEqual(Expr[1], 5); m1gt5 = Greater(Expr[1], 5)
    151. 

  151.         assert (m1lt5 | m1le5) == (m1lt5 | m1e5) == m1le5
    152. 

  152.         assert (m1gt5 | m1ge5) == (m1gt5 | m1e5) == m1ge5
    153. 

  153.         assert (m1lt5 | m1gt5) == m1ne5
    154. 

  154.         assert (m1le5 | m1ge5) == (m1lt5 | m1e5 | m1gt5) == Always()
    155. 

  155.         assert (m1e5 | m1ne5) == Always()
    156. 

  156.         assert (m1e5 | Equal(Expr[1], 11)) == Range(Expr[1], 5, 11)
    157. 

  157.         assert type(m1e5 | Equal(Expr[2], 5)) is Disjunction
    158. 

  158. 

  159.         assert ((Range(Expr[3], (None,-5), (0,4), (7,9), (13,25), (48,None)) |
    160. 

  160.                  Range(Expr[3], (None,1), (6,12), 21, (37,49), (53,68), (70,None))) ==
    161. 

  161.                 Range(Expr[3], (None,4), (6,25), (37,None)))
    162. 

  162. 

  163.         m3e5orm4ne7 = MemEqual(3, 5) | MemNotEqual(4, 7)
    164. 

  164.         assert ~m3e5orm4ne7 == (MemNotEqual(3, 5) & MemEqual(4, 7))
    165. 

  165.         assert m3e5orm4ne7.references() == frozenset([3, 4])
    166. 

  166.         assert m3e5orm4ne7.movepointer(-1) == (MemNotEqual(3, 7) | MemEqual(2, 5))
    167. 

  167.         assert m3e5orm4ne7.withmemory({3: 5}) == Always()
    168. 

  168.         assert m3e5orm4ne7.withmemory({3: 8}) == MemNotEqual(4, 7)
    169. 

  169.         assert m3e5orm4ne7.withmemory({3: 8, 4: 7}) == Never()
    170. 

  170. 

  171.     def test_compactrepr(self):
    172. 

  172.         assert Always().compactrepr() == 'True'
    173. 

  173.         assert Never().compactrepr() == 'False'
    174. 

  174. 

  175.         assert MemEqual(-1, 7).compactrepr() == '{-1}==7'
    176. 

  176.         assert MemNotEqual(-1, 7).compactrepr() == '{-1}!=7'
    177. 

  177.         assert Equal(Expr[3+Expr[4]], 7).compactrepr() in ('{3+{4}}==7', '{{4}+3}==7')
    178. 

  178.         assert Equal(Expr[3+Expr[4]], 0).compactrepr() in ('!{3+{4}}', '!{{4}+3}')
    179. 

  179.         assert Equal(Expr[3]+Expr[4], 0).compactrepr() in ('!({3}+{4})', '!({4}+{3})')
    180. 

  180.         assert NotEqual(Expr[3+Expr[4]], 7).compactrepr() in ('{3+{4}}!=7', '{{4}+3}!=7')
    181. 

  181.         assert NotEqual(Expr[3+Expr[4]], 0).compactrepr() in ('{3+{4}}', '{{4}+3}')
    182. 

  182.         assert NotEqual(Expr[3]+Expr[4], 0).compactrepr() in ('{3}+{4}', '{4}+{3}')
    183. 

  183.         assert Range(Expr[5], 1, 3, 5, 7, 9).compactrepr() == '{5}~(1,3,5,7,9)'
    184. 

  184.         assert (~Range(Expr[5], 1, 3, 5, 7, 9)).compactrepr() == '{5}~(..0,2,4,6,8,10..)'
    185. 

  185.         assert Range(Expr[5], (1,12), (16,30)).compactrepr() == '{5}~(1..12,16..30)'
    186. 

  186.         assert Range(Expr[5], (None,8)).compactrepr() == '{5}<=8'
    187. 

  187.         assert Range(Expr[5], (4,8)).compactrepr() == '4<={5}<=8'
    188. 

  188.         assert Range(Expr[5], (4,None)).compactrepr() == '4<={5}'
    189. 

  189. 

  190.         assert ((MemEqual(1,2) | MemEqual(2,3) | MemEqual(3,4)).compactrepr() in
    191. 

  191.                 ('{1}==2 || {2}==3 || {3}==4', '{1}==2 || {3}==4 || {2}==3',
    192. 

  192.                  '{2}==3 || {1}==2 || {3}==4', '{2}==3 || {3}==4 || {1}==2',
    193. 

  193.                  '{3}==4 || {1}==2 || {2}==3', '{3}==4 || {2}==3 || {1}==2'))
    194. 

  194.         assert ((MemEqual(1,2) & MemEqual(2,3) & MemEqual(3,4)).compactrepr() in
    195. 

  195.                 ('{1}==2 && {2}==3 && {3}==4', '{1}==2 && {3}==4 && {2}==3',
    196. 

  196.                  '{2}==3 && {1}==2 && {3}==4', '{2}==3 && {3}==4 && {1}==2',
    197. 

  197.                  '{3}==4 && {1}==2 && {2}==3', '{3}==4 && {2}==3 && {1}==2'))
    198. 

  198.         assert (((MemEqual(1,2) | MemEqual(2,3)) & MemEqual(3,4)).compactrepr() in
    199. 

  199.                 ('({1}==2 || {2}==3) && {3}==4', '({2}==3 || {1}==2) && {3}==4',
    200. 

  200.                  '{3}==4 && ({1}==2 || {2}==3)', '{3}==4 && ({2}==3 || {1}==2)'))
    201. 

  201.         assert (((MemEqual(1,2) & MemEqual(2,3)) | MemEqual(3,4)).compactrepr() in
    202. 

  202.                 ('({1}==2 && {2}==3) || {3}==4', '({2}==3 && {1}==2) || {3}==4',
    203. 

  203.                  '{3}==4 || ({1}==2 && {2}==3)', '{3}==4 || ({2}==3 && {1}==2)'))
    204. 

  204. 

  205.