materials/emacs-the-best-python-editor/PyEval/expr_test.py at python-gui-tkinter · realpython/materials · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
"""
Test cases for PyEval

Jon Fincher, July 2018
"""

import unittest

from pyeval_expression import Expression


class TestPyEval(unittest.TestCase):
    """
    Validation of Expression and Operator classes.
    No setup function is needed
    """

    def test_positive_operand_expression(self):
        """
        Tests a single positive operand expression
        """
        expr = Expression("53")
        self.assertEqual("53 ", expr.result(), "ERROR: Positive operand")

    def test_negative_operand_expression(self):
        """
        Tests a single negative operand expression
        """
        expr = Expression("-53")
        self.assertEqual("-53 ", expr.result(), "ERROR: Negative operand")

    def test_double_term_expression(self):
        """
        Tests a set of double term expressions
        """
        expr = Expression("53+2")
        self.assertEqual(
            "53 2 + ", expr.result(), "ERROR: Double positive term expression"
        )
        expr = Expression("-53+2")
        self.assertEqual(
            "-53 2 + ",
            expr.result(),
            "ERROR: Negative/positive term expression",
        )
        expr = Expression("53+-2")
        self.assertEqual(
            "53 -2 + ",
            expr.result(),
            "ERROR: Positive/negative term expression",
        )
        expr = Expression("-53+-2")
        self.assertEqual(
            "-53 -2 + ",
            expr.result(),
            "ERROR: Double negative term expression",
        )

    def test_double_term_operands(self):
        """
        Tests a set of operands
        """
        expr = Expression("53+2")
        self.assertEqual(
            "53 2 + ", expr.result(), "ERROR: Additive expression"
        )
        expr = Expression("53-2")
        self.assertEqual(
            "53 2 - ", expr.result(), "ERROR: Subtrative expression"
        )
        expr = Expression("53*2")
        self.assertEqual(
            "53 2 * ", expr.result(), "ERROR: Multiplicative expression"
        )
        expr = Expression("53/2")
        self.assertEqual("53 2 / ", expr.result(), "ERROR: Divide expression")

    def test_triple_term_expression(self):
        """
        Tests a set of triple term expressions
        """
        expr = Expression("53+2+37")
        self.assertEqual(
            "53 2 37 + + ", expr.result(), "ERROR: Add/Add expression"
        )
        expr = Expression("53+2*37")
        self.assertEqual(
            "53 2 37 * + ", expr.result(), "ERROR: Add/Multiply expression"
        )
        expr = Expression("53*2+37")
        self.assertEqual(
            "53 2 * 37 + ", expr.result(), "ERROR: Multiply/Add expression"
        )
        expr = Expression("53*2*37")
        self.assertEqual(
            "53 2 37 * * ",
            expr.result(),
            "ERROR: Multiply/Multiply expression",
        )

    def test_whitespace_expression(self):
        """
        Tests a set of expressions with a variety of whitespace
        """
        expr = Expression("53+2+37")
        self.assertEqual(
            "53 2 37 + + ", expr.result(), "ERROR: No whitespace expression"
        )
        expr = Expression("53 + 2 + 37")
        self.assertEqual(
            "53 2 37 + + ",
            expr.result(),
            "ERROR: Infixed whitespace expression",
        )
        expr = Expression(" 53+2+37 ")
        self.assertEqual(
            "53 2 37 + + ",
            expr.result(),
            "ERROR: Pre/post-fixed whitespace expression",
        )
        expr = Expression(" 53 + 2 + 37 ")
        self.assertEqual(
            "53 2 37 + + ",
            expr.result(),
            "ERROR: Pre/post/in-fixed whitespace expression",
        )
        expr = Expression("  53  +  2  +  37  ")
        self.assertEqual(
            "53 2 37 + + ",
            expr.result(),
            "ERROR: Multiple whitespace expression",
        )

        # This test should throw an exception - spaces in between operands
        # should give an error
        with self.assertRaises(SyntaxError):
            expr = Expression("  53  +  -  2  +  37  ")
            expr.parse()