def test_stdin_is_concatenation_of_model_and_program_stdin_WHEN_program_defines_single_stdin( self): # ARRANGE # model_contents = '\n'.join(('the', 'contents', 'of', 'the', 'model')) test_setup = SingleStdinOfProgramTestSetup( self, exit_code=0, additional_stdin=model_contents) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): with self.subTest(pgm_and_args_case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layouts__source_variants( self, equivalent_source_variants__for_expr_parse__s__nsc, RunProgramAbsStx( test_setup.program_w_stdin_syntax( pgm_and_args_case.pgm_and_args), ), model_constructor.of_str(self, model_contents), arrangement_w_tcds( symbols=pgm_and_args_case.symbol_table, process_execution=test_setup. proc_exe_env__w_stdin_check, tcds_contents=pgm_and_args_case.tcds, ), MultiSourceExpectation( symbol_references=pgm_and_args_case. references_assertion, execution=EXECUTION_OUTPUT_IS_EMPTY, primitive=PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION, ), )
def runTest(self): # ARRANGE # model = model_constructor.of_str(self, 'string with at least one line') line_matcher = LineMatcherSymbolContextOfPrimitiveConstant( 'MATCHER', True, ) after_bin_op = 'after bin op' lm_argument = lm_args.And([ lm_args.SymbolReference(line_matcher.name), lm_args.Custom(after_bin_op), ]) for quantifier in Quantifier: arguments = args2.Quantification(quantifier, lm_argument.as_str) with self.subTest(quantifier): # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check( self, source=arguments.as_remaining_source, input_=model, arrangement=arrangement_w_tcds( symbols=line_matcher.symbol_table, ), expectation=Expectation( ParseExpectation(source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=lm_argument. operator_name + ' ' + after_bin_op), symbol_references=line_matcher. references_assertion), ExecutionExpectation( main_result=asrt_matching_result.matches_value( line_matcher.result_value))), )
def test_transformation_SHOULD_apply_only_to_matcher_argument(self): to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'the_to_upper_transformer', string_transformers.to_uppercase()) model = contents_transformation.TransformedContentsSetup( original='text', transformed='TEXT', ) integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, args2.conjunction([ args2.Parentheses( args2.Transformed( to_upper_transformer.name, args2.Equals.eq_string(model.transformed)), ), args2.Equals.eq_string(model.original), ]).as_arguments, model_constructor.of_str(self, model.original), arrangement_w_tcds(symbols=to_upper_transformer.symbol_table), Expectation( ParseExpectation( symbol_references=asrt.matches_singleton_sequence( is_reference_to_string_transformer( to_upper_transformer.name))), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True))))
def runTest(self): expected_contents = 'expected-contents' resolving_env = PathResolvingEnvironmentPreOrPostSds(fake_tcds()) sdv = self._sdv_expecting_equals(expected_contents) adv = sdv.resolve(resolving_env.symbols).value_of_any_dependency(resolving_env.tcds) for actual_contents in [expected_contents, expected_contents + '-unexpected']: expected_result = actual_contents == expected_contents expected_matching_result = asrt_matching_result.matches_value(expected_result) with self.subTest(expected_result=expected_result): model_w_ext_deps = model_constructor.of_str( self, actual_contents, may_depend_on_external_resources=True, ) with tmp_dir() as dir_space_dir__matcher: matcher = adv.primitive(self._app_env(dir_space_dir__matcher, 'matcher-path')) with tmp_dir() as dir_space_dir__model: model = model_w_ext_deps(FullResolvingEnvironment( resolving_env.symbols, resolving_env.tcds, self._app_env(dir_space_dir__model, 'model-path') )) # ACT # matching_result_1st = matcher.matches_w_trace(model) matching_result_2nd = matcher.matches_w_trace(model) # ASSERT # expected_matching_result.apply_with_message(self, matching_result_1st, '1st') expected_matching_result.apply_with_message(self, matching_result_2nd, '2nd')
def _check(self, expected_contents: str, actual_contents: str, may_depend_on_external_resources: bool, expected_result: bool, ): string_source_symbol_with_expected = StringSourceSymbolContext.of_primitive_constant( 'EXPECTED_CONTENTS_SYMBOL', expected_contents, ) integration_check.CHECKER__PARSE_SIMPLE.check( self, args2.Equals.eq_string( string_source_symbol_with_expected.name__sym_ref_syntax ).as_remaining_source, model_constructor.of_str( self, actual_contents, may_depend_on_external_resources=may_depend_on_external_resources, ), arrangement_w_tcds( symbols=string_source_symbol_with_expected.symbol_table ), Expectation( ParseExpectation( symbol_references=string_source_symbol_with_expected.references_assertion, ), execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value( expected_result ) ), ), )
def test_stdin_contains_model_contents_WHEN_program_do_not_define_stdin( self): # ARRANGE # test_setup = SingleStdinOfProgramTestSetup(self, exit_code=0) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): with self.subTest(pgm_and_args_case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx( self, abstract_syntaxes.RunProgramAbsStx( pgm_and_args_case.pgm_and_args, ), model_constructor.of_str( self, test_setup.STRING_SOURCE_CONTENTS), arrangement_w_tcds( symbols=pgm_and_args_case.symbol_table, process_execution=test_setup. proc_exe_env__w_stdin_check, tcds_contents=pgm_and_args_case.tcds, ), Expectation( ParseExpectation(symbol_references=pgm_and_args_case. references_assertion, ), execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value( True)), ))
def _check(self, expected_contents: str, actual_contents: str, may_depend_on_external_resources: bool, expected_result: bool, ): expected_file_relativity = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE) expected_contents_file = File('expected.txt', expected_contents) integration_check.CHECKER__PARSE_SIMPLE.check( self, args2.Equals.eq_file( expected_file_relativity.path_argument_of_rel_name(expected_contents_file.name) ).as_remaining_source, model_constructor.of_str(self, actual_contents, may_depend_on_external_resources=may_depend_on_external_resources), arrangement_w_tcds( tcds_contents=expected_file_relativity.populator_for_relativity_option_root( DirContents([expected_contents_file]) ) ), Expectation( execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value( expected_result ) ), ), )
def test_stdin_contains_model_contents_WHEN_program_do_not_define_stdin( self): # ARRANGE # test_setup = SingleStdinOfProgramTestSetup(self, exit_code=0) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): with self.subTest(pgm_and_args_case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx( self, RunProgramAbsStx(pgm_and_args_case.pgm_and_args, ), model_constructor.of_str( self, test_setup.STRING_SOURCE_CONTENTS), arrangement_w_tcds( symbols=pgm_and_args_case.symbol_table, process_execution=test_setup. proc_exe_env__w_stdin_check, tcds_contents=pgm_and_args_case.tcds, ), Expectation( ParseExpectation(symbol_references=pgm_and_args_case. references_assertion, ), execution=EXECUTION_OUTPUT_IS_EMPTY, primitive=PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION, ))
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): # ARRANGE # named_transformer = StringTransformerSymbolContext.of_primitive( 'the_transformer', every_line_empty()) original_file_contents = 'some\ntext' symbols = SymbolTable( {named_transformer.name: named_transformer.symbol_table_container}) expected_symbol_reference_to_transformer = is_reference_to_string_transformer( named_transformer.name) expected_symbol_usages = asrt.matches_sequence( [expected_symbol_reference_to_transformer]) self._check_with_source_variants( test_configuration.arguments_for( args( '{transform_option} {the_transformer} {maybe_not} {empty}', the_transformer=named_transformer.name, maybe_not=maybe_not. nothing__if_positive__not_option__if_negative)), model_constructor.of_str(self, original_file_contents), arrangement_w_tcds(post_population_action= MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbols), Expectation( ParseExpectation(symbol_references=expected_symbol_usages), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ))
def _check_variants_with_expectation_type( self, args_variant_constructor: InstructionArgumentsVariantConstructor, expected_result_of_positive_test: PassOrFail, actual_file_contents: str, symbols: SymbolTable = None, expected_symbol_references: Assertion[Sequence[SymbolReference]] = asrt.is_empty_sequence): for expectation_type in ExpectationType: etc = expectation_type_config__non_is_success(expectation_type) with self.subTest(expectation_type=expectation_type): args_variant = args_variant_constructor.construct(expectation_type) complete_instruction_arguments = test_configuration.arguments_for(args_variant) for source in equivalent_source_variants__for_expression_parser( self, complete_instruction_arguments): integration_check.CHECKER__PARSE_FULL.check( self, source, model_constructor.of_str(self, actual_file_contents), Arrangement( tcds=TcdsArrangement( post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY ), symbols=symbols), Expectation( ParseExpectation( symbol_references=expected_symbol_references, ), ExecutionExpectation( main_result=etc.main_result(expected_result_of_positive_test), ), ) )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): expected_content_line_template = 'expected content line, with {symbol} ref' def expected_content(symbol_content: str) -> str: return expected_content_line_template.format(symbol=symbol_content) symbol = StringConstantSymbolContext('symbol_name', 'the symbol value') self._check( test_configuration.source_for( args('{maybe_not} {equals} <<EOF', maybe_not=maybe_not.nothing__if_positive__not_option__if_negative), [expected_content(symbol.name__sym_ref_syntax), 'EOF', 'following line']), model_constructor.of_str(self, lines_content([expected_content(symbol.str_value)])), arrangement_w_tcds( post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbol.symbol_table), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(3), symbol_references=asrt.matches_sequence([ symbol.reference_assertion__w_str_rendering ]), ), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): regex_lines = ['1.3', '4.*6'] here_doc_of_reg_ex = here_document_as_elements(regex_lines) actual_contents = lines_content(['123', '456', '789']) for transformer_option_arguments in TRANSFORMER_OPTION_ALTERNATIVES_ELEMENTS: with self.subTest(maybe_with_transformer_option=transformer_option_arguments): argument_elements = ArgumentElements(transformer_option_arguments + maybe_not.empty__if_positive__not_option__if_negative + [matcher_options.MATCHES_ARGUMENT, FULL_MATCH_ARGUMENT] ).followed_by(here_doc_of_reg_ex) self._check( argument_elements.as_remaining_source, model_constructor.of_str(self, actual_contents), arrangement_w_tcds(), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1 + len(here_doc_of_reg_ex.following_lines)) ), ExecutionExpectation( main_result=maybe_not.fail__if_positive__pass_if_negative ), ), )
def runTest(self): lines = ['1', '2', '3'] actual_number_of_lines = len(lines) integer_matcher = IntegerMatcherSymbolContext.of_primitive( 'INTEGER_MATCHER', matchers.matcher( comparators.EQ, actual_number_of_lines, )) integration_check.CHECKER__PARSE_SIMPLE.check( self, args.NumLines( integer_matcher.name__sym_ref_syntax).as_remaining_source, model_constructor.of_str(self, lines_content(lines)), arrangement_w_tcds(symbols=integer_matcher.symbol_table, ), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1), symbol_references=integer_matcher.references_assertion, ), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True)), ), )
def _new_model( self, environment: InstructionEnvironmentForPostSdsStep) -> StringSource: the_model_constructor = model_constructor.of_str( self.put, self.actual_model_contents) return the_model_constructor( model_constructor.resolving_env_w_custom_dir_space( environment.sds))
def test_tree_of_transformations(self): # ARRANGE # to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'the_to_upper_transformer', string_transformers.to_uppercase()) keep_line_1 = StringTransformerSymbolContext.of_primitive( 'keep_line_1', string_transformers.keep_single_line(1)) keep_line_2 = StringTransformerSymbolContext.of_primitive( 'keep_line_2', string_transformers.keep_single_line(2)) equals_1st = StringMatcherSymbolContext.of_primitive( 'equals_1st', string_matchers.EqualsConstant('1ST\n')) equals_2nd = StringMatcherSymbolContext.of_primitive( 'equals_2nd', string_matchers.EqualsConstant('2ND\n')) model__original = '1st\n2nd\n' symbol_contexts = [ to_upper_transformer, keep_line_1, equals_1st, keep_line_2, equals_2nd, ] # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, args2.Transformed( to_upper_transformer.name__sym_ref_syntax, args2.Parentheses( args2.conjunction([ args2.Parentheses( args2.Transformed( keep_line_1.name__sym_ref_syntax, args2.SymbolReference(equals_1st.name), )), args2.Parentheses( args2.Transformed( keep_line_2.name__sym_ref_syntax, args2.SymbolReference(equals_2nd.name), )), ]))).as_arguments, model_constructor.of_str(self, model__original), arrangement_w_tcds(symbols=SymbolContext.symbol_table_of_contexts( symbol_contexts)), Expectation( ParseExpectation( symbol_references=SymbolContext. references_assertion_of_contexts(symbol_contexts)), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True))))
def runTest(self): # ARRANGE # model_contents = '\n'.join(('the', 'contents', 'of', 'the', 'model')) test_setup = StdinCheckWithProgramWExitCode0ForSuccess() # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx( self, abstract_syntaxes.RunProgramAbsStx( test_setup.program_that_checks_stdin__syntax( 'the contents of stdin', model_contents), ), model_constructor.of_str(self, model_contents), arrangement_w_tcds(tcds_contents=test_setup.tcds_contents, ), Expectation(execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value(True)), ), )
def runTest(self): # ARRANGE # named_transformer = StringTransformerSymbolContext.of_primitive( _TRANSFORMER_SYMBOL_NAME, string_transformers.to_uppercase() ) contents_generator = contents_transformation.TransformedContentsSetup( original='some\ntext', transformed='SOME\nTEXT', ) symbols = self.rel_opt.symbols.in_arrangement() symbols.put(named_transformer.name, named_transformer.symbol_table_container) expected_symbol_reference_to_transformer = is_reference_to_string_transformer(named_transformer.name) expected_symbol_references = asrt.matches_sequence( [expected_symbol_reference_to_transformer] + self.rel_opt.symbols.usage_expectation_assertions() ) self._check_with_source_variants( test_configuration.arguments_for( args( '{transform_option} {transformer} {maybe_not} {equals} ' '{file_option} {relativity_option} expected.txt', transformer=named_transformer.name, maybe_not=self.not_opt.nothing__if_positive__not_option__if_negative, relativity_option=self.rel_opt.option_argument)), model_constructor.of_str(self, contents_generator.original), arrangement_w_tcds( tcds_contents=self.rel_opt.populator_for_relativity_option_root(DirContents([ File('expected.txt', contents_generator.transformed) ])), post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbols, ), Expectation( ParseExpectation( symbol_references=expected_symbol_references, ), ExecutionExpectation( main_result=self.not_opt.pass__if_positive__fail__if_negative, ), ), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): expected_contents = 'expected contents' self._check_with_source_variants( test_configuration.arguments_for( args('{maybe_not} {equals} {expected_contents}', expected_contents=surrounded_by_hard_quotes_str(expected_contents), maybe_not=maybe_not.nothing__if_positive__not_option__if_negative), ), model_constructor.of_str(self, expected_contents), arrangement_w_tcds( post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY), Expectation( execution=ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative ), ), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): actual_contents = '01234' for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES: with self.subTest(maybe_with_transformer_option=maybe_with_transformer_option): self._check_with_source_variants( test_configuration.arguments_for( args('{maybe_with_transformer_option} {maybe_not} {matches} {full_match} 1.3', maybe_with_transformer_option=maybe_with_transformer_option, maybe_not=maybe_not.nothing__if_positive__not_option__if_negative)), model_constructor.of_str(self, actual_contents), arrangement_w_tcds(), Expectation( execution=ExecutionExpectation( main_result=maybe_not.fail__if_positive__pass_if_negative ), ), )
def runTest(self): # ARRANGE # original_model_contents = 'some text' expected_model_contents = original_model_contents.upper() cases = [ NEA( 'transformation that makes matcher match', True, string_transformers.to_uppercase(), ), NEA( 'transformation that makes matcher NOT match', False, delete_everything(), ), ] # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants( self, args2.Transformed( _TRANSFORMER_SYMBOL_NAME, args2.Equals.eq_string( surrounded_by_hard_quotes_str( expected_model_contents))).as_arguments, asrt.matches_singleton_sequence( is_reference_to_string_transformer(_TRANSFORMER_SYMBOL_NAME)), model_constructor.of_str(self, original_model_contents), [ NExArr( case.name, PrimAndExeExpectation.of_exe( main_result=asrt_matching_result.matches_value( case.expected), ), arrangement_w_tcds( symbols=StringTransformerSymbolContext.of_primitive( _TRANSFORMER_SYMBOL_NAME, case.actual).symbol_table, )) for case in cases ], )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): self._check( test_configuration.source_for( args('{maybe_not} {equals} <<EOF', maybe_not=maybe_not.nothing__if_positive__not_option__if_negative), ['expected content line', 'EOF']), model_constructor.of_str(self, lines_content(['expected content line'])), arrangement_w_tcds( post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(3), ), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES: with self.subTest( maybe_with_transformer_option=maybe_with_transformer_option ): self._check_with_source_variants( test_configuration.arguments_for( args( '{maybe_with_transformer_option} {maybe_not} {empty}', maybe_with_transformer_option= maybe_with_transformer_option, maybe_not=maybe_not. nothing__if_positive__not_option__if_negative)), model_constructor.of_str( self, 'contents that makes the file non-empty'), arrangement_w_tcds( post_population_action= MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY), Expectation(execution=ExecutionExpectation( main_result=maybe_not. fail__if_positive__pass_if_negative), ), )
def runTest(self): self._check_with_source_variants( test_configuration.arguments_for( args('{maybe_not} {equals} {file_option} {relativity_option} expected.txt', maybe_not=self.not_opt.nothing__if_positive__not_option__if_negative, relativity_option=self.rel_opt.option_argument)), model_constructor.of_str(self, 'expected'), arrangement_w_tcds( self.rel_opt.populator_for_relativity_option_root( DirContents([File('expected.txt', 'expected')])), post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=self.rel_opt.symbols.in_arrangement(), ), Expectation( ParseExpectation( symbol_references=self.rel_opt.symbols.usages_expectation(), ), ExecutionExpectation( main_result=self.not_opt.pass__if_positive__fail__if_negative, ), ), )
def runTest(self): # ARRANGE # model_contents = 'the contents of the model' test_setup = StdinCheckViaCopyToOutputFileTestSetup( ProcOutputFile.STDOUT) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx( self, RunProgramAbsStx(test_setup.program_that_copies_stdin_syntax(), ), model_constructor.of_str(self, model_contents), arrangement_w_tcds(symbols=SymbolContext.symbol_table_of_contexts( test_setup.symbols), ), Expectation( parse=ParseExpectation( symbol_references=SymbolContext. references_assertion_of_contexts(test_setup.symbols)), execution=ExecutionExpectation( main_result=asrt_string_source.pre_post_freeze__identical( asrt_contents.matches__str(asrt.equals( model_contents)))), primitive=PRIMITIVE_IS_NOT_IDENTITY_TRANSFORMATION, ), )
def runTest(self): model__original = 'the model text' the_model_constructor = model_constructor.of_str(self, model__original) string_transformer = StringTransformerSymbolContext.of_primitive( 'THE_STRING_TRANSFORMER', string_transformers.to_uppercase()) sm_equals = StringMatcherSymbolContext.of_primitive( 'STRING_MATCHER_1', string_matchers.EqualsConstant(model__original.upper())) symbol = [ string_transformer, sm_equals, ] after_bin_op = 'after bin op' sm_conjunction = args2.conjunction([ args2.SymbolReference(sm_equals.name), args2.Custom(after_bin_op), ]) arguments = args2.Transformed(string_transformer.name__sym_ref_syntax, sm_conjunction) integration_check.CHECKER__PARSE_SIMPLE.check( self, source=arguments.as_remaining_source, input_=the_model_constructor, arrangement=arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbol), ), expectation=Expectation( ParseExpectation(source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=' '.join( [sm_conjunction.operator, after_bin_op])), symbol_references=SymbolContext. references_assertion_of_contexts(symbol)), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True))), )
def test_stdin_is_concatenation_of_model_and_program_stdin_WHEN_program_defines_multiple_stdin( self): # ARRANGE # model_contents = '\n'.join(('the', 'contents', 'of', 'the', 'model')) test_setup = MultipleStdinOfProgramTestSetup( self, exit_code=0, additional_stdin=model_contents) # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layouts__source_variants( self, equivalent_source_variants__for_expr_parse__s__nsc, abstract_syntaxes.RunProgramAbsStx( test_setup.program_w_stdin_syntax, ), model_constructor.of_str(self, model_contents), arrangement_w_tcds( symbols=test_setup.program_symbol.symbol_table, process_execution=test_setup.proc_exe_env__w_stdin_check, ), MultiSourceExpectation( symbol_references=test_setup.program_symbol. references_assertion, execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value(True)), ), )
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): # ARRANGE # string_to_prepend = '.' initial_model_contents = '\n' model_after_2_transformations = ''.join( [string_to_prepend, string_to_prepend, initial_model_contents]) initial_model = model_constructor.of_str(self, initial_model_contents) equals_expected_matcher = StringMatcherSymbolContext.of_primitive( 'EQUALS_EXPECTED', EqualsMatcherTestImpl(model_after_2_transformations)) prepend_transformer_symbol = StringTransformerSymbolContext.of_primitive( 'PREPEND_TRANSFORMER', string_transformers.of_line_transformer__w_preserved_line_ending( 'prepend to each line', lambda line: (line + string_to_prepend))) prepend_trans_arg = str_trans_syntax.syntax_for_transformer_option( prepend_transformer_symbol.name) trans_and_eq_expected_matcher_source = remaining_source( '{prepend_trans_arg} {equals_expected_matcher}'.format( prepend_trans_arg=prepend_trans_arg, equals_expected_matcher=equals_expected_matcher.name, )) # ACT & ASSERT # parser = sut.parsers().full prepend_and_equals_expected_matcher_sdv = parser.parse( trans_and_eq_expected_matcher_source) prepend_and_equals_expected_matcher = StringMatcherSymbolContext.of_sdv( 'PREPEND_AND_EQUALS_EXPECTED', prepend_and_equals_expected_matcher_sdv) symbols = SymbolContext.symbol_table_of_contexts([ equals_expected_matcher, prepend_transformer_symbol, prepend_and_equals_expected_matcher, ]) expected_symbol_references = asrt.matches_sequence([ is_reference_to_string_transformer( prepend_transformer_symbol.name), is_reference_to_string_matcher( prepend_and_equals_expected_matcher.name), ]) self._check_with_source_variants( test_configuration.arguments_for( args( '{prepend_trans_arg} {maybe_not} {prepend_and_equals_expected_matcher}', prepend_trans_arg=prepend_trans_arg, maybe_not=maybe_not. nothing__if_positive__not_option__if_negative, prepend_and_equals_expected_matcher= prepend_and_equals_expected_matcher.name)), initial_model, arrangement_w_tcds(symbols=symbols), Expectation( ParseExpectation( symbol_references=expected_symbol_references, ), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ))