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 expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=pgm_and_args_case.expected_command_driver(env),
arguments=asrt.equals(arguments),
),
stdin=asrt.matches_singleton_sequence(
asrt_str_src.matches__str(
asrt.equals(str_src_contents), )),
transformer=asrt.matches_singleton_sequence(
asrt.is_(transformer_symbol.primitive)),
)
def test_symbol_reference_on_command_line_SHOULD_be_reported_and_used_in_execution(
self):
symbol = StringConstantSymbolContext('symbol_name', 'symbol value')
string_to_print_template = 'constant and {symbol}'
expected_output_template = string_to_print_template + '\n'
shell_source_line = shell_commands.command_that_prints_to_stdout(
string_to_print_template.format(
symbol=symbol.name__sym_ref_syntax))
act_phase_instructions = [
instr([shell_command_source_line_for(shell_source_line)])
]
check_execution(
self,
sut.actor(),
act_phase_instructions,
arrangement_w_tcds(symbol_table=symbol.symbol_table),
Expectation(symbol_usages=asrt.matches_singleton_sequence(
symbol.reference_assertion__w_str_rendering),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=pr.stdout(
asrt.equals(
expected_output_template.format(
symbol=symbol.str_value))))),
)
def runTest(self):
# ARRANGE #
source_file = fs.File.empty('source-file.src')
python_interpreter_symbol = PathSymbolContext.of_sdv(
'PYTHON_INTERPRETER_SYMBOL',
path_sdvs.constant(
path_ddvs.absolute_path(pathlib.Path(sys.executable))))
interpreter_with_symbol_reference = command_sdvs.for_executable_file(
python_interpreter_symbol.reference_sdv__path_or_string(
relativity_configurations.INTERPRETER_FILE.relativity))
arrangement = arrangement_w_tcds(
symbol_table=python_interpreter_symbol.symbol_table,
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([source_file])))
expectation = Expectation(
symbol_usages=asrt.matches_singleton_sequence(
python_interpreter_symbol.reference_assertion__path_or_string),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=asrt_pr.sub_process_result(
exitcode=asrt.equals(0),
stdout=asrt.equals(''),
stderr=asrt.equals(''),
)),
)
# ACT & ASSERT #
check_execution(self, sut.actor(interpreter_with_symbol_reference),
[instr([])], arrangement, expectation)
def runTest(self):
# ARRANGE #
exit_code_from_program = 0
exe_file_in_path = fs.python_executable_file(
'the-program',
lines_content(py_program.exit_with_code(exit_code_from_program)),
)
program_symbol = StringConstantSymbolContext(
'PROGRAM_NAME_SYMBOL',
exe_file_in_path.name,
)
program_line = args.system_program_command_line(
program_symbol.name__sym_ref_syntax).as_str
with tmp_dir_in_path_with_files(DirContents([exe_file_in_path
])) as environ:
for source_case in valid_source_variants(program_line):
with self.subTest(source_case.name):
# ACT & ASSERT #
integration_check.check_execution(
self,
sut.actor(),
[instr([program_line])],
arrangement_w_tcds(
symbol_table=program_symbol.symbol_table,
act_exe_input=AtcExeInputArr(environ=environ),
),
Expectation(
symbol_usages=asrt.matches_singleton_sequence(
program_symbol.
reference_assertion__string__w_all_indirect_refs_are_strings
),
execute=asrt_eh.is_exit_code(
exit_code_from_program)),
)
def test_symbol_reference_in_dst_file_argument(self):
dst_path_symbol = ConstantSuffixPathDdvSymbolContext(
'dst_path_symbol', RelOptionType.REL_ACT, 'dst-file.txt',
ACCEPTED_DST_RELATIVITY_VARIANTS)
string_value = rich_str_abs_stx.HereDocAbsStx(
'single line in here doc\n')
instruction_syntax = instr_abs_stx.create_w_explicit_contents(
dst_path_symbol.abstract_syntax,
string_source_abs_stx.StringSourceOfStringAbsStx(string_value),
)
expected_file = fs.File(dst_path_symbol.path_suffix,
string_value.value)
integration_check.CHECKER__BEFORE_ACT.check__abs_stx(
self, instruction_syntax,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=
SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, ),
symbols=dst_path_symbol.symbol_table,
),
Expectation.phase_agnostic(
main_result=IS_SUCCESS,
symbol_usages=asrt.matches_singleton_sequence(
dst_path_symbol.reference_assertion),
main_side_effects_on_sds=dir_contains_exactly(
dst_path_symbol.rel_option_type,
fs.DirContents([expected_file])),
))
def test_possibility_to_have_sds_path_references_in_argument(self):
file_name_of_referenced_file = 'file-name.txt'
symbol = ConstantSuffixPathDdvSymbolContext(
'symbol_name', RelOptionType.REL_TMP, file_name_of_referenced_file)
executable = 'the-executable'
command_line = '{executable} {symbol}'.format(
executable=executable,
symbol=symbol.name__sym_ref_syntax,
)
arrangement = arrangement_w_tcds(
hds_contents=relativity_configurations.ATC_FILE.
populator_for_relativity_option_root__hds(
fs.DirContents([
fs.python_executable_file(
executable,
PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES
)
])),
symbol_table=symbol.symbol_table)
expectation = Expectation(
execute=eh_assertions.is_exit_code(0),
symbol_usages=asrt.matches_singleton_sequence(
symbol.reference_assertion__w_str_rendering),
post_sds=PostSdsExpectation.constant(
sub_process_result_from_execute=pr.stdout(
str_asrt.contains(file_name_of_referenced_file))),
)
check_execution(self, sut.actor(), [instr([command_line])],
arrangement, expectation)
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):
# ARRANGE #
matcher = LineMatcherSymbolContext.of_primitive_constant(
'line_matcher_symbol',
False,
)
line_matcher_arg = lm_args.SymbolReference(matcher.name)
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
# ACT & ASSERT #
for may_depend_on_external_resources in [False, True]:
with self.subTest(may_depend_on_external_resources=may_depend_on_external_resources):
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
remaining_source(arguments),
model_constructor.empty(self,
may_depend_on_external_resources=may_depend_on_external_resources),
arrangement_w_tcds(
symbols=matcher.symbol_table
),
expectation_of_successful_filter_execution(
symbol_references=asrt.matches_singleton_sequence(
matcher.reference_assertion
),
output_lines=[],
)
)
def runTest(self):
unconditionally_constant_true = FilesMatcherSymbolContext.of_primitive_constant(
'unconditionally_constant_true', True)
symbols = unconditionally_constant_true.symbol_table
location = RelSdsOptionType.REL_TMP
model_file_name = 'the-checked-file'
integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
arguments=args.DirContents(
args.SymbolReference(
unconditionally_constant_true.name)).as_arguments,
symbol_references=asrt.matches_singleton_sequence(
unconditionally_constant_true.reference_assertion),
input_=integration_check.file_in_sds(location, model_file_name),
execution=[
NExArr(
invalid_file_case.name,
PrimAndExeExpectation.of_exe(
is_hard_error=asrt_renderer.
is_renderer_of_major_blocks()),
arrangement_w_tcds(
symbols=symbols,
non_hds_contents=sds_populator.contents_in(
location, invalid_file_case.value)))
for invalid_file_case in invalid_model.cases(model_file_name)
])
def test_node_with_detail_and_child(self):
# ARRANGE #
for child_data in [False, True]:
with self.subTest(data=child_data):
child = Node('the child', child_data, (), ())
detail = StringDetail('the detail')
root = Node('the root', False, [detail], [child])
# EXPECTATION #
expectation = asrt_struct.matches_major_block__w_plain_properties(
minor_blocks=asrt.matches_sequence([
asrt_struct.matches_minor_block(
line_elements=asrt.matches_sequence([
matches_header_line_element(root),
matches_string_detail_line_element(detail,
depth=0),
]),
properties=matches_node_properties(depth=0),
),
asrt_struct.matches_minor_block(
line_elements=asrt.matches_singleton_sequence(
matches_header_line_element(child)),
properties=matches_node_properties(depth=1),
),
]))
# ACT & ASSERT #
_check(self, root, expectation)
def test(self):
expected_defined_symbol = ConstantSuffixPathDdvSymbolContext(
'name', RelOptionType.REL_ACT, 'component')
argument_cases = [
NameAndValue('value on same line', '{rel_act} {suffix}'),
NameAndValue('value on following line',
'{new_line} {rel_act} {suffix}'),
]
for argument_case in argument_cases:
with self.subTest(arguments=argument_case.name):
instruction_argument = src2(
ValueType.PATH,
expected_defined_symbol.name,
argument_case.value,
suffix=expected_defined_symbol.path_suffix)
for source in equivalent_source_variants__with_source_check__consume_last_line(
self, instruction_argument):
INSTRUCTION_CHECKER.check(
self, source, Arrangement.phase_agnostic(),
Expectation.phase_agnostic(
symbol_usages=asrt.matches_singleton_sequence(
expected_defined_symbol.
assert_matches_definition_of_sdv),
symbols_after_main=assert_symbol_table_is_singleton(
expected_defined_symbol.name,
expected_defined_symbol.value.
assert_matches_container_of_sdv)))
def runTest(self):
# ARRANGE #
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'a-dir')
unconditionally_hard_error_file_matcher = FileMatcherSymbolContext.of_primitive(
'unconditionally_hard_error_file_matcher',
matchers.MatcherThatReportsHardError())
file_in_model = 'a-file'
# ACT & ASSERT #
check_non_full_and_full(
self,
fc_args.FilesCondition([
fc_args.FileCondition(
file_in_model,
fm_args.SymbolReferenceWReferenceSyntax(
unconditionally_hard_error_file_matcher.name)),
]),
model_constructor__non_recursive(checked_dir.path_sdv),
Arrangement(
symbols=unconditionally_hard_error_file_matcher.symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(file_in_model)])),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
unconditionally_hard_error_file_matcher.
reference_assertion)),
ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text())),
)
def test_transformation_only_as_source_argument(self):
# ARRANGE #
transformer = StringTransformerPrimitiveSymbolContext(
'STRING_TRANSFORMER', string_transformers.to_uppercase())
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
program_w_transformer = FullProgramAbsStx(
pgm_and_args_case.pgm_and_args,
transformation=transformer.abstract_syntax)
symbols = list(pgm_and_args_case.symbols) + [transformer]
with self.subTest(command=pgm_and_args_case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_transformer,
pgm_and_args_case.mk_arrangement(
SymbolContext.symbol_table_of_contexts(symbols)),
MultiSourceExpectation(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
primitive=lambda env: (asrt_pgm_val.matches_program(
asrt_command.
matches_command(driver=pgm_and_args_case.
expected_command_driver(env),
arguments=asrt.is_empty_sequence),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt.matches_singleton_sequence(
asrt.is_(transformer.primitive)),
))))
def runTest(self):
# ARRANGE #
files_matcher_name = 'the_files_matcher'
checked_dir_location = RelSdsOptionType.REL_TMP
checked_dir = Dir.empty('checked-dir')
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
arguments=args.DirContents(
fsm_args.SymbolReference(files_matcher_name)).as_arguments,
input_=integration_check.file_in_sds(checked_dir_location,
checked_dir.name),
symbol_references=asrt.matches_singleton_sequence(
is_reference_to_files_matcher(files_matcher_name)),
execution=[
NExArr(
'checked dir is empty',
PrimAndExeExpectation.of_exe(
main_result=asrt_matching_result.matches_value(
matcher_result)),
arrangement_w_tcds(
non_hds_contents=sds_populator.contents_in(
checked_dir_location, DirContents([checked_dir])),
symbols=FilesMatcherSymbolContext.
of_primitive_constant(files_matcher_name,
matcher_result).symbol_table,
),
) for matcher_result in [False, True]
],
)
def test_SHOULD_not_be_identity_transformer(self):
# ARRANGE #
matcher = LineMatcherSymbolContext.of_primitive_constant(
'line_matcher_symbol',
False,
)
line_matcher_arg = lm_args.SymbolReference(matcher.name)
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, []),
arrangement_w_tcds(
symbols=matcher.symbol_table
),
expectation_of_successful_filter_execution(
symbol_references=asrt.matches_singleton_sequence(
matcher.reference_assertion
),
output_lines=[],
)
)
def test(self):
with tmp_dir() as abs_path_of_dir_containing_last_file_base_name:
fs_location_info = FileSystemLocationInfo(
FileLocationInfo(
abs_path_of_dir_containing_last_file_base_name))
instruction_argument = src2(ValueType.PATH, 'name',
'{rel_source_file} component')
for source in equivalent_source_variants__with_source_check__consume_last_line(
self, instruction_argument):
expected_path_sdv = path_sdvs.constant(
path_ddvs.rel_abs_path(
abs_path_of_dir_containing_last_file_base_name,
path_ddvs.constant_path_part('component')))
expected_symbol_value = PathSymbolValueContext.of_sdv(
expected_path_sdv)
expected_symbol = PathSymbolContext('name',
expected_symbol_value)
INSTRUCTION_CHECKER.check(
self, source,
Arrangement.phase_agnostic(
fs_location_info=fs_location_info),
Expectation.phase_agnostic(
symbol_usages=asrt.matches_singleton_sequence(
expected_symbol.assert_matches_definition_of_sdv),
symbols_after_main=assert_symbol_table_is_singleton(
'name', expected_symbol_value.
assert_matches_container_of_sdv)))
def expectation(self) -> Expectation:
return Expectation(
symbol_usages=asrt.matches_singleton_sequence(
is_reference_to_files_matcher__usage(
self.name_of_referenced_symbol)),
main_result=asrt_pfh.is_hard_error(
is_string_for_test_that_equals(self.error_message)),
)
def runTest(self):
# ARRANGE #
files_matcher_name = 'the_files_matcher'
checked_dir_location = RelOptionType.REL_ACT
checked_dir = Dir.empty('checked-dir')
matcher_argument = SymbolReferenceArgument(files_matcher_name).as_str
tcds = TcdsArrangementPostAct(
TcdsPopulatorForRelOptionType(checked_dir_location,
DirContents([checked_dir])))
source_cases = [
NameAndValue(
'All arguments on separate lines',
Arguments(checked_dir.name, [
reserved_words.COLON, args.RECURSION_OPTION_STR,
matcher_argument
]),
),
NameAndValue(
'Empty lines between arguments',
Arguments(checked_dir.name, [
'',
reserved_words.COLON,
'',
args.RECURSION_OPTION_STR,
'',
matcher_argument,
]),
),
]
execution_cases = [
NExArr(
'matcher gives ' + str(matcher_result),
ExecutionExpectation(
main_result=asrt_pfh.is_non_hard_error(matcher_result)),
ArrangementPostAct2(
tcds,
symbols=FilesMatcherSymbolContext.of_primitive_constant(
files_matcher_name, matcher_result).symbol_table))
for matcher_result in [False, True]
]
# ACT & ASSERT #
for source_case in source_cases:
with self.subTest(source_case=source_case.name):
INSTRUCTION_CHECKER.check_multi__with_source_variants(
self,
SourceArrangement.new_w_arbitrary_fs_location(
source_case.value),
symbol_usages=asrt.matches_singleton_sequence(
is_reference_to_files_matcher__usage(
files_matcher_name)),
execution=execution_cases,
)
def test_matches(self):
command = system_program_command('program', [])
stdin_data = ()
transformer = IdentityStringTransformer()
sut.matches_program(
command=asrt.is_(command),
stdin=asrt.is_(stdin_data),
transformer=asrt.matches_singleton_sequence(asrt.is_(transformer)),
)
def test_result_of_execution_SHOULD_be_negation_of_negated_expr(self):
# ARRANGE #
conf = self.configuration
helper = self._asrt_helper
symbol_name = conf.valid_symbol_name_and_not_valid_primitive_or_operator(
)
mk_operand_trace = get_mk_operand_trace('the_operand')
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))
execution_cases = [
execution_case_for(operand_result)
for operand_result in [False, True]
]
source_cases = [
NameAndValue(
'operand on same line',
ArgumentElements([logic.NOT_OPERATOR_NAME, symbol_name], )),
NameAndValue(
'operand on following line',
ArgumentElements([logic.NOT_OPERATOR_NAME], [
[symbol_name],
])),
]
# ACT & ASSERT #
for source_case in source_cases:
with self.subTest(source_case.name):
conf.checker_for_parser_of_full_expr(
).check_multi__w_source_variants(
self,
arguments=source_case.value.as_arguments,
symbol_references=asrt.matches_singleton_sequence(
helper.is_sym_ref_to(symbol_name)),
input_=conf.arbitrary_model,
execution=execution_cases,
)
def test_matches(self):
# ARRANGE #
expected_detail = StringDetail('the string detail')
actual = sut.IndentedDetail([expected_detail])
# EXPECTATION #
assertion = sut.is_indented_detail(
details=asrt.matches_singleton_sequence(asrt.is_(expected_detail))
)
# ACT & ASSERT #
assertion.apply_without_message(self, actual)
def test_should_have_exactly_one_references(self):
# ARRANGE #
symbol_reference = TypeWithStrRenderingSymbolReference(
'the_symbol_name', is_any_type_w_str_rendering())
fragment = impl.SymbolStringFragmentSdv(symbol_reference.reference)
# ACT #
actual = list(fragment.references)
# ASSERT #
assertion = asrt.matches_singleton_sequence(
symbol_reference.reference_assertion)
assertion.apply_without_message(self, actual)
def test_referenced_symbol_SHOULD_be_validated(self):
symbol_name = 'fc_symbol'
for symbol_ref_syntax in symbol_ref_syntax_cases(symbol_name):
with self.subTest(symbol_ref_syntax=symbol_ref_syntax.name):
CHECKER.check_multi__w_source_variants(
self,
arguments=Arguments(symbol_ref_syntax.value),
symbol_references=asrt.matches_singleton_sequence(
is_reference_to_files_condition(symbol_name)),
input_=None,
execution=failing_validation_cases__multi_exe(symbol_name),
)
def test_every_line_SHOULD_be_filtered(self):
matcher = LineMatcherSymbolContext.of_primitive(
'line_matcher_symbol',
sub_string_line_matcher('MATCH'),
)
line_matcher_arg = lm_args.SymbolReference(matcher.name)
cases = [
NEA('no lines',
[],
[],
),
NEA('single line that matches',
['a MATCH'],
['a MATCH'],
),
NEA('single line that matches, ended by new-line',
['a MATCH\n'],
['a MATCH\n'],
),
NEA('single line that does not match',
actual=['not a match'],
expected=[],
),
NEA('some lines matches',
actual=with_appended_new_lines([
'first line is a MATCH',
'second line is not a match',
'third line MATCH:es',
'fourth line not',
]),
expected=with_appended_new_lines([
'first line is a MATCH',
'third line MATCH:es',
]),
),
]
for case in cases:
with self.subTest(case_name=case.name):
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, case.actual),
arrangement_w_tcds(
symbols=matcher.symbol_table
),
expectation_of_successful_filter_execution(
output_lines=case.expected,
symbol_references=asrt.matches_singleton_sequence(
references.is_reference_to_line_matcher(matcher.name)
),
)
)
def matches_trace_with_details(
tree: Node[bool],
details: Sequence[Assertion[s.LineElement]],
) -> Assertion[s.MajorBlock]:
expected_line_elements = asrt.matches_sequence(
[matches_header_line_element(tree)] + list(details))
return asrt_struct.matches_major_block__w_plain_properties(
minor_blocks=asrt.matches_singleton_sequence(
asrt_struct.matches_minor_block(
line_elements=expected_line_elements,
properties=matches_node_properties(depth=0),
)))
def test_expression_inside_parentheses_SHOULD_be_validated(self):
symbol_name = 'fc_symbol'
CHECKER.check_multi__w_source_variants(
self,
arguments=args.Parentheses(
args.SymbolReferenceWReferenceSyntax(
symbol_name)).as_arguments,
symbol_references=asrt.matches_singleton_sequence(
is_reference_to_files_condition(symbol_name)),
input_=None,
execution=failing_validation_cases__multi_exe(symbol_name),
)
def runTest(self):
fsm_symbol_name = 'the_files_matcher'
integration_check.CHECKER__PARSE_FULL.check_multi__w_source_variants(
self,
args.DirContents(
args.SymbolReference(fsm_symbol_name)).as_arguments,
symbol_references=asrt.matches_singleton_sequence(
is_reference_to_files_matcher(fsm_symbol_name)),
input_=integration_check.constant_relative_file_name(
'arbitrary-file-argument'),
execution=instruction_validation_cases.
failing_validation_cases__multi_exe(fsm_symbol_name))
def test_header(self):
# ARRANGE #
for data in [False, True]:
with self.subTest(data=data):
root = Node('header', data, (), ())
renderer = ConstantNodeRendererTestImpl(root)
# EXPECTATION #
expectation = asrt_struct.matches_major_block__w_plain_properties(
minor_blocks=asrt.matches_singleton_sequence(
asrt_struct.matches_minor_block__w_plain_properties(
line_elements=asrt.matches_singleton_sequence(
_matches_header_line_element(root)
),
)
)
)
# ACT & ASSERT #
_check(self, root, expectation)
def runTest(self):
# ARRANGE #
transformer = StringTransformerPrimitiveSymbolContext(
'STRING_TRANSFORMER', string_transformers.to_uppercase())
after_bin_op = 'after bin op'
after_bin_op_syntax = CustomStringTransformerAbsStx.of_str(
after_bin_op)
composition_string_transformer = StringTransformerCompositionAbsStx(
[transformer.abstract_syntax, after_bin_op_syntax],
within_parens=False,
allow_elements_on_separate_lines=False,
)
expected_source_after_parse = asrt_source.is_at_line(
current_line_number=2,
remaining_part_of_current_line=' '.join(
[composition_string_transformer.operator_name(),
after_bin_op]),
)
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(
):
command_followed_by_transformer = FullProgramAbsStx(
pgm_and_args_case.pgm_and_args,
transformation=composition_string_transformer,
)
symbols = list(pgm_and_args_case.symbols) + [transformer]
with self.subTest(command=pgm_and_args_case.name):
source = remaining_source(
command_followed_by_transformer.tokenization().layout(
LayoutSpec.of_default()))
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check(
self, source, None,
pgm_and_args_case.mk_arrangement(
SymbolContext.symbol_table_of_contexts(symbols)),
Expectation(
ParseExpectation(
source=expected_source_after_parse,
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
),
primitive=lambda env: (asrt_pgm_val.matches_program(
asrt_command.
matches_command(driver=pgm_and_args_case.
expected_command_driver(env),
arguments=asrt.is_empty_sequence),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt.matches_singleton_sequence(
asrt.is_(transformer.primitive)),
))))
