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)