← Back to branch summary

~free.ekanayaka/storm/any-expr

« back to all changes in this revision

Viewing changes to tests/expr.py

  • Committer: James Henstridge
  • Date: 2009-06-18 15:18:56 UTC
  • mfrom: (304.2.7 storm.bug-349482)
  • Revision ID: james@jamesh.id.au-20090618151856-6h05868g4j0ogkfw
Change compile_python so that constants can be injected into the matcher.

This allows compile_python to work on the class of expressions 
containing values whose repr() is not a valid Python expression.  It 
also removes the need to construct new copies of values in the matcher.
[r=therve,niemeyer][f=349482]

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/expr.py
1937
1937
 
1938
1938
    def test_compile_sequence(self):
1939
1939
        expr = [elem1, Variable(1), (Variable(2), None)]
1940
 
        py_expr = compile_python(expr)
1941
 
        self.assertEquals(py_expr, "elem1, 1, 2, None")
 
1940
        state = State()
 
1941
        py_expr = compile_python(expr, state)
 
1942
        self.assertEquals(py_expr, "elem1, _0, _1, None")
 
1943
        self.assertEquals(state.parameters, [1, 2])
1942
1944
 
1943
1945
    def test_compile_invalid(self):
1944
1946
        self.assertRaises(CompileError, compile_python, object())
1965
1967
        self.assertEquals(py_expr, "1L")
1966
1968
 
1967
1969
    def test_bool(self):
1968
 
        py_expr = compile_python(True)
1969
 
        self.assertEquals(py_expr, "True")
 
1970
        state = State()
 
1971
        py_expr = compile_python(True, state)
 
1972
        self.assertEquals(py_expr, "_0")
 
1973
        self.assertEquals(state.parameters, [True])
1970
1974
 
1971
1975
    def test_float(self):
1972
1976
        py_expr = compile_python(1.1)
1974
1978
 
1975
1979
    def test_datetime(self):
1976
1980
        dt = datetime(1977, 5, 4, 12, 34)
1977
 
        py_expr = compile_python(dt)
1978
 
        self.assertEquals(py_expr, repr(dt))
 
1981
        state = State()
 
1982
        py_expr = compile_python(dt, state)
 
1983
        self.assertEquals(py_expr, "_0")
 
1984
        self.assertEquals(state.parameters, [dt])
1979
1985
 
1980
1986
    def test_date(self):
1981
1987
        d = date(1977, 5, 4)
1982
 
        py_expr = compile_python(d)
1983
 
        self.assertEquals(py_expr, repr(d))
 
1988
        state = State()
 
1989
        py_expr = compile_python(d, state)
 
1990
        self.assertEquals(py_expr, "_0")
 
1991
        self.assertEquals(state.parameters, [d])
1984
1992
 
1985
1993
    def test_time(self):
1986
1994
        t = time(12, 34)
1987
 
        py_expr = compile_python(t)
1988
 
        self.assertEquals(py_expr, repr(t))
 
1995
        state = State()
 
1996
        py_expr = compile_python(t, state)
 
1997
        self.assertEquals(py_expr, "_0")
 
1998
        self.assertEquals(state.parameters, [t])
1989
1999
 
1990
2000
    def test_timedelta(self):
1991
2001
        td = timedelta(days=1, seconds=2, microseconds=3)
1992
 
        py_expr = compile_python(td)
1993
 
        self.assertEquals(py_expr, repr(td))
 
2002
        state = State()
 
2003
        py_expr = compile_python(td, state)
 
2004
        self.assertEquals(py_expr, "_0")
 
2005
        self.assertEquals(state.parameters, [td])
1994
2006
 
1995
2007
    def test_none(self):
1996
2008
        py_expr = compile_python(None)
1998
2010
 
1999
2011
    def test_column(self):
2000
2012
        expr = Column(column1)
2001
 
        py_expr = compile_python(expr)
2002
 
        self.assertEquals(py_expr, "get_column('column1')")
 
2013
        state = State()
 
2014
        py_expr = compile_python(expr, state)
 
2015
        self.assertEquals(py_expr, "get_column(_0)")
 
2016
        self.assertEquals(state.parameters, [expr])
2003
2017
 
2004
2018
    def test_column_table(self):
2005
2019
        expr = Column(column1, table1)
2006
 
        py_expr = compile_python(expr)
2007
 
        self.assertEquals(py_expr, "get_column('column1')")
 
2020
        state = State()
 
2021
        py_expr = compile_python(expr, state)
 
2022
        self.assertEquals(py_expr, "get_column(_0)")
 
2023
        self.assertEquals(state.parameters, [expr])
2008
2024
 
2009
2025
    def test_variable(self):
2010
2026
        expr = Variable("value")
2011
 
        py_expr = compile_python(expr)
2012
 
        self.assertEquals(py_expr, "'value'")
 
2027
        state = State()
 
2028
        py_expr = compile_python(expr, state)
 
2029
        self.assertEquals(py_expr, "_0")
 
2030
        self.assertEquals(state.parameters, ["value"])
2013
2031
 
2014
2032
    def test_eq(self):
2015
2033
        expr = Eq(Variable(1), Variable(2))
2016
 
        py_expr = compile_python(expr)
2017
 
        self.assertEquals(py_expr, "1 == 2")
 
2034
        state = State()
 
2035
        py_expr = compile_python(expr, state)
 
2036
        self.assertEquals(py_expr, "_0 == _1")
 
2037
        self.assertEquals(state.parameters, [1, 2])
2018
2038
 
2019
2039
    def test_ne(self):
2020
2040
        expr = Ne(Variable(1), Variable(2))
2021
 
        py_expr = compile_python(expr)
2022
 
        self.assertEquals(py_expr, "1 != 2")
 
2041
        state = State()
 
2042
        py_expr = compile_python(expr, state)
 
2043
        self.assertEquals(py_expr, "_0 != _1")
 
2044
        self.assertEquals(state.parameters, [1, 2])
2023
2045
 
2024
2046
    def test_gt(self):
2025
2047
        expr = Gt(Variable(1), Variable(2))
2026
 
        py_expr = compile_python(expr)
2027
 
        self.assertEquals(py_expr, "1 > 2")
 
2048
        state = State()
 
2049
        py_expr = compile_python(expr, state)
 
2050
        self.assertEquals(py_expr, "_0 > _1")
 
2051
        self.assertEquals(state.parameters, [1, 2])
2028
2052
 
2029
2053
    def test_ge(self):
2030
2054
        expr = Ge(Variable(1), Variable(2))
2031
 
        py_expr = compile_python(expr)
2032
 
        self.assertEquals(py_expr, "1 >= 2")
 
2055
        state = State()
 
2056
        py_expr = compile_python(expr, state)
 
2057
        self.assertEquals(py_expr, "_0 >= _1")
 
2058
        self.assertEquals(state.parameters, [1, 2])
2033
2059
 
2034
2060
    def test_lt(self):
2035
2061
        expr = Lt(Variable(1), Variable(2))
2036
 
        py_expr = compile_python(expr)
2037
 
        self.assertEquals(py_expr, "1 < 2")
 
2062
        state = State()
 
2063
        py_expr = compile_python(expr, state)
 
2064
        self.assertEquals(py_expr, "_0 < _1")
 
2065
        self.assertEquals(state.parameters, [1, 2])
2038
2066
 
2039
2067
    def test_le(self):
2040
2068
        expr = Le(Variable(1), Variable(2))
2041
 
        py_expr = compile_python(expr)
2042
 
        self.assertEquals(py_expr, "1 <= 2")
 
2069
        state = State()
 
2070
        py_expr = compile_python(expr, state)
 
2071
        self.assertEquals(py_expr, "_0 <= _1")
 
2072
        self.assertEquals(state.parameters, [1, 2])
2043
2073
 
2044
2074
    def test_lshift(self):
2045
2075
        expr = LShift(Variable(1), Variable(2))
2046
 
        py_expr = compile_python(expr)
2047
 
        self.assertEquals(py_expr, "1<<2")
 
2076
        state = State()
 
2077
        py_expr = compile_python(expr, state)
 
2078
        self.assertEquals(py_expr, "_0<<_1")
 
2079
        self.assertEquals(state.parameters, [1, 2])
2048
2080
 
2049
2081
    def test_rshift(self):
2050
2082
        expr = RShift(Variable(1), Variable(2))
2051
 
        py_expr = compile_python(expr)
2052
 
        self.assertEquals(py_expr, "1>>2")
 
2083
        state = State()
 
2084
        py_expr = compile_python(expr, state)
 
2085
        self.assertEquals(py_expr, "_0>>_1")
 
2086
        self.assertEquals(state.parameters, [1, 2])
2053
2087
 
2054
2088
    def test_in(self):
2055
2089
        expr = In(Variable(1), Variable(2))
2056
 
        py_expr = compile_python(expr)
2057
 
        self.assertEquals(py_expr, "1 in (2,)")
 
2090
        state = State()
 
2091
        py_expr = compile_python(expr, state)
 
2092
        self.assertEquals(py_expr, "_0 in (_1,)")
 
2093
        self.assertEquals(state.parameters, [1, 2])
2058
2094
 
2059
2095
    def test_and(self):
2060
2096
        expr = And(elem1, elem2, And(elem3, elem4))
2109
2145
 
2110
2146
        match = compile_python.get_matcher((col1 > 10) & (col2 < 10))
2111
2147
 
2112
 
        self.assertTrue(match({"column1": 15, "column2": 5}.get))
2113
 
        self.assertFalse(match({"column1": 5, "column2": 15}.get))
 
2148
        self.assertTrue(match({col1: 15, col2: 5}.get))
 
2149
        self.assertFalse(match({col1: 5, col2: 15}.get))
 
2150
 
 
2151
    def test_match_bad_repr(self):
 
2152
        """The get_matcher() works for expressions containing values
 
2153
        whose repr is not valid Python syntax."""
 
2154
        class BadRepr(object):
 
2155
            def __repr__(self):
 
2156
                return "$Not a valid Python expression$"
 
2157
 
 
2158
        value = BadRepr()
 
2159
        col1 = Column(column1)
 
2160
        match = compile_python.get_matcher(col1 == Variable(value))
 
2161
        self.assertTrue(match({col1: value}.get))
2114
2162
 
2115
2163
 
2116
2164
class LazyValueExprTest(TestHelper):