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_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 expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=command_driver.expected_command_driver(env),
arguments=asrt.equals(all_arguments)),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
def expected_program(env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=program_ref_case.expected_command_driver(env),
arguments=asrt.is_empty_sequence,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_shell_command(
command_line=shell_command_line_of_referenced_program,
arguments=expected_argument_strings,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_system_program_command(
program=program_case.expected_resolved_value,
arguments=argument_case.expected_resolved_values(
env.tcds)),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
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.is_empty_sequence),
stdin=asrt.matches_singleton_sequence(
asrt_str_src.matches__str(
asrt.equals(str_src_contents), )),
transformer=asrt_pgm_val.is_no_transformation(),
)
def expected_program(
env: AssertionResolvingEnvironment) -> Assertion[Program]:
return asrt_pgm_val.matches_program(
command=asrt_command.equals_system_program_command(
program=referenced_system_program_name,
arguments=referenced_program_arguments +
case.expected_additional_arguments,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)
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)),
))))
def runTest(self):
# ARRANGE #
for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference():
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_consume_until_end_of_last_line__s__nsc,
pgm_and_args_case.pgm_and_args,
pgm_and_args_case.mk_arrangement(SymbolContext.symbol_table_of_contexts(pgm_and_args_case.symbols)),
MultiSourceExpectation(
symbol_references=SymbolContext.references_assertion_of_contexts(pgm_and_args_case.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_pgm_val.is_no_transformation(),
)
)
)
)
def test_not_matches(self):
expected_command = system_program_command('program', [])
expected_stdin = [string_sources.string_source_that_must_not_be_used()]
expected_transformer = IdentityStringTransformer()
assertion = sut.matches_program(
command=asrt.is_(expected_command),
stdin=asrt.len_equals(len(expected_stdin)),
transformer=asrt.matches_singleton_sequence(
asrt.is_(expected_transformer)),
)
actual_command = system_program_command('program', [])
actual_stdin = ()
actual_transformer = ()
cases = [
NameAndValue(
'unexpected command',
Program(command=actual_command,
stdin=expected_stdin,
transformation=[expected_transformer])),
NameAndValue(
'unexpected stdin',
Program(command=expected_command,
stdin=actual_stdin,
transformation=[expected_transformer])),
NameAndValue(
'unexpected transformer',
Program(command=expected_command,
stdin=expected_stdin,
transformation=actual_transformer)),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(assertion, case.value)
def test_stdin_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
str_src_contents__of_argument = 'the_str_src_contents__of_argument'
str_src_contents__of_referenced_pgm = 'the_str_src_contents__of_program'
stdin_argument_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str(
str_src_contents__of_argument)
stdin_sdv__of_referenced = str_src_sdvs.ConstantStringStringSourceSdv(
string_sdvs.str_constant(str_src_contents__of_referenced_pgm))
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
stdin=[stdin_sdv__of_referenced],
)
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
symbols__symbol_table = [referenced_program]
symbols__expected_references = [referenced_program]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_stdin = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
stdin=stdin_argument_syntax,
)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt.matches_sequence([
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_referenced_pgm)),
asrt_str_src.matches__str(
asrt.equals(str_src_contents__of_argument)),
]),
transformer=asrt_pgm_val.is_no_transformation(),
)
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self, equivalent_source_variants__for_expr_parse__s__nsc,
program_w_stdin,
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
def test_list_of_arguments_and_symbol_references(self):
arg_wo_space = 'arg_wo_space'
arg_w_space = 'an arg w space'
string_symbol_1 = StringConstantSymbolContext(
'STRING_SYMBOL_1',
'value of string symbol 1',
default_restrictions=asrt_data_rest.is__w_str_rendering(),
)
string_symbol_2 = StringConstantSymbolContext(
'STRING_SYMBOL_2',
'value of string symbol 2',
default_restrictions=asrt_data_rest.is__w_str_rendering(),
)
arguments_cases = [
ArgumentsCase(
'one / wo symbol references',
arguments=[
ArgumentOfRichStringAbsStx.of_str(arg_w_space,
QuoteType.SOFT)
],
expected_arguments=[arg_w_space],
symbols=(),
),
ArgumentsCase(
'two / wo symbol references',
arguments=[
ArgumentOfRichStringAbsStx.of_str(arg_wo_space),
ArgumentOfRichStringAbsStx.of_str(arg_w_space,
QuoteType.HARD)
],
expected_arguments=[arg_wo_space, arg_w_space],
symbols=(),
),
ArgumentsCase(
'three / w symbol references',
arguments=[
ArgumentOfSymbolReferenceAbsStx(string_symbol_1.name),
ArgumentOfRichStringAbsStx.of_str(arg_w_space,
QuoteType.HARD),
ArgumentOfSymbolReferenceAbsStx(string_symbol_2.name)
],
expected_arguments=[
string_symbol_1.str_value, arg_w_space,
string_symbol_2.str_value
],
symbols=[string_symbol_1, string_symbol_2],
),
]
# ARRANGE #
for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__excluding_program_reference(
):
for arguments_case in arguments_cases:
pgm_w_args = PgmAndArgsWArgumentsAbsStx(
pgm_and_args_case.pgm_and_args, arguments_case.arguments)
expected_arguments = asrt.equals(
arguments_case.expected_arguments)
symbols = list(pgm_and_args_case.symbols) + list(
arguments_case.symbols)
expectation = 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=expected_arguments,
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt_pgm_val.is_no_transformation(),
)))
with self.subTest(command=pgm_and_args_case.name,
arguments=arguments_case.name):
# ACT & ASSERT #
CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input(
self,
equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc,
pgm_w_args,
pgm_and_args_case.mk_arrangement(
SymbolContext.symbol_table_of_contexts(symbols)),
expectation,
)
def test_transformation_in_referenced_program_and_as_source_argument(self):
# ARRANGE #
transformer__in_referenced_program = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER_IN_REFERENCED_PROGRAM',
string_transformers.delete_everything())
referenced_program__system_program = 'the-system-program'
referenced_program__sdv = program_sdvs.system_program(
string_sdvs.str_constant(referenced_program__system_program),
transformations=[transformer__in_referenced_program.reference_sdv])
referenced_program = ProgramSymbolContext.of_sdv(
'REFERENCED_PROGRAM', referenced_program__sdv)
transformer__in_source = StringTransformerPrimitiveSymbolContext(
'TRANSFORMER_IN_SOURCE', string_transformers.to_uppercase())
symbols__symbol_table = [
referenced_program, transformer__in_referenced_program,
transformer__in_source
]
symbols__expected_references = [
referenced_program, transformer__in_source
]
arguments_cases = [
NameAndValue(
'no arguments',
[],
),
NameAndValue(
'single argument',
['arg1'],
)
]
for arguments_case in arguments_cases:
with self.subTest(arguments=arguments_case.name):
program_w_transformer = FullProgramAbsStx(
ProgramOfSymbolReferenceAbsStx(referenced_program.name, [
ArgumentOfRichStringAbsStx.of_str(arg)
for arg in arguments_case.value
]),
transformation=transformer__in_source.abstract_syntax)
expected_primitive = asrt_pgm_val.matches_program(
asrt_command.matches_command(
driver=asrt_command.
matches_system_program_command_driver(
asrt.equals(referenced_program__system_program)),
arguments=asrt.equals(arguments_case.value),
),
stdin=asrt_pgm_val.is_no_stdin(),
transformer=asrt.matches_sequence([
asrt.is_(transformer__in_referenced_program.primitive),
asrt.is_(transformer__in_source.primitive),
]),
)
# 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,
arrangement_wo_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbols__symbol_table), ),
MultiSourceExpectation.of_const(
symbol_references=SymbolContext.
references_assertion_of_contexts(
symbols__expected_references),
primitive=expected_primitive,
))
