def test_condition_else_fail(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
cC = jp.PathEqPredicate('c', 'C')
ifAthenBelseC = jc.IF(aA, bB, cC)
# False if all conditions are false
# False if "if" is true and "then" is false even if "else" matches.
test_cases = [{'a':'A', 'b':'X', 'c':'C'},
{'a':'X', 'b':'B', 'c':'D'}]
for i in range(2):
test = test_cases[i]
tried = [aA(context, test)]
if i < 1:
# First has true IF so tries THEN
tried.append(bB(context, test))
else:
# Remainder has false IF so tries ELSE
tried.append(cC(context, test))
expect = jc.CompositePredicateResult(
valid=False, pred=ifAthenBelseC, results=tried)
result = ifAthenBelseC(context, test)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_condition_else_success(self):
context = ExecutionContext(a='A', b='B', c='C')
aA = jp.PathEqPredicate('a', lambda x: x['a'])
bB = jp.PathEqPredicate('b', lambda x: x['b'])
cC = jp.PathEqPredicate('c', lambda x: x['c'])
ifAthenBelseC = jc.IF(aA, bB, cC)
# True if all conditions are true.
# True if "if" satisfied and "then" matches.
# True if only else condition is true.
test_cases = [_LETTER_DICT,
{'a':'A', 'b':'B', 'c':'X'},
{'a':'X', 'b':'B', 'c':'C'},
{'a':'X', 'b':'X', 'c':'C'},
]
for i in range(3):
test = test_cases[i]
tried = [aA(context, test)]
if i < 2:
# First two have true IF to just execute THEN
tried.append(bB(context, test))
else:
# Remainder have false IF to just execute ELSE
tried.append(cC(context, test))
expect = jc.CompositePredicateResult(
valid=True, pred=ifAthenBelseC, results=tried)
result = ifAthenBelseC(context, test)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_not_success(self):
context = ExecutionContext()
a1 = jp.PathEqPredicate('a', '1')
not_a1 = jc.NOT(a1)
expect = jc.CompositePredicateResult(
valid=True, pred=not_a1, results=[a1(context, _LETTER_DICT)])
result = not_a1(context, _LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
b2 = jp.PathEqPredicate('b', '2')
b2_or_a1 = jc.OR([b2, a1])
not_b2_or_a1 = jc.NOT(b2_or_a1)
expect = jc.CompositePredicateResult(
valid=True, pred=not_b2_or_a1,
results=[b2_or_a1(context, _LETTER_DICT)])
result = not_b2_or_a1(context, _LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_not_fail(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
not_aA = jc.NOT(aA)
expect = jc.CompositePredicateResult(
valid=False, pred=not_aA, results=[aA(context, _LETTER_DICT)])
result = not_aA(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
bB = jp.PathEqPredicate('b', 'B')
bB_or_aA = jc.OR([bB, aA])
not_bB_or_aA = jc.NOT(bB_or_aA)
expect = jc.CompositePredicateResult(
valid=False, pred=not_bB_or_aA,
results=[bB_or_aA(context, _LETTER_DICT)])
result = not_bB_or_aA(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_disjunction_true_aborts_early(self):
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
disjunction = jc.OR([aA, bB])
expect = jc.CompositePredicateResult(valid=True,
pred=disjunction,
results=[aA(_LETTER_DICT)])
result = disjunction(_LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_disjunction_false(self):
context = ExecutionContext()
a1 = jp.PathEqPredicate('a', 1)
b2 = jp.PathEqPredicate('b', 2)
disjunction = jc.OR([a1, b2])
expect = jc.CompositePredicateResult(
valid=False, pred=disjunction,
results=[a1(context, _LETTER_DICT), b2(context, _LETTER_DICT)])
result = disjunction(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_conjunction_true(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
conjunction = jc.AND([aA, bB])
expect = jc.CompositePredicateResult(
valid=True, pred=conjunction,
results=[aA(context, _LETTER_DICT), bB(context, _LETTER_DICT)])
result = conjunction(context, _LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_conjunction_false_aborts_early(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
b2 = jp.PathEqPredicate('b', 2)
bB = jp.PathEqPredicate('b', 'B')
conjunction = jc.AND([aA, b2, bB])
expect = jc.CompositePredicateResult(
valid=False, pred=conjunction,
results=[aA(context, _LETTER_DICT), b2(context, _LETTER_DICT)])
result = conjunction(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_cardinality_bounds_1(self):
context = ExecutionContext()
for min in range(0, 3):
for max in range(0, 3):
if min > max:
continue
predicate = jp.CardinalityPredicate(_AorX, min=min, max=max)
expect_ok = min <= 1 and max >= 1
source = _CAB
result = predicate(context, source)
all_results = [
jp.CompositePredicateResult(False, _AorX, [
jp.PathValueResult(_CAB,
'',
PathValue('[0]', 'C'),
valid=False,
pred=_eq_A),
jp.PathValueResult(_CAB,
'',
PathValue('[0]', 'C'),
valid=False,
pred=_eq_X)
]),
jp.CompositePredicateResult(True, _AorX, [
jp.PathValueResult(_CAB,
'',
PathValue('[1]', 'A'),
valid=True,
pred=_eq_A)
]),
jp.CompositePredicateResult(False, _AorX, [
jp.PathValueResult(_CAB,
'',
PathValue('[2]', 'B'),
valid=False,
pred=_eq_A),
jp.PathValueResult(_CAB,
'',
PathValue('[2]', 'B'),
valid=False,
pred=_eq_X)
])
]
builder = jp.PathPredicateResultBuilder(pred=jp.PathPredicate(
'', _AorX),
source=_CAB)
builder.add_result_candidate(PathValue('[0]', 'C'),
all_results[0])
builder.add_result_candidate(PathValue('[1]', 'A'),
all_results[1])
builder.add_result_candidate(PathValue('[2]', 'B'),
all_results[2])
expect_path_result = builder.build(True)
if expect_ok:
self.assertEqual(
jp.ConfirmedCardinalityResult(predicate,
expect_path_result),
result)
elif max == 0:
self.assertEqual(
jp.UnexpectedValueCardinalityResult(
predicate, expect_path_result), result)
else:
self.assertEqual(
jp.FailedCardinalityRangeResult(
predicate, expect_path_result), result)
