def test(self): # ARRANGE # detail = sut.StringDetail('a detail') child = sut.Node('child header', False, (), ()) root_header = 'root header' root_data = True root = sut.Node(root_header, root_data, (detail,), (child,)) # ACT & ASSERT # self.assertEqual(root_header, root.header, 'root header') self.assertEqual(root_data, root.data, 'root data') expected_root_details = asrt.matches_singleton_sequence( asrt.is_(detail) ) expected_root_details.apply_with_message(self, root.details, 'root details') expected_root_children = asrt.matches_singleton_sequence( asrt.is_(child) ) expected_root_children.apply_with_message(self, root.children, 'root children')
def __init__(self, result: bool): self._result = result self._matching_result = MatchingResult( self._result, renderers.Constant( tree.Node(logic.CONSTANT_MATCHER, self._result, (tree.StringDetail(logic.BOOLEANS[result]), ), ())), ) self._structure = renderers.Constant( tree.Node(logic.CONSTANT_MATCHER, None, (tree.StringDetail(logic.BOOLEANS[result]), ), ()))
def matches_w_trace(self, model: MODEL) -> MatchingResult: self._registry.append(model) return MatchingResult(self._constant_result, renderers.Constant(tree.Node(self.name, self._constant_result, (), ())))
def render(self) -> tree.Node[None]: return tree.Node( self.NAME, None, [tree.StringDetail(argument) for argument in self._arguments], (), )
def test_attributes(self): # ARRANGE # tree = sut.Node('header', 'data', (), ()) detail = sut.TreeDetail(tree) # ACT & ASSERT # self.assertIs(tree, detail.tree)
def test_disjunction_followed_by_conjunction__with_negation(self): # ARRANGEMENT # sym_a = NameAndValue('_a_', matchers.ConstantMatcherWithCustomName('a', True)) sym_b = NameAndValue( '_b_', matchers.ConstantMatcherWithCustomName('b', False)) sym_c = NameAndValue('_c_', matchers.ConstantMatcherWithCustomName('c', True)) all_symbols = [sym_a, sym_b, sym_c] arguments = ArgumentElements([ logic.NOT_OPERATOR_NAME, sym_a.name, logic.OR_OPERATOR_NAME, logic.NOT_OPERATOR_NAME, sym_b.name, logic.AND_OPERATOR_NAME, logic.NOT_OPERATOR_NAME, sym_c.name, ]) expected_trace = tree.Node(logic.OR_OPERATOR_NAME, False, (), [ tree.Node(logic.NOT_OPERATOR_NAME, False, (), [sym_a.value.trace_tree]), tree.Node(logic.AND_OPERATOR_NAME, False, (), [ tree.Node(logic.NOT_OPERATOR_NAME, True, (), [sym_b.value.trace_tree]), tree.Node(logic.NOT_OPERATOR_NAME, False, (), [sym_c.value.trace_tree]), ]), ]) # ACT & ASSERT # self._check( arguments, False, all_symbols, expected_trace, )
def _expected_trace_for(self, expected_result: bool, operands: List[NameAndValue[MatcherBehaviour]], ) -> tree.Node[bool]: operand_nodes = filter(lambda x: x is not None, [ operand.value.accept(_ApplicationTraceConstructor(operand.name)) for operand in operands ]) return tree.Node(self.operator, expected_result, (), list(operand_nodes), )
def test_accept_visitor(self): # ARRANGE # visitor = _VisitorThatRegistersVisitedClassesAndReturnsConstant() node = sut.Node('header', 'data', (), ()) detail = sut.TreeDetail(node) # ACT # detail.accept(visitor) # ASSERT # self.assertEqual(visitor.visited_classes, [sut.TreeDetail], 'visited classes')
def execution_case_for( operand_result: bool ) -> NExArr[PrimAndExeExpectation[MatcherWTrace[MODEL], MatchingResult], Arrangement]: operand_matcher = helper.logic_type_symbol_context_from_primitive( symbol_name, matchers.ConstantMatcherWithCustomTrace( mk_operand_trace, operand_result)) trace = tree.Node(logic.NOT_OPERATOR_NAME, not operand_result, (), [mk_operand_trace(operand_result)]) return NExArr( 'operand that gives ' + str(operand_result), PrimAndExeExpectation.of_exe( main_result=asrt_matching_result.matches( value=asrt.equals(not operand_result), trace=trace_equals(trace))), Arrangement(symbols=operand_matcher.symbol_table))
def __init__(self, name: str, result: bool, ): super().__init__(result) self._name = name self._trace_tree = tree.Node(name, result, (tree.StringDetail(logic.BOOLEANS[result]),), ()) self._matching_result = MatchingResult( result, renderers.Constant( self._trace_tree ), )
def runTest(self): # ARRANGE # def get_trace(data: T) -> tree.Node[T]: return tree.Node.empty('name of string matcher', data) for string_matcher_result in [False, True]: string_matcher = StringMatcherSymbolContext.of_primitive( 'STRING_MATCHER', ConstantMatcherWithCustomTrace(get_trace, string_matcher_result), ) expected_trace = tree.Node( MATCHER_NAME, string_matcher_result, (), [get_trace(string_matcher_result)], ) # ACT & ASSERT # with self.subTest(string_matcher_result=string_matcher_result): integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, arguments=lm_args.Contents( sm_args2.SymbolReferenceWReferenceSyntax( string_matcher.name), ).as_arguments, input_=models.ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=string_matcher.symbol_table, ), expectation=Expectation( ParseExpectation(symbol_references=string_matcher. references_assertion), ExecutionExpectation( main_result=asrt_matching_result.matches( asrt.equals(string_matcher_result), trace=asrt_trace_rendering. matches_node_renderer( asrt_d_tree.equals_node(expected_trace)), ))), )
def matches_w_trace(self, line: LineMatcherLine) -> MatchingResult: result = self._matches(line) return MatchingResult(result, Constant(tree.Node(self.name, result, (), ())))
def matches_w_trace(self, model: MODEL) -> MatchingResult: value = self._matches(model) return MatchingResult( value, renderers.Constant(tree.Node(self.NAME, value, (), ())), )
def structure(self) -> StructureRenderer: return renderers.Constant(tree.Node(self.NAME, None, (), ()))