示例#1
0
  def test_map_predicate_bad(self):
    aA = jp.PathPredicate('a', jp.STR_EQ('A'))

    expect_result = mp.MapPredicateResult(
        valid=False, pred=aA,
        obj_list=[_NUMBER_DICT], all_results=[aA(_NUMBER_DICT)],
        bad_map=[mp.ObjectResultMapAttempt(_NUMBER_DICT, aA(_NUMBER_DICT))],
        good_map=[])

    self._try_map(aA, _NUMBER_DICT, False, expect_result)
示例#2
0
  def test_map_predicate_good_1(self):
    aA = jp.PathPredicate('a', jp.STR_EQ('A'))

    aA_attempt = mp.ObjectResultMapAttempt(_LETTER_DICT, aA(_LETTER_DICT))
    expect_result = mp.MapPredicateResult(
        valid=True, pred=aA,
        obj_list=[_LETTER_DICT], all_results=[aA_attempt.result],
        good_map=[aA_attempt],
        bad_map=[])

    self._try_map(aA, _LETTER_DICT, True, expect_result)
示例#3
0
  def test_map_not_found(self):
    aA = jp.PathPredicate('a', jp.STR_EQ('A'))

    aa_composite_attempt = mp.ObjectResultMapAttempt(_COMPOSITE_DICT,
                                                     aA(_COMPOSITE_DICT))
    expect_result = mp.MapPredicateResult(
        valid=False, pred=aA,
        obj_list=[_COMPOSITE_DICT], all_results=[aa_composite_attempt.result],
        bad_map=[aa_composite_attempt],
        good_map=[])

    self._try_map(aA, _COMPOSITE_DICT, False, expect_result)
示例#4
0
  def test_map_predicate_good_and_bad_min_1(self):
    aA = jp.PathPredicate('a', jp.STR_EQ('A'))

    aa_number_attempt = mp.ObjectResultMapAttempt(_NUMBER_DICT,
                                                  aA(_NUMBER_DICT))
    aa_letter_attempt = mp.ObjectResultMapAttempt(_LETTER_DICT,
                                                  aA(_LETTER_DICT))
    expect_result = mp.MapPredicateResult(
        valid=True, pred=aA,
        obj_list=[_NUMBER_DICT, _LETTER_DICT],
        all_results=[aa_number_attempt.result, aa_letter_attempt.result],
        good_map=[aa_letter_attempt],
        bad_map=[aa_number_attempt])

    self._try_map(aA, [_NUMBER_DICT, _LETTER_DICT], True, expect_result)
示例#5
0
  def test_map_predicate_good_and_bad_min_2(self):
    context = ExecutionContext()
    aA = jp.PathPredicate('a', jp.STR_EQ('A'))

    expect_result = jp.MapPredicateResult(
        valid=False, pred=aA,
        obj_list=[_NUMBER_DICT, _LETTER_DICT],
        all_results=[aA(context, _NUMBER_DICT), aA(context, _LETTER_DICT)],
        good_map=[jp.ObjectResultMapAttempt(_LETTER_DICT,
                                            aA(context, _LETTER_DICT))],
        bad_map=[jp.ObjectResultMapAttempt(_NUMBER_DICT,
                                           aA(context, _NUMBER_DICT))])

    self._try_map(
        context, aA, [_NUMBER_DICT, _LETTER_DICT], False, expect_result, min=2)