Merge lp:~cjwatson/storm/expr-spacing into lp:storm
- expr-spacing
- Merge into trunk
Proposed by
Colin Watson
| Status: | Merged |
|---|---|
| Merged at revision: | 542 |
| Proposed branch: | lp:~cjwatson/storm/expr-spacing |
| Merge into: | lp:storm |
| Diff against target: |
298 lines (+47/-37) 4 files modified
NEWS (+8/-0) storm/expr.py (+7/-7) storm/tests/databases/postgres.py (+1/-1) storm/tests/expr.py (+31/-29) |
| To merge this branch: | bzr merge lp:~cjwatson/storm/expr-spacing |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Simon Poirier (community) | Approve | ||
|
Review via email:
|
|||
Commit message
Add whitespace around "<<", ">>", "+", "-", "*", "/", and "%" operators.
Description of the change
I ran into this when using flask-storm's RequestTracer, which uses sqlparse to help it substitute parameters in its trace output; it was getting confused because sqlparse parses "expr+%s" as "expr", "+%", "s" rather than "expr", "+", "%s". Adding surrounding whitespace removes the ambiguity here.
To post a comment you must log in.
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'NEWS' | |||
| 2 | --- NEWS 2019-11-21 16:06:52 +0000 | |||
| 3 | +++ NEWS 2019-12-09 17:40:55 +0000 | |||
| 4 | @@ -1,6 +1,14 @@ | |||
| 5 | 1 | 0.23 (XXXX-XX-XX) | 1 | 0.23 (XXXX-XX-XX) |
| 6 | 2 | ================= | 2 | ================= |
| 7 | 3 | 3 | ||
| 8 | 4 | Improvements | ||
| 9 | 5 | ------------ | ||
| 10 | 6 | |||
| 11 | 7 | - Add whitespace around "<<", ">>", "+", "-", "*", "/", and "%" operators. | ||
| 12 | 8 | This helps to avoid confusion in tracers, since they run before parameter | ||
| 13 | 9 | substitution: for example, sqlparse parses "expr+%s" as "expr", "+%", "s" | ||
| 14 | 10 | rather than "expr", "+", "%s". | ||
| 15 | 11 | |||
| 16 | 4 | Bug fixes | 12 | Bug fixes |
| 17 | 5 | --------- | 13 | --------- |
| 18 | 6 | 14 | ||
| 19 | 7 | 15 | ||
| 20 | === modified file 'storm/expr.py' | |||
| 21 | --- storm/expr.py 2019-09-17 09:35:10 +0000 | |||
| 22 | +++ storm/expr.py 2019-12-09 17:40:55 +0000 | |||
| 23 | @@ -1091,11 +1091,11 @@ | |||
| 24 | 1091 | 1091 | ||
| 25 | 1092 | class RShift(BinaryOper): | 1092 | class RShift(BinaryOper): |
| 26 | 1093 | __slots__ = () | 1093 | __slots__ = () |
| 28 | 1094 | oper = ">>" | 1094 | oper = " >> " |
| 29 | 1095 | 1095 | ||
| 30 | 1096 | class LShift(BinaryOper): | 1096 | class LShift(BinaryOper): |
| 31 | 1097 | __slots__ = () | 1097 | __slots__ = () |
| 33 | 1098 | oper = "<<" | 1098 | oper = " << " |
| 34 | 1099 | 1099 | ||
| 35 | 1100 | 1100 | ||
| 36 | 1101 | class Like(BinaryOper): | 1101 | class Like(BinaryOper): |
| 37 | @@ -1139,23 +1139,23 @@ | |||
| 38 | 1139 | 1139 | ||
| 39 | 1140 | class Add(CompoundOper): | 1140 | class Add(CompoundOper): |
| 40 | 1141 | __slots__ = () | 1141 | __slots__ = () |
| 42 | 1142 | oper = "+" | 1142 | oper = " + " |
| 43 | 1143 | 1143 | ||
| 44 | 1144 | class Sub(NonAssocBinaryOper): | 1144 | class Sub(NonAssocBinaryOper): |
| 45 | 1145 | __slots__ = () | 1145 | __slots__ = () |
| 47 | 1146 | oper = "-" | 1146 | oper = " - " |
| 48 | 1147 | 1147 | ||
| 49 | 1148 | class Mul(CompoundOper): | 1148 | class Mul(CompoundOper): |
| 50 | 1149 | __slots__ = () | 1149 | __slots__ = () |
| 52 | 1150 | oper = "*" | 1150 | oper = " * " |
| 53 | 1151 | 1151 | ||
| 54 | 1152 | class Div(NonAssocBinaryOper): | 1152 | class Div(NonAssocBinaryOper): |
| 55 | 1153 | __slots__ = () | 1153 | __slots__ = () |
| 57 | 1154 | oper = "/" | 1154 | oper = " / " |
| 58 | 1155 | 1155 | ||
| 59 | 1156 | class Mod(NonAssocBinaryOper): | 1156 | class Mod(NonAssocBinaryOper): |
| 60 | 1157 | __slots__ = () | 1157 | __slots__ = () |
| 62 | 1158 | oper = "%" | 1158 | oper = " % " |
| 63 | 1159 | 1159 | ||
| 64 | 1160 | 1160 | ||
| 65 | 1161 | class And(CompoundOper): | 1161 | class And(CompoundOper): |
| 66 | 1162 | 1162 | ||
| 67 | === modified file 'storm/tests/databases/postgres.py' | |||
| 68 | --- storm/tests/databases/postgres.py 2019-11-21 16:06:52 +0000 | |||
| 69 | +++ storm/tests/databases/postgres.py 2019-12-09 17:40:55 +0000 | |||
| 70 | @@ -285,7 +285,7 @@ | |||
| 71 | 285 | self.assertEqual(statement, | 285 | self.assertEqual(statement, |
| 72 | 286 | 'SELECT * FROM ' | 286 | 'SELECT * FROM ' |
| 73 | 287 | '((SELECT 1 AS id) UNION ALL (SELECT 1)) AS "_1" ' | 287 | '((SELECT 1 AS id) UNION ALL (SELECT 1)) AS "_1" ' |
| 75 | 288 | 'ORDER BY id+? LIMIT 1 OFFSET 1') | 288 | 'ORDER BY id + ? LIMIT 1 OFFSET 1') |
| 76 | 289 | self.assertVariablesEqual(state.parameters, [Variable(1)]) | 289 | self.assertVariablesEqual(state.parameters, [Variable(1)]) |
| 77 | 290 | 290 | ||
| 78 | 291 | result = self.connection.execute(expr) | 291 | result = self.connection.execute(expr) |
| 79 | 292 | 292 | ||
| 80 | === modified file 'storm/tests/expr.py' | |||
| 81 | --- storm/tests/expr.py 2019-11-21 16:06:52 +0000 | |||
| 82 | +++ storm/tests/expr.py 2019-12-09 17:40:55 +0000 | |||
| 83 | @@ -502,7 +502,8 @@ | |||
| 84 | 502 | expr = And(e[1], Or(e[2], e[3]), | 502 | expr = And(e[1], Or(e[2], e[3]), |
| 85 | 503 | Add(e[4], Mul(e[5], Sub(e[6], Div(e[7], Div(e[8], e[9])))))) | 503 | Add(e[4], Mul(e[5], Sub(e[6], Div(e[7], Div(e[8], e[9])))))) |
| 86 | 504 | statement = compile(expr) | 504 | statement = compile(expr) |
| 88 | 505 | self.assertEqual(statement, "1 AND (2 OR 3) AND 4+5*(6-7/(8/9))") | 505 | self.assertEqual(statement, |
| 89 | 506 | "1 AND (2 OR 3) AND 4 + 5 * (6 - 7 / (8 / 9))") | ||
| 90 | 506 | 507 | ||
| 91 | 507 | expr = Func1(Select(Count()), [Select(Count())]) | 508 | expr = Func1(Select(Count()), [Select(Count())]) |
| 92 | 508 | statement = compile(expr) | 509 | statement = compile(expr) |
| 93 | @@ -1196,26 +1197,26 @@ | |||
| 94 | 1196 | expr = LShift(Func1(), Func2()) | 1197 | expr = LShift(Func1(), Func2()) |
| 95 | 1197 | state = State() | 1198 | state = State() |
| 96 | 1198 | statement = compile(expr, state) | 1199 | statement = compile(expr, state) |
| 98 | 1199 | self.assertEqual(statement, "func1()<<func2()") | 1200 | self.assertEqual(statement, "func1() << func2()") |
| 99 | 1200 | self.assertEqual(state.parameters, []) | 1201 | self.assertEqual(state.parameters, []) |
| 100 | 1201 | 1202 | ||
| 101 | 1202 | expr = Func1() << "value" | 1203 | expr = Func1() << "value" |
| 102 | 1203 | state = State() | 1204 | state = State() |
| 103 | 1204 | statement = compile(expr, state) | 1205 | statement = compile(expr, state) |
| 105 | 1205 | self.assertEqual(statement, "func1()<<?") | 1206 | self.assertEqual(statement, "func1() << ?") |
| 106 | 1206 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1207 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 107 | 1207 | 1208 | ||
| 108 | 1208 | def test_rshift(self): | 1209 | def test_rshift(self): |
| 109 | 1209 | expr = RShift(Func1(), Func2()) | 1210 | expr = RShift(Func1(), Func2()) |
| 110 | 1210 | state = State() | 1211 | state = State() |
| 111 | 1211 | statement = compile(expr, state) | 1212 | statement = compile(expr, state) |
| 113 | 1212 | self.assertEqual(statement, "func1()>>func2()") | 1213 | self.assertEqual(statement, "func1() >> func2()") |
| 114 | 1213 | self.assertEqual(state.parameters, []) | 1214 | self.assertEqual(state.parameters, []) |
| 115 | 1214 | 1215 | ||
| 116 | 1215 | expr = Func1() >> "value" | 1216 | expr = Func1() >> "value" |
| 117 | 1216 | state = State() | 1217 | state = State() |
| 118 | 1217 | statement = compile(expr, state) | 1218 | statement = compile(expr, state) |
| 120 | 1218 | self.assertEqual(statement, "func1()>>?") | 1219 | self.assertEqual(statement, "func1() >> ?") |
| 121 | 1219 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1220 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 122 | 1220 | 1221 | ||
| 123 | 1221 | def test_like(self): | 1222 | def test_like(self): |
| 124 | @@ -1311,83 +1312,83 @@ | |||
| 125 | 1311 | expr = Add(elem1, elem2, Add(elem3, elem4)) | 1312 | expr = Add(elem1, elem2, Add(elem3, elem4)) |
| 126 | 1312 | state = State() | 1313 | state = State() |
| 127 | 1313 | statement = compile(expr, state) | 1314 | statement = compile(expr, state) |
| 129 | 1314 | self.assertEqual(statement, "elem1+elem2+elem3+elem4") | 1315 | self.assertEqual(statement, "elem1 + elem2 + elem3 + elem4") |
| 130 | 1315 | self.assertEqual(state.parameters, []) | 1316 | self.assertEqual(state.parameters, []) |
| 131 | 1316 | 1317 | ||
| 132 | 1317 | expr = Func1() + "value" | 1318 | expr = Func1() + "value" |
| 133 | 1318 | state = State() | 1319 | state = State() |
| 134 | 1319 | statement = compile(expr, state) | 1320 | statement = compile(expr, state) |
| 136 | 1320 | self.assertEqual(statement, "func1()+?") | 1321 | self.assertEqual(statement, "func1() + ?") |
| 137 | 1321 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1322 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 138 | 1322 | 1323 | ||
| 139 | 1323 | def test_sub(self): | 1324 | def test_sub(self): |
| 140 | 1324 | expr = Sub(elem1, Sub(elem2, elem3)) | 1325 | expr = Sub(elem1, Sub(elem2, elem3)) |
| 141 | 1325 | state = State() | 1326 | state = State() |
| 142 | 1326 | statement = compile(expr, state) | 1327 | statement = compile(expr, state) |
| 144 | 1327 | self.assertEqual(statement, "elem1-(elem2-elem3)") | 1328 | self.assertEqual(statement, "elem1 - (elem2 - elem3)") |
| 145 | 1328 | self.assertEqual(state.parameters, []) | 1329 | self.assertEqual(state.parameters, []) |
| 146 | 1329 | 1330 | ||
| 147 | 1330 | expr = Sub(Sub(elem1, elem2), elem3) | 1331 | expr = Sub(Sub(elem1, elem2), elem3) |
| 148 | 1331 | state = State() | 1332 | state = State() |
| 149 | 1332 | statement = compile(expr, state) | 1333 | statement = compile(expr, state) |
| 151 | 1333 | self.assertEqual(statement, "elem1-elem2-elem3") | 1334 | self.assertEqual(statement, "elem1 - elem2 - elem3") |
| 152 | 1334 | self.assertVariablesEqual(state.parameters, []) | 1335 | self.assertVariablesEqual(state.parameters, []) |
| 153 | 1335 | 1336 | ||
| 154 | 1336 | expr = Func1() - "value" | 1337 | expr = Func1() - "value" |
| 155 | 1337 | state = State() | 1338 | state = State() |
| 156 | 1338 | statement = compile(expr, state) | 1339 | statement = compile(expr, state) |
| 158 | 1339 | self.assertEqual(statement, "func1()-?") | 1340 | self.assertEqual(statement, "func1() - ?") |
| 159 | 1340 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1341 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 160 | 1341 | 1342 | ||
| 161 | 1342 | def test_mul(self): | 1343 | def test_mul(self): |
| 162 | 1343 | expr = Mul(elem1, elem2, Mul(elem3, elem4)) | 1344 | expr = Mul(elem1, elem2, Mul(elem3, elem4)) |
| 163 | 1344 | state = State() | 1345 | state = State() |
| 164 | 1345 | statement = compile(expr, state) | 1346 | statement = compile(expr, state) |
| 166 | 1346 | self.assertEqual(statement, "elem1*elem2*elem3*elem4") | 1347 | self.assertEqual(statement, "elem1 * elem2 * elem3 * elem4") |
| 167 | 1347 | self.assertEqual(state.parameters, []) | 1348 | self.assertEqual(state.parameters, []) |
| 168 | 1348 | 1349 | ||
| 169 | 1349 | expr = Func1() * "value" | 1350 | expr = Func1() * "value" |
| 170 | 1350 | state = State() | 1351 | state = State() |
| 171 | 1351 | statement = compile(expr, state) | 1352 | statement = compile(expr, state) |
| 173 | 1352 | self.assertEqual(statement, "func1()*?") | 1353 | self.assertEqual(statement, "func1() * ?") |
| 174 | 1353 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1354 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 175 | 1354 | 1355 | ||
| 176 | 1355 | def test_div(self): | 1356 | def test_div(self): |
| 177 | 1356 | expr = Div(elem1, Div(elem2, elem3)) | 1357 | expr = Div(elem1, Div(elem2, elem3)) |
| 178 | 1357 | state = State() | 1358 | state = State() |
| 179 | 1358 | statement = compile(expr, state) | 1359 | statement = compile(expr, state) |
| 181 | 1359 | self.assertEqual(statement, "elem1/(elem2/elem3)") | 1360 | self.assertEqual(statement, "elem1 / (elem2 / elem3)") |
| 182 | 1360 | self.assertEqual(state.parameters, []) | 1361 | self.assertEqual(state.parameters, []) |
| 183 | 1361 | 1362 | ||
| 184 | 1362 | expr = Div(Div(elem1, elem2), elem3) | 1363 | expr = Div(Div(elem1, elem2), elem3) |
| 185 | 1363 | state = State() | 1364 | state = State() |
| 186 | 1364 | statement = compile(expr, state) | 1365 | statement = compile(expr, state) |
| 188 | 1365 | self.assertEqual(statement, "elem1/elem2/elem3") | 1366 | self.assertEqual(statement, "elem1 / elem2 / elem3") |
| 189 | 1366 | self.assertEqual(state.parameters, []) | 1367 | self.assertEqual(state.parameters, []) |
| 190 | 1367 | 1368 | ||
| 191 | 1368 | expr = Func1() / "value" | 1369 | expr = Func1() / "value" |
| 192 | 1369 | state = State() | 1370 | state = State() |
| 193 | 1370 | statement = compile(expr, state) | 1371 | statement = compile(expr, state) |
| 195 | 1371 | self.assertEqual(statement, "func1()/?") | 1372 | self.assertEqual(statement, "func1() / ?") |
| 196 | 1372 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1373 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 197 | 1373 | 1374 | ||
| 198 | 1374 | def test_mod(self): | 1375 | def test_mod(self): |
| 199 | 1375 | expr = Mod(elem1, Mod(elem2, elem3)) | 1376 | expr = Mod(elem1, Mod(elem2, elem3)) |
| 200 | 1376 | state = State() | 1377 | state = State() |
| 201 | 1377 | statement = compile(expr, state) | 1378 | statement = compile(expr, state) |
| 203 | 1378 | self.assertEqual(statement, "elem1%(elem2%elem3)") | 1379 | self.assertEqual(statement, "elem1 % (elem2 % elem3)") |
| 204 | 1379 | self.assertEqual(state.parameters, []) | 1380 | self.assertEqual(state.parameters, []) |
| 205 | 1380 | 1381 | ||
| 206 | 1381 | expr = Mod(Mod(elem1, elem2), elem3) | 1382 | expr = Mod(Mod(elem1, elem2), elem3) |
| 207 | 1382 | state = State() | 1383 | state = State() |
| 208 | 1383 | statement = compile(expr, state) | 1384 | statement = compile(expr, state) |
| 210 | 1384 | self.assertEqual(statement, "elem1%elem2%elem3") | 1385 | self.assertEqual(statement, "elem1 % elem2 % elem3") |
| 211 | 1385 | self.assertEqual(state.parameters, []) | 1386 | self.assertEqual(state.parameters, []) |
| 212 | 1386 | 1387 | ||
| 213 | 1387 | expr = Func1() % "value" | 1388 | expr = Func1() % "value" |
| 214 | 1388 | state = State() | 1389 | state = State() |
| 215 | 1389 | statement = compile(expr, state) | 1390 | statement = compile(expr, state) |
| 217 | 1390 | self.assertEqual(statement, "func1()%?") | 1391 | self.assertEqual(statement, "func1() % ?") |
| 218 | 1391 | self.assertVariablesEqual(state.parameters, [Variable("value")]) | 1392 | self.assertVariablesEqual(state.parameters, [Variable("value")]) |
| 219 | 1392 | 1393 | ||
| 220 | 1393 | def test_func(self): | 1394 | def test_func(self): |
| 221 | @@ -2138,7 +2139,8 @@ | |||
| 222 | 2138 | expr = And(e[1], Or(e[2], e[3]), | 2139 | expr = And(e[1], Or(e[2], e[3]), |
| 223 | 2139 | Add(e[4], Mul(e[5], Sub(e[6], Div(e[7], Div(e[8], e[9])))))) | 2140 | Add(e[4], Mul(e[5], Sub(e[6], Div(e[7], Div(e[8], e[9])))))) |
| 224 | 2140 | py_expr = compile_python(expr) | 2141 | py_expr = compile_python(expr) |
| 226 | 2141 | self.assertEqual(py_expr, "1 and (2 or 3) and 4+5*(6-7/(8/9))") | 2142 | self.assertEqual(py_expr, |
| 227 | 2143 | "1 and (2 or 3) and 4 + 5 * (6 - 7 / (8 / 9))") | ||
| 228 | 2142 | 2144 | ||
| 229 | 2143 | def test_get_precedence(self): | 2145 | def test_get_precedence(self): |
| 230 | 2144 | self.assertTrue(compile_python.get_precedence(Or) < | 2146 | self.assertTrue(compile_python.get_precedence(Or) < |
| 231 | @@ -2290,14 +2292,14 @@ | |||
| 232 | 2290 | expr = LShift(Variable(1), Variable(2)) | 2292 | expr = LShift(Variable(1), Variable(2)) |
| 233 | 2291 | state = State() | 2293 | state = State() |
| 234 | 2292 | py_expr = compile_python(expr, state) | 2294 | py_expr = compile_python(expr, state) |
| 236 | 2293 | self.assertEqual(py_expr, "_0<<_1") | 2295 | self.assertEqual(py_expr, "_0 << _1") |
| 237 | 2294 | self.assertEqual(state.parameters, [1, 2]) | 2296 | self.assertEqual(state.parameters, [1, 2]) |
| 238 | 2295 | 2297 | ||
| 239 | 2296 | def test_rshift(self): | 2298 | def test_rshift(self): |
| 240 | 2297 | expr = RShift(Variable(1), Variable(2)) | 2299 | expr = RShift(Variable(1), Variable(2)) |
| 241 | 2298 | state = State() | 2300 | state = State() |
| 242 | 2299 | py_expr = compile_python(expr, state) | 2301 | py_expr = compile_python(expr, state) |
| 244 | 2300 | self.assertEqual(py_expr, "_0>>_1") | 2302 | self.assertEqual(py_expr, "_0 >> _1") |
| 245 | 2301 | self.assertEqual(state.parameters, [1, 2]) | 2303 | self.assertEqual(state.parameters, [1, 2]) |
| 246 | 2302 | 2304 | ||
| 247 | 2303 | def test_in(self): | 2305 | def test_in(self): |
| 248 | @@ -2320,7 +2322,7 @@ | |||
| 249 | 2320 | def test_add(self): | 2322 | def test_add(self): |
| 250 | 2321 | expr = Add(elem1, elem2, Add(elem3, elem4)) | 2323 | expr = Add(elem1, elem2, Add(elem3, elem4)) |
| 251 | 2322 | py_expr = compile_python(expr) | 2324 | py_expr = compile_python(expr) |
| 253 | 2323 | self.assertEqual(py_expr, "elem1+elem2+elem3+elem4") | 2325 | self.assertEqual(py_expr, "elem1 + elem2 + elem3 + elem4") |
| 254 | 2324 | 2326 | ||
| 255 | 2325 | def test_neg(self): | 2327 | def test_neg(self): |
| 256 | 2326 | expr = Neg(elem1) | 2328 | expr = Neg(elem1) |
| 257 | @@ -2330,34 +2332,34 @@ | |||
| 258 | 2330 | def test_sub(self): | 2332 | def test_sub(self): |
| 259 | 2331 | expr = Sub(elem1, Sub(elem2, elem3)) | 2333 | expr = Sub(elem1, Sub(elem2, elem3)) |
| 260 | 2332 | py_expr = compile_python(expr) | 2334 | py_expr = compile_python(expr) |
| 262 | 2333 | self.assertEqual(py_expr, "elem1-(elem2-elem3)") | 2335 | self.assertEqual(py_expr, "elem1 - (elem2 - elem3)") |
| 263 | 2334 | 2336 | ||
| 264 | 2335 | expr = Sub(Sub(elem1, elem2), elem3) | 2337 | expr = Sub(Sub(elem1, elem2), elem3) |
| 265 | 2336 | py_expr = compile_python(expr) | 2338 | py_expr = compile_python(expr) |
| 267 | 2337 | self.assertEqual(py_expr, "elem1-elem2-elem3") | 2339 | self.assertEqual(py_expr, "elem1 - elem2 - elem3") |
| 268 | 2338 | 2340 | ||
| 269 | 2339 | def test_mul(self): | 2341 | def test_mul(self): |
| 270 | 2340 | expr = Mul(elem1, elem2, Mul(elem3, elem4)) | 2342 | expr = Mul(elem1, elem2, Mul(elem3, elem4)) |
| 271 | 2341 | py_expr = compile_python(expr) | 2343 | py_expr = compile_python(expr) |
| 273 | 2342 | self.assertEqual(py_expr, "elem1*elem2*elem3*elem4") | 2344 | self.assertEqual(py_expr, "elem1 * elem2 * elem3 * elem4") |
| 274 | 2343 | 2345 | ||
| 275 | 2344 | def test_div(self): | 2346 | def test_div(self): |
| 276 | 2345 | expr = Div(elem1, Div(elem2, elem3)) | 2347 | expr = Div(elem1, Div(elem2, elem3)) |
| 277 | 2346 | py_expr = compile_python(expr) | 2348 | py_expr = compile_python(expr) |
| 279 | 2347 | self.assertEqual(py_expr, "elem1/(elem2/elem3)") | 2349 | self.assertEqual(py_expr, "elem1 / (elem2 / elem3)") |
| 280 | 2348 | 2350 | ||
| 281 | 2349 | expr = Div(Div(elem1, elem2), elem3) | 2351 | expr = Div(Div(elem1, elem2), elem3) |
| 282 | 2350 | py_expr = compile_python(expr) | 2352 | py_expr = compile_python(expr) |
| 284 | 2351 | self.assertEqual(py_expr, "elem1/elem2/elem3") | 2353 | self.assertEqual(py_expr, "elem1 / elem2 / elem3") |
| 285 | 2352 | 2354 | ||
| 286 | 2353 | def test_mod(self): | 2355 | def test_mod(self): |
| 287 | 2354 | expr = Mod(elem1, Mod(elem2, elem3)) | 2356 | expr = Mod(elem1, Mod(elem2, elem3)) |
| 288 | 2355 | py_expr = compile_python(expr) | 2357 | py_expr = compile_python(expr) |
| 290 | 2356 | self.assertEqual(py_expr, "elem1%(elem2%elem3)") | 2358 | self.assertEqual(py_expr, "elem1 % (elem2 % elem3)") |
| 291 | 2357 | 2359 | ||
| 292 | 2358 | expr = Mod(Mod(elem1, elem2), elem3) | 2360 | expr = Mod(Mod(elem1, elem2), elem3) |
| 293 | 2359 | py_expr = compile_python(expr) | 2361 | py_expr = compile_python(expr) |
| 295 | 2360 | self.assertEqual(py_expr, "elem1%elem2%elem3") | 2362 | self.assertEqual(py_expr, "elem1 % elem2 % elem3") |
| 296 | 2361 | 2363 | ||
| 297 | 2362 | def test_match(self): | 2364 | def test_match(self): |
| 298 | 2363 | col1 = Column(column1) | 2365 | col1 = Column(column1) |
+1 LGTM