def test_cardinality_bounds_2_indirect(self):
predicate = jp.CardinalityPredicate(_AorB,
min=lambda x: x['min'],
max=lambda x: x['max'])
for min in range(0, 3):
for max in range(0, 3):
if min > max:
continue
context = ExecutionContext(min=min, max=max)
expect_ok = min <= 2 and max >= 2
source = _CAB
result = predicate(context, source)
all_results = [
jp.SequencedPredicateResult(
False, _AorB,
[jp.PathValueResult(_CAB, '', PathValue('[0]', 'C'),
valid=False, pred=_eq_A),
jp.PathValueResult(_CAB, '', PathValue('[0]', 'C'),
valid=False, pred=_eq_B)]),
jp.SequencedPredicateResult(
True, _AorB,
[jp.PathValueResult(_CAB, '', PathValue('[1]', 'A'),
valid=True, pred=_eq_A)]),
jp.SequencedPredicateResult(
True, _AorB,
[jp.PathValueResult(_CAB, '', PathValue('[2]', 'B'),
valid=False, pred=_eq_A),
jp.PathValueResult(_CAB, '', PathValue('[2]', 'B'),
valid=True, pred=_eq_B)])]
builder = jp.PathPredicateResultBuilder(
pred=jp.PathPredicate('', _AorB), 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)
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.SequencedPredicateResult(valid=False,
pred=ifAthenBelseC,
results=tried)
result = ifAthenBelseC(context, test)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_disjunction_true_aborts_early(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
disjunction = jc.OR([aA, bB])
expect = jc.SequencedPredicateResult(
valid=True, pred=disjunction, results=[aA(context, _LETTER_DICT)])
result = disjunction(context, _LETTER_DICT)
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.SequencedPredicateResult(
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.SequencedPredicateResult(
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.SequencedPredicateResult(
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.SequencedPredicateResult(
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_false(self):
context = ExecutionContext()
a1 = jp.PathEqPredicate('a', 1)
b2 = jp.PathEqPredicate('b', 2)
disjunction = jc.OR([a1, b2])
expect = jc.SequencedPredicateResult(
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.SequencedPredicateResult(
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.SequencedPredicateResult(
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_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.SequencedPredicateResult(valid=True,
pred=ifAthenBelseC,
results=tried)
result = ifAthenBelseC(context, test)
self.assertTrue(result)
self.assertEqual(expect, result)