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,
),
))
