changeset 3 | e7e0ae78773e |
parent 0 | 2e8eeb919028 |
2:87cfa131b535 | 3:e7e0ae78773e |
---|---|
14 # |
14 # |
15 # Description: |
15 # Description: |
16 # |
16 # |
17 |
17 |
18 import unittest |
18 import unittest |
19 import sys, os |
19 |
20 import __init__ |
20 from cone.public import rules |
21 |
|
22 from cone.public.api import CompositeConfiguration, Feature |
|
23 from cone.public.rules import ASTInterpreter, RelationContainerImpl, RELATIONS, get_tokens |
|
24 from cone.public.rules import ParseException, DefaultContext, BaseRelation, RequireExpression, OPERATORS |
|
25 |
21 |
26 #### TEST RELATIONS #### |
22 #### TEST RELATIONS #### |
27 |
23 |
28 AA_BA = 'a.a require b.b' |
24 AA_BA = '${a.a} require ${b.b}' |
29 AB_BB = 'a.b require b.b' |
25 AB_BB = '${a.b} require ${b.b}' |
30 BA_CA = 'b.a require c.a and c.b and a.b' |
26 BA_CA = '${b.a} require ${c.a} and ${c.b} and ${a.b}' |
31 |
27 |
32 CB_DA = 'c.b require d.a' |
28 CB_DA = '${c.b} require ${d.a}' |
33 DA_DB = 'd.a require d.b' |
29 DA_DB = '${d.a} require ${d.b}' |
34 |
30 |
35 AC_AB_BA = 'a.c and a.a require b.a' |
31 AC_AB_BA = '${a.c} and ${a.a} require ${b.a}' |
36 |
32 |
37 EA_FSTAR = 'e.a require f.*' |
33 EA_FSTAR = '${e.a} require ${f.*}' |
38 |
34 |
39 TEST_RELATIONS = { |
35 TEST_RELATIONS = { |
40 'a.a' : [AA_BA], |
36 'a.a' : [AA_BA], |
41 'a.b' : [AB_BB], |
37 'a.b' : [AB_BB], |
42 'a.c' : [AC_AB_BA], |
38 'a.c' : [AC_AB_BA], |
44 'c.b' : [CB_DA], |
40 'c.b' : [CB_DA], |
45 'd.a' : [DA_DB], |
41 'd.a' : [DA_DB], |
46 'e.a' : [EA_FSTAR] |
42 'e.a' : [EA_FSTAR] |
47 } |
43 } |
48 |
44 |
45 #rules.RELATIONS[rules.BaseRelation.KEY] = rules.BaseRelation |
|
46 #rules.OPERATORS[rules.BaseRelation.KEY] = rules.BaseRelation |
|
47 |
|
49 class DummyRelationFactory(): |
48 class DummyRelationFactory(): |
50 def get_relations_for(self, configuration, ref): |
49 def get_relations_for(self, configuration, ref): |
51 rels = TEST_RELATIONS.get(ref) |
50 rels = TEST_RELATIONS.get(ref) |
52 |
51 |
53 if rels: |
52 if rels: |
54 relation_container = RelationContainerImpl() |
53 relation_container = rules.RelationContainerImpl() |
55 for rel in rels: |
54 for rel in rels: |
56 rel_s = rel.split(' ') |
55 rel_s = rel.split(' ') |
57 from_ref = rel_s[0] |
56 from_ref = rel_s[0] |
58 relation_name = 'require' |
57 relation_name = 'require' |
59 to_ref = ' '.join(rel_s[2:]) |
58 to_ref = ' '.join(rel_s[2:]) |
60 relation = RELATIONS.get(relation_name)(configuration, from_ref, to_ref) |
59 relation = rules.RELATIONS.get(relation_name)(configuration, from_ref, to_ref) |
61 relation_container.add_relation(relation) |
60 relation_container.add_relation(relation) |
62 propagated_relations = self.get_relations_for(configuration, to_ref) |
61 propagated_relations = self.get_relations_for(configuration, to_ref) |
63 if propagated_relations: |
62 if propagated_relations: |
64 for relation in propagated_relations: |
63 for relation in propagated_relations: |
65 relation_container.add_relation(relation) |
64 relation_container.add_relation(relation) |
80 } |
79 } |
81 |
80 |
82 def get_feature(self, ref): |
81 def get_feature(self, ref): |
83 return DummyConfiguration.VALUES.get(ref, False) |
82 return DummyConfiguration.VALUES.get(ref, False) |
84 |
83 |
85 class DummyContext(DefaultContext): |
84 class DummyContext(rules.DefaultContext): |
86 def handle_terminal(self, expression): |
85 def handle_terminal(self, expression): |
87 return DummyConfiguration.VALUES.get(expression, False) |
86 return DummyConfiguration.VALUES.get(expression, False) |
88 |
87 |
89 class DummyBaseRelation(BaseRelation): |
88 class DictContext(rules.DefaultContext): |
89 def handle_terminal(self, expression): |
|
90 return self.data.get(expression, None) |
|
91 |
|
92 def convert_value(self, value): |
|
93 if isinstance(value, (str, unicode)): |
|
94 return eval(value) |
|
95 else: |
|
96 return value |
|
97 |
|
98 def set(self, expression, value): |
|
99 self.data[expression] = value |
|
100 |
|
101 |
|
102 class DummyBaseRelation(rules.BaseRelation): |
|
90 def __init__(self, data, left, right): |
103 def __init__(self, data, left, right): |
91 self.context = DummyContext(data) |
104 self.context = DummyContext(data) |
92 super(DummyBaseRelation, self).__init__(data, left, right) |
105 super(DummyBaseRelation, self).__init__(data, left, right) |
93 |
106 |
94 class DummyRequireRelation(DummyBaseRelation): |
107 class DummyRequireRelation(DummyBaseRelation): |
96 |
109 |
97 def __init__(self, data, left, right): |
110 def __init__(self, data, left, right): |
98 self.context = DummyContext(data) |
111 self.context = DummyContext(data) |
99 super(DummyRequireRelation, self).__init__(data, left, right) |
112 super(DummyRequireRelation, self).__init__(data, left, right) |
100 |
113 |
101 RELATIONS[DummyRequireRelation.KEY] = DummyRequireRelation |
114 rules.RELATIONS[DummyRequireRelation.KEY] = DummyRequireRelation |
102 OPERATORS['require'] = RequireExpression |
115 rules.OPERATORS['require'] = rules.RequireExpression |
103 multilines = \ |
116 multilines = \ |
104 """ |
117 """ |
105 APs.AP configures KCRUidCommsDatCreator.KCommsDatCreatorInputFileName = 'VariantData_commsdat.xml' and |
118 APs.AP configures KCRUidCommsDatCreator.KCommsDatCreatorInputFileName = 'VariantData_commsdat.xml' and |
106 KCRUidStartupSettings.KCRKeyAccessPointPlugin = '0' and |
119 KCRUidStartupSettings.KCRKeyAccessPointPlugin = '0' and |
107 KCRUidStartupSettings.KCRKeyStreamingPlugin = '0' and |
120 KCRUidStartupSettings.KCRKeyStreamingPlugin = '0' and |
139 |
152 |
140 def test_not_has_ref_in_container(self): |
153 def test_not_has_ref_in_container(self): |
141 factory = DummyRelationFactory() |
154 factory = DummyRelationFactory() |
142 rels = factory.get_relations_for(self.configuration, 'c.b') |
155 rels = factory.get_relations_for(self.configuration, 'c.b') |
143 ret = rels.execute() |
156 ret = rels.execute() |
144 self.assertFalse(ret) |
157 self.assertTrue(ret) |
145 |
158 |
146 def test_two_on_the_left(self): |
159 def test_two_on_the_left(self): |
147 factory = DummyRelationFactory() |
160 factory = DummyRelationFactory() |
148 rels = factory.get_relations_for(self.configuration, 'a.c') |
161 rels = factory.get_relations_for(self.configuration, 'a.c') |
149 ret = rels.execute() |
162 ret = rels.execute() |
150 self.assertTrue(ret) |
163 self.assertTrue(ret) |
151 |
164 |
165 class TestExpressions(unittest.TestCase): |
|
166 def test_one_param_expression(self): |
|
167 exp = rules.OneParamExpression(None, rules.ValueTerminal(None, "10")) |
|
168 c = DictContext({}) |
|
169 self.assertEquals(exp.eval(c), 10) |
|
170 exp = rules.OneParamExpression(None, rules.ReferenceTerminal(None, "${foo}")) |
|
171 c = DictContext({'foo' : 'Foo string'}) |
|
172 self.assertEquals(exp.eval(c), 'Foo string') |
|
173 |
|
174 def test_neg_expression(self): |
|
175 exp = rules.NegExpression(None, rules.ValueTerminal(None, "10")) |
|
176 c = DictContext({}) |
|
177 self.assertEquals(exp.eval(c), -10) |
|
178 exp = rules.NegExpression(None, rules.ReferenceTerminal(None, "${foo}")) |
|
179 c = DictContext({'foo' : 2}) |
|
180 self.assertEquals(exp.eval(c), -2) |
|
181 |
|
182 def test_and_expression(self): |
|
183 exp = rules.AndExpression(None, rules.ValueTerminal(None, True), |
|
184 rules.ReferenceTerminal(None, "${foo}")) |
|
185 c = DictContext({'foo' : 1}) |
|
186 self.assertEquals(exp.eval(c), True) |
|
187 c = DictContext({'foo' : 0}) |
|
188 self.assertEquals(exp.eval(c), False) |
|
189 c = DictContext({'foo' : ""}) |
|
190 self.assertEquals(exp.eval(c), False) |
|
191 c = DictContext({'foo' : False}) |
|
192 self.assertEquals(exp.eval(c), False) |
|
193 c = DictContext({'foo' : True}) |
|
194 self.assertEquals(exp.eval(c), True) |
|
195 |
|
196 def test_minus_expression(self): |
|
197 exp = rules.MinusExpression(None, rules.ValueTerminal(None, "10"), rules.ReferenceTerminal(None, "${foo}")) |
|
198 c = DictContext({'foo' : 10}) |
|
199 self.assertEquals(exp.eval(c), 0) |
|
200 |
|
201 def test_plus_expression(self): |
|
202 exp = rules.PlusExpression(None, rules.ValueTerminal(None, "10"), rules.ReferenceTerminal(None, "${foo}")) |
|
203 c = DictContext({'foo' : 10}) |
|
204 self.assertEquals(exp.eval(c), 20) |
|
205 |
|
206 def test_mul_expression(self): |
|
207 exp = rules.MultiplyExpression(None, rules.ValueTerminal(None, "10"), rules.ReferenceTerminal(None, "${foo}")) |
|
208 c = DictContext({'foo' : 10}) |
|
209 self.assertEquals(exp.eval(c), 100) |
|
210 |
|
211 def test_div_expression(self): |
|
212 exp = rules.DivideExpression(None, rules.ValueTerminal(None, "10"), rules.ReferenceTerminal(None, "${foo}")) |
|
213 c = DictContext({'foo' : 10}) |
|
214 self.assertEquals(exp.eval(c), 1) |
|
215 |
|
216 def test_get_expressions_from_relation(self): |
|
217 rel = rules.RequireRelation(None,"${foo} == True","${test} = 2 and ${aaa} == ${bbb}") |
|
218 self.assertEquals(len(rel.get_expressions()), 11) |
|
219 |
|
220 def test_get_refs_from_relation(self): |
|
221 rel = rules.BaseRelation(None,"${foo} == True","${test} = 2 and ${aaa} == ${bbb}") |
|
222 self.assertEquals(rel.get_refs(), ['foo']) |
|
223 |
|
224 def test_set_expression(self): |
|
225 exp = rules.SetExpression(None,rules.ReferenceTerminal(None, "${t}"), rules.ValueTerminal(None, "10")) |
|
226 c = DictContext({'foo' : 10, 't' :None}) |
|
227 self.assertEquals(exp.eval(c), True) |
|
228 self.assertEquals(c.data['t'], 10) |
|
229 |
|
230 def test_set_expression_in_relation(self): |
|
231 rel = rules.RequireRelation(None,"1","${test} = 1") |
|
232 c = DictContext({'test' : None, 't' :None}) |
|
233 rel.execute(c) |
|
234 self.assertEquals(c.data['test'], 1) |
|
235 rel = rules.RequireRelation(None,"1","${test} = 2 and ${t} = 3") |
|
236 rel.execute(c) |
|
237 self.assertEquals(c.data['test'], 2) |
|
238 self.assertEquals(c.data['t'], 3) |
|
239 |
|
240 def test_set_expression_in_relation_and_get_set_elements(self): |
|
241 rel = rules.RequireRelation(None,"1","${test} = 2") |
|
242 self.assertEquals(rel.get_set_expressions()[0].left.get_ref(), 'test') |
|
243 |
|
244 rel = rules.RequireRelation(None,"1","${test} = 2 and ${t} = 3") |
|
245 self.assertEquals(len(rel.get_set_expressions()), 2) |
|
246 self.assertEquals(rel.get_set_expressions()[0].left.get_ref(), 'test') |
|
247 self.assertEquals(rel.get_set_expressions()[1].left.get_ref(), 't') |
|
248 |
|
249 def test_set_expression_in_relation_and_get_refs(self): |
|
250 rel = rules.RequireRelation(None,"${foo}","${test} = 2") |
|
251 self.assertEquals(rel.get_refs(), ['foo']) |
|
252 rel = rules.RequireRelation(None,"${foo}","${test} = 2 and ${t} = 3") |
|
253 self.assertEquals(rel.get_refs(), ['foo']) |
|
254 |
|
255 def test_set_expression_in_relation_and_get_set_refs(self): |
|
256 rel = rules.RequireRelation(None,"1","${test} = 2") |
|
257 self.assertEquals(rel.get_set_refs(), ['test']) |
|
258 |
|
259 rel = rules.RequireRelation(None,"1","${test} = 2 and ${t} = 3") |
|
260 self.assertEquals(rel.get_set_refs(),['test','t']) |
|
261 |
|
262 def test_set_expression_in_relation_with_string(self): |
|
263 rel = rules.RequireRelation(None,"1",'${test} = "foo "') |
|
264 c = DictContext({'test' : None, 't' :None}) |
|
265 rel.execute(c) |
|
266 self.assertEquals(c.data['test'], 'foo ') |
|
267 |
|
268 def test_set_expression_in_relation_with_string_concat(self): |
|
269 rel = rules.RequireRelation(None,"1",'${test} = "foo " + "bar"') |
|
270 c = DictContext({'test' : None, 't' :None}) |
|
271 rel.execute(c) |
|
272 self.assertEquals(c.data['test'], 'foo bar') |
|
273 |
|
274 def test_set_expression_in_relation_with_ref_concat(self): |
|
275 rel = rules.RequireRelation(None,"1",'${test} = ${s1} + " " + u"bar" + ${s2}') |
|
276 c = DictContext({'test' : None, 's1' : 'test', 's2' : 'one'}) |
|
277 rel.execute(c) |
|
278 self.assertEquals(c.data['test'], 'test barone') |
|
279 |
|
280 class TestRuleUtils(unittest.TestCase): |
|
281 def test_is_str_literal(self): |
|
282 self.assertEquals(rules.is_str_literal(1), False) |
|
283 self.assertEquals(rules.is_str_literal([]), False) |
|
284 self.assertEquals(rules.is_str_literal("foo"), False) |
|
285 self.assertEquals(rules.is_str_literal("'foo'"), True) |
|
286 self.assertEquals(rules.is_str_literal('foo'), False) |
|
287 self.assertEquals(rules.is_str_literal('"foo bar"'), True) |
|
288 |
|
289 def test_get_str_literal(self): |
|
290 self.assertEquals(rules.get_str_literal(1), None) |
|
291 self.assertEquals(rules.get_str_literal([]), None) |
|
292 self.assertEquals(rules.get_str_literal("foo"), None) |
|
293 self.assertEquals(rules.get_str_literal("'foo'"), 'foo') |
|
294 self.assertEquals(rules.get_str_literal('foo'), None) |
|
295 self.assertEquals(rules.get_str_literal('"foo bar"'), 'foo bar') |
|
152 |
296 |
153 class TestASTInterpreter(unittest.TestCase): |
297 class TestASTInterpreter(unittest.TestCase): |
154 def test_require(self): |
298 def test_require(self): |
155 ip = ASTInterpreter('a excludes b require 0') |
299 ip = rules.ASTInterpreter('a excludes b require 0') |
156 ret = ip.eval() |
300 ret = ip.eval() |
157 |
301 |
158 def test_get_tokens(self): |
302 def test_get_tokens(self): |
159 self.assertEquals(get_tokens("foo=(2+1) * 3"),['foo','=','(','2','+','1',')','*','3']) |
303 self.assertEquals(rules.get_tokens("foo=(2+1) * 3"),['foo','=','(','2','+','1',')','*','3']) |
160 self.assertEquals(get_tokens("Arithmetic.MixedResult3 = (Arithmetic.Value2 / 2 + Arithmetic.Value1 * 9) - 7"),['Arithmetic.MixedResult3', '=', '(', 'Arithmetic.Value2', '/', '2', '+', 'Arithmetic.Value1', '*', '9', ')', '-', '7']) |
304 self.assertEquals(rules.get_tokens("Arithmetic.MixedResult3 = (Arithmetic.Value2 / 2 + Arithmetic.Value1 * 9) - 7"),['Arithmetic.MixedResult3', '=', '(', 'Arithmetic.Value2', '/', '2', '+', 'Arithmetic.Value1', '*', '9', ')', '-', '7']) |
161 print get_tokens(multilines) |
305 self.assertEquals(len(rules.get_tokens(multilines)),25) |
162 self.assertEquals(len(get_tokens(multilines)),25) |
|
163 |
306 |
164 def test_get_unindented_multiline_tokens(self): |
307 def test_get_unindented_multiline_tokens(self): |
165 self.assertEquals( |
308 self.assertEquals( |
166 get_tokens("foo = 2+bar\nand foobar = 3 and\nfubar=4"), |
309 rules.get_tokens("foo = 2+bar\nand foobar = 3 and\nfubar=4"), |
167 ['foo', '=', '2', '+', 'bar', 'and', 'foobar', '=', '3', 'and', 'fubar', '=', '4']) |
310 ['foo', '=', '2', '+', 'bar', 'and', 'foobar', '=', '3', 'and', 'fubar', '=', '4']) |
168 |
311 |
169 def test_get_tab_separated_tokens(self): |
312 def test_get_tab_separated_tokens(self): |
170 self.assertEquals( |
313 self.assertEquals( |
171 get_tokens("foo\tconfigures\t\tbar\t=\t5"), |
314 rules.get_tokens("foo\tconfigures\t\tbar\t=\t5"), |
172 ['foo', 'configures', 'bar', '=', '5']) |
315 ['foo', 'configures', 'bar', '=', '5']) |
173 |
316 |
174 def test_get_unicode_tokens(self): |
317 def test_get_unicode_tokens(self): |
175 self.assertEquals( |
318 self.assertEquals( |
176 get_tokens(u'xÿz configures xzÿ = ÿxá'), |
319 rules.get_tokens(u'xÿz configures xzÿ = ÿxá'), |
177 [u'xÿz', 'configures', u'xzÿ', '=', u'ÿxá']) |
320 [u'xÿz', 'configures', u'xzÿ', '=', u'ÿxá']) |
178 |
321 |
179 def test_get_unicode_tokens_2(self): |
322 def test_get_unicode_tokens_2(self): |
180 self.assertEquals( |
323 self.assertEquals( |
181 get_tokens(u'ελληνικά configures ünicode = u"test string" + ελληνικά'), |
324 rules.get_tokens(u'ελληνικά configures ünicode = u"test string" + ελληνικά'), |
182 [u'ελληνικά', 'configures', u'ünicode', '=', 'u"test string"', '+', u'ελληνικά']) |
325 [u'ελληνικά', 'configures', u'ünicode', '=', 'u"test string"', '+', u'ελληνικά']) |
183 |
326 |
184 def test_get_unicode_tokens_3(self): |
327 def test_get_unicode_tokens_3(self): |
185 self.assertEquals( |
328 self.assertEquals( |
186 get_tokens(u'oöoä äöoö oöo öoö äaäa'), |
329 rules.get_tokens(u'oöoä äöoö oöo öoö äaäa'), |
187 [u'oöoä', u'äöoö', u'oöo', u'öoö', u'äaäa']) |
330 [u'oöoä', u'äöoö', u'oöo', u'öoö', u'äaäa']) |
188 |
331 |
189 def test_get_unicode_tokens_4(self): |
332 def test_get_unicode_tokens_4(self): |
190 self.assertEquals( |
333 self.assertEquals( |
191 get_tokens(u'ünicode.rêf1 require rêf2 . ελληνικά'), |
334 rules.get_tokens(u'ünicode.rêf1 require rêf2 . ελληνικά'), |
192 [u'ünicode.rêf1', u'require', u'rêf2.ελληνικά']) |
335 [u'ünicode.rêf1', u'require', u'rêf2.ελληνικά']) |
193 |
336 |
194 def test_get_unicode_tokens_multiline(self): |
337 def test_get_unicode_tokens_multiline(self): |
195 tokenstr = u""" |
338 tokenstr = u""" |
196 foo=(2+1) * 3 |
339 foo=(2+1) * 3 |
199 expected = [ |
342 expected = [ |
200 'foo', '=', '(', '2', '+', '1', ')', '*', '3', |
343 'foo', '=', '(', '2', '+', '1', ')', '*', '3', |
201 u'xÿz', 'configures', u'xzÿ', '=', u'ÿxá', |
344 u'xÿz', 'configures', u'xzÿ', '=', u'ÿxá', |
202 u'ελληνικά', 'configures', u'ünicode', '=', 'u"test string"', '+', u'ελληνικά', |
345 u'ελληνικά', 'configures', u'ünicode', '=', 'u"test string"', '+', u'ελληνικά', |
203 ] |
346 ] |
204 actual = get_tokens(tokenstr) |
347 actual = rules.get_tokens(tokenstr) |
205 self.assertEquals(actual, expected, '\n%r \n!= \n%r' % (actual, expected)) |
348 self.assertEquals(actual, expected, '\n%r \n!= \n%r' % (actual, expected)) |
206 |
349 |
207 def test_multiline_string(self): |
350 def test_multiline_string(self): |
208 tokenstr = ''' |
351 tokenstr = ''' |
209 """ |
352 """ |
210 tes- |
353 tes- |
211 ti |
354 ti |
212 """ |
355 """ |
213 ''' |
356 ''' |
214 expected = ['"""\ntes-\nti\n"""'] |
357 expected = ['"""\ntes-\nti\n"""'] |
215 self.assertEquals(get_tokens(tokenstr), expected) |
358 self.assertEquals(rules.get_tokens(tokenstr), expected) |
216 |
359 |
217 def test_syntax_error(self): |
360 def test_syntax_error(self): |
218 try: |
361 try: |
219 ip = ASTInterpreter('a and and') |
362 ip = rules.ASTInterpreter('a and and') |
220 self.assertTrue(False) |
363 self.assertTrue(False) |
221 except ParseException: |
364 except rules.ParseException: |
222 self.assertTrue(True) |
365 self.assertTrue(True) |
223 |
366 |
224 def test_empty_expression(self): |
367 def test_empty_expression(self): |
225 expression = '' |
368 expression = '' |
226 ip = ASTInterpreter(expression) |
369 ip = rules.ASTInterpreter(expression) |
227 result = ip.eval() |
370 result = ip.eval() |
228 self.assertFalse(result) |
371 self.assertFalse(result) |
229 |
372 |
230 def test_no_expression(self): |
373 def test_no_expression(self): |
231 ip = ASTInterpreter() |
374 ip = rules.ASTInterpreter() |
232 result = ip.eval() |
375 result = ip.eval() |
233 self.assertFalse(result) |
376 self.assertFalse(result) |
234 |
377 |
235 try: |
378 try: |
236 ip.create_ast(None) |
379 ip.create_ast(None) |
237 self.assertFalse(True) |
380 self.assertFalse(True) |
238 except ParseException: |
381 except rules.ParseException: |
239 self.assertTrue(True) |
382 self.assertTrue(True) |
240 |
383 |
241 ip.create_ast('1 and 1') |
384 ip.create_ast('1 and 1') |
242 result = ip.eval() |
385 result = ip.eval() |
243 self.assertTrue(result) |
386 self.assertTrue(result) |
244 |
387 |
245 def test_one_param_ops(self): |
388 def test_one_param_ops(self): |
246 ip = ASTInterpreter('1 and truth 1') |
389 ip = rules.ASTInterpreter('1 and truth 1') |
247 result = ip.eval() |
390 result = ip.eval() |
248 self.assertTrue(result) |
391 self.assertTrue(result) |
249 |
392 |
250 ip.create_ast('1 and truth 0') |
393 ip.create_ast('1 and truth 0') |
251 result = ip.eval() |
394 result = ip.eval() |
255 result = ip.eval() |
398 result = ip.eval() |
256 self.assertTrue(result) |
399 self.assertTrue(result) |
257 |
400 |
258 def test_infix_to_postfix(self): |
401 def test_infix_to_postfix(self): |
259 expression = '1 and not 1' |
402 expression = '1 and not 1' |
260 ip = ASTInterpreter(expression) |
403 ip = rules.ASTInterpreter(expression) |
261 self.assertEqual(ip.postfix_array, ['1', '1', 'not', 'and']) |
404 self.assertEqual(ip.postfix_array, ['1', '1', 'not', 'and']) |
262 self.assertFalse(ip.eval()) |
405 self.assertFalse(ip.eval()) |
263 |
406 |
407 def test_infix_to_postfix_with_minus(self): |
|
408 expression = '1 - 1' |
|
409 ip = rules.ASTInterpreter(expression) |
|
410 self.assertEqual(ip.postfix_array, ['1', '1', '-']) |
|
411 self.assertFalse(ip.eval()) |
|
412 |
|
264 def test_infix_to_postfix_pars(self): |
413 def test_infix_to_postfix_pars(self): |
265 expression = '1 and ( 0 or 1 and 1 )' |
414 expression = '1 and ( 0 or 1 and 1 )' |
266 ip = ASTInterpreter(expression) |
415 ip = rules.ASTInterpreter(expression) |
267 self.assertEqual(ip.postfix_array, ['1', '0', '1', 'or', '1', 'and', 'and']) |
416 self.assertEqual(ip.postfix_array, ['1', '0', '1', 'or', '1', 'and', 'and']) |
268 self.assertTrue(ip.eval()) |
417 self.assertTrue(ip.eval()) |
269 |
418 |
270 def test_not(self): |
419 def test_not(self): |
271 ip = ASTInterpreter(u'not 1',) |
420 ip = rules.ASTInterpreter(u'not 1',) |
272 ret = ip.eval() |
421 ret = ip.eval() |
273 self.assertFalse(ret) |
422 self.assertFalse(ret) |
274 |
423 |
275 ip.create_ast(u'not 1') |
424 ip.create_ast(u'not 1') |
276 ret = ip.eval() |
425 ret = ip.eval() |
279 ip.create_ast('not STRING_VALUE') |
428 ip.create_ast('not STRING_VALUE') |
280 ret = ip.eval() |
429 ret = ip.eval() |
281 self.assertFalse(ret) |
430 self.assertFalse(ret) |
282 |
431 |
283 def test_not_with_multiple(self): |
432 def test_not_with_multiple(self): |
284 ip = ASTInterpreter(u'1 and not 0') |
433 ip = rules.ASTInterpreter(u'1 and not 0') |
285 ret = ip.eval() |
434 ret = ip.eval() |
286 self.assertTrue(ret) |
435 self.assertTrue(ret) |
287 ip.create_ast(u'1 and not 1') |
436 ip.create_ast(u'1 and not 1') |
288 ret = ip.eval() |
437 ret = ip.eval() |
289 self.assertFalse(ret) |
438 self.assertFalse(ret) |
290 |
439 |
291 def test_and(self): |
440 def test_and(self): |
292 ip = ASTInterpreter(u'1 and 1 and 0') |
441 ip = rules.ASTInterpreter(u'1 and 1 and 0') |
293 ret = ip.eval() |
442 ret = ip.eval() |
294 self.assertFalse(ret) |
443 self.assertFalse(ret) |
295 |
444 |
296 ip.create_ast(u'1 and 1 and 1') |
445 ip.create_ast(u'1 and 1 and 1') |
297 ret = ip.eval() |
446 ret = ip.eval() |
298 self.assertTrue(ret) |
447 self.assertTrue(ret) |
299 |
448 |
300 def test_nand(self): |
449 def test_nand(self): |
301 ip = ASTInterpreter(u'1 nand 1 nand 1') |
450 ip = rules.ASTInterpreter(u'1 nand 1 nand 1') |
302 ret = ip.eval() |
451 ret = ip.eval() |
303 self.assertTrue(ret) |
452 self.assertTrue(ret) |
304 |
453 |
305 ip.create_ast(u'1 nand 1 nand 0') |
454 ip.create_ast(u'1 nand 1 nand 0') |
306 ret = ip.eval() |
455 ret = ip.eval() |
313 ip.create_ast(u'0 nand 0 nand 0') |
462 ip.create_ast(u'0 nand 0 nand 0') |
314 ret = ip.eval() |
463 ret = ip.eval() |
315 self.assertTrue(ret) |
464 self.assertTrue(ret) |
316 |
465 |
317 def test_or(self): |
466 def test_or(self): |
318 ip = ASTInterpreter(u'1 or 1 or 0') |
467 ip = rules.ASTInterpreter(u'1 or 1 or 0') |
319 ret = ip.eval() |
468 ret = ip.eval() |
320 self.assertTrue(ret) |
469 self.assertTrue(ret) |
321 |
470 |
322 def test_or_for_exclude(self): |
471 def test_or_for_exclude(self): |
323 """ |
472 """ |
324 On exclude case if OR returns True -> some element is selected |
473 On exclude case if OR returns True -> some element is selected |
325 and the rule evaluation should fail, the exclude rule should |
474 and the rule evaluation should fail, the exclude rule should |
326 evaluate if PostfixRuleEngine.eval(expression) -> return False |
475 evaluate if PostfixRuleEngine.eval(expression) -> return False |
327 """ |
476 """ |
328 ip = ASTInterpreter(u'1 or 1 or 1') |
477 ip = rules.ASTInterpreter(u'1 or 1 or 1') |
329 ret = ip.eval() |
478 ret = ip.eval() |
330 self.assertTrue(ret) |
479 self.assertTrue(ret) |
331 |
480 |
332 ip.create_ast(u'1 or 1 or 0') |
481 ip.create_ast(u'1 or 1 or 0') |
333 ret = ip.eval() |
482 ret = ip.eval() |
352 ip.create_ast(u'0 or 0 or 0') |
501 ip.create_ast(u'0 or 0 or 0') |
353 ret = ip.eval() |
502 ret = ip.eval() |
354 self.assertFalse(ret) |
503 self.assertFalse(ret) |
355 |
504 |
356 def test_nor(self): |
505 def test_nor(self): |
357 ip = ASTInterpreter(u'1 nor 1 nor 1') |
506 ip = rules.ASTInterpreter(u'1 nor 1 nor 1') |
358 ret = ip.eval() |
507 ret = ip.eval() |
359 self.assertFalse(ret) |
508 self.assertFalse(ret) |
360 |
509 |
361 ip.create_ast(u'1 nor 1 nor 0') |
510 ip.create_ast(u'1 nor 1 nor 0') |
362 ret = ip.eval() |
511 ret = ip.eval() |
370 ret = ip.eval() |
519 ret = ip.eval() |
371 self.assertFalse(ret) |
520 self.assertFalse(ret) |
372 |
521 |
373 |
522 |
374 def test_xor(self): |
523 def test_xor(self): |
375 ip = ASTInterpreter(u'1 xor 1') |
524 ip = rules.ASTInterpreter(u'1 xor 1') |
376 ret = ip.eval() |
525 ret = ip.eval() |
377 self.assertFalse(ret) |
526 self.assertFalse(ret) |
378 |
527 |
379 ip.create_ast(u'1 xor 0 xor 0') |
528 ip.create_ast(u'1 xor 0 xor 0') |
380 ret = ip.eval() |
529 ret = ip.eval() |
381 self.assertTrue(ret) |
530 self.assertTrue(ret) |
382 |
531 |
383 def test_eq_cmp(self): |
532 def test_eq_cmp(self): |
384 ip = ASTInterpreter(u'1 == 0') |
533 ip = rules.ASTInterpreter(u'1 == 0') |
385 ret = ip.eval() |
534 ret = ip.eval() |
386 self.assertFalse(ret) |
535 self.assertFalse(ret) |
387 |
536 |
388 ip.create_ast(u'1 == 1') |
537 ip.create_ast(u'1 == 1') |
389 ret = ip.eval() |
538 ret = ip.eval() |
396 ip.create_ast(u'DEFINED == UNDEFINED') |
545 ip.create_ast(u'DEFINED == UNDEFINED') |
397 ret = ip.eval() |
546 ret = ip.eval() |
398 self.assertFalse(ret) |
547 self.assertFalse(ret) |
399 |
548 |
400 def test_neq_cmp(self): |
549 def test_neq_cmp(self): |
401 ip = ASTInterpreter(u'1 != 1') |
550 ip = rules.ASTInterpreter(u'1 != 1') |
402 ret = ip.eval() |
551 ret = ip.eval() |
403 self.assertFalse(ret) |
552 self.assertFalse(ret) |
404 |
553 |
405 ip.create_ast(u'1 != 0') |
554 ip.create_ast(u'1 != 0') |
406 ret = ip.eval() |
555 ret = ip.eval() |
407 self.assertTrue(ret) |
556 self.assertTrue(ret) |
408 |
557 |
409 def test_lt_cmp(self): |
558 def test_lt_cmp(self): |
410 ip = ASTInterpreter(u'0 < 1') |
559 ip = rules.ASTInterpreter(u'0 < 1') |
411 ret = ip.eval() |
560 ret = ip.eval() |
412 self.assertTrue(ret) |
561 self.assertTrue(ret) |
413 |
562 |
414 ip.create_ast(u'-1 < 1') |
563 ip.create_ast(u'0-1 < 1') |
415 ret = ip.eval() |
564 ret = ip.eval() |
416 self.assertTrue(ret) |
565 self.assertTrue(ret) |
417 |
566 |
418 ip.create_ast(u'-1 < -2') |
567 ip.create_ast(u'0-1 < 0-2') |
419 ret = ip.eval() |
568 ret = ip.eval() |
420 self.assertFalse(ret) |
569 self.assertFalse(ret) |
421 |
570 |
422 ip.create_ast(u'2 < 0') |
571 ip.create_ast(u'2 < 0') |
423 ret = ip.eval() |
572 ret = ip.eval() |
424 self.assertFalse(ret) |
573 self.assertFalse(ret) |
425 |
574 |
426 def test_gt_cmp(self): |
575 def test_gt_cmp(self): |
427 ip = ASTInterpreter(u'0 > -1') |
576 ip = rules.ASTInterpreter(u'0 > 0-1') |
428 ret = ip.eval() |
577 ret = ip.eval() |
429 self.assertTrue(ret) |
578 self.assertTrue(ret) |
430 |
579 |
431 ip.create_ast(u'2 > 1') |
580 ip.create_ast(u'2 > 1') |
432 ret = ip.eval() |
581 ret = ip.eval() |
434 |
583 |
435 ip.create_ast(u'0 > 1') |
584 ip.create_ast(u'0 > 1') |
436 ret = ip.eval() |
585 ret = ip.eval() |
437 self.assertFalse(ret) |
586 self.assertFalse(ret) |
438 |
587 |
439 ip.create_ast(u'-1 > 1') |
588 ip.create_ast(u'0-1 > 1') |
440 ret = ip.eval() |
589 ret = ip.eval() |
441 self.assertFalse(ret) |
590 self.assertFalse(ret) |
442 |
591 |
443 def test_lte_cmp(self): |
592 def test_lte_cmp(self): |
444 ip = ASTInterpreter(u'0 <= 1') |
593 ip = rules.ASTInterpreter(u'0 <= 1') |
445 ret = ip.eval() |
594 ret = ip.eval() |
446 self.assertTrue(ret) |
595 self.assertTrue(ret) |
447 |
596 |
448 ip.create_ast(u'0 <= 0') |
597 ip.create_ast(u'0 <= 0') |
449 ret = ip.eval() |
598 ret = ip.eval() |
452 ip.create_ast(u'1 <= 0') |
601 ip.create_ast(u'1 <= 0') |
453 ret = ip.eval() |
602 ret = ip.eval() |
454 self.assertFalse(ret) |
603 self.assertFalse(ret) |
455 |
604 |
456 def test_gte_cmp(self): |
605 def test_gte_cmp(self): |
457 ip = ASTInterpreter(u'1 >= 0') |
606 ip = rules.ASTInterpreter(u'1 >= 0') |
458 ret = ip.eval() |
607 ret = ip.eval() |
459 self.assertTrue(ret) |
608 self.assertTrue(ret) |
460 |
609 |
461 ip.create_ast(u'0 >= 0') |
610 ip.create_ast(u'0 >= 0') |
462 ret = ip.eval() |
611 ret = ip.eval() |
463 self.assertTrue(ret) |
612 self.assertTrue(ret) |
464 |
613 |
465 ip.create_ast(u'0 >= 1') |
614 ip.create_ast(u'0 >= 1') |
466 ret = ip.eval() |
615 ret = ip.eval() |
467 self.assertFalse(ret) |
616 self.assertFalse(ret) |
468 |
617 |
469 def test_extract_refs(self): |
618 def test_extract_refs(self): |
470 refs = ASTInterpreter.extract_refs('a.a and ( b.c and d.e )') |
619 refs = rules.ASTInterpreter.extract_refs('${a.a} and ( ${b.c} and ${d.e} )') |
471 self.assertTrue('a.a' in refs) |
620 self.assertTrue('a.a' in refs) |
472 self.assertTrue('b.c' in refs) |
621 self.assertTrue('b.c' in refs) |
473 self.assertTrue('d.e' in refs) |
622 self.assertTrue('d.e' in refs) |
474 self.assertTrue('and' not in refs) |
623 self.assertTrue('and' not in refs) |
475 |
624 |
476 def test_one_of(self): |
625 def test_one_of(self): |
477 """ Test for showing that relation one-of is basically "LEFT and R1 xor R2" |
626 """ Test for showing that relation one-of is basically "LEFT and R1 xor R2" |
478 """ |
627 """ |
479 ip = ASTInterpreter(u'1 and 1 and 1 xor 0') |
628 ip = rules.ASTInterpreter(u'1 and 1 and 1 xor 0') |
480 ret = ip.eval() |
629 ret = ip.eval() |
481 self.assertTrue(ret) |
630 self.assertTrue(ret) |
482 |
631 |
483 if __name__ == '__main__': |
632 if __name__ == '__main__': |
484 unittest.main() |
633 unittest.main() |