def test(self):
# ARRANGE #
reg_ex_pattern = 'const_pattern'
arguments = st_args.syntax_for_filter_transformer(str(
lm_args.Contents(sm_args.Matches(reg_ex_pattern)))
)
lines = [
reg_ex_pattern + '\n',
'non matching line',
]
expected_lines = [
reg_ex_pattern + '\n',
]
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, lines),
arrangement_w_tcds(),
expectation_of_successful_filter_execution(
output_lines=expected_lines,
symbol_references=asrt.is_empty_sequence,
)
)
def runTest(self):
# ARRANGE #
for case in validation_cases.failing_validation_cases():
line_matcher_symbol_context = case.value.symbol_context
line_matcher_arg = lm_args.SymbolReference(line_matcher_symbol_context.name)
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
with self.subTest(case.name):
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, []),
arrangement_wo_tcds(
symbols=line_matcher_symbol_context.symbol_table
),
Expectation(
ParseExpectation(
symbol_references=line_matcher_symbol_context.references_assertion
),
ExecutionExpectation(
validation=case.value.expectation,
)
)
)
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 runTest(self):
# ARRANGE #
arguments = names.IDENTITY_TRANSFORMER_NAME
model_content_lines = ['the model contents line 1']
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, model_content_lines),
arrangement_w_tcds(),
Expectation(
ParseExpectation(
symbol_references=asrt.is_empty_sequence,
),
ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__matches_lines__identical(
asrt.equals(model_content_lines),
may_depend_on_external_resources=asrt.equals(False),
)
),
prim_asrt__constant(is_identity_transformer(True)),
adv=freeze_check.first_invoked_method_of_source_model__is_freeze,
)
)
def check__w_access_of_all_model_properties(
put: unittest.TestCase,
range_expr: Sequence[range_args.Range],
input_and_expected: InputAndExpectedWExtDeps,
):
arguments = args.filter_line_nums__multi(range_expr)
for source_may_depend_on_external_resources in [False, True]:
with put.subTest(may_depend_on_external_resources=
source_may_depend_on_external_resources):
integration_check.CHECKER__PARSE_SIMPLE.check(
put, arguments.as_remaining_source,
model_constructor.of_lines(
put,
input_and_expected.input,
may_depend_on_external_resources=
source_may_depend_on_external_resources,
), arrangement_w_tcds(),
integration_check.expectation_of_successful_execution(
symbol_references=asrt.is_empty_sequence,
output_lines=input_and_expected.expected.lines,
may_depend_on_external_resources=input_and_expected.
expected.may_dep_on_ext_rsrc(
source_may_depend_on_external_resources),
frozen_may_depend_on_external_resources=asrt.anything_goes(
),
is_identity_transformer=False,
))
def test_regular_expression_SHOULD_be_matched(self):
# ARRANGE #
input_lines = [
'Exactly',
]
expected_lines = [
'is what I want',
]
for line_filter_case in LINE_FILTER_CASES:
for preserve_new_lines in [False, True]:
source = ReplaceRegexAbsStx.of_str(
'[E][x][a][c][t][l][y]',
quoting.surrounded_by_str('is what I want',
QuoteType.HARD),
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
source,
model_constructor.of_lines(self, input_lines),
arrangement_w_tcds(
symbols=line_filter_case.value.symbol_table, ),
expectation_of_successful_replace_execution__multi(
symbol_references=line_filter_case.value.
references_assertion,
may_depend_on_external_resources=line_filter_case.
value.may_depend_on_external_resources,
output_lines=expected_lines,
),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
})
def runTest(self):
# ARRANGE #
symbol_in_regex = StringConstantSymbolContext(
'symbol_in_regex',
'plain string pattern',
default_restrictions=asrt_regex.is_reference_restrictions__regex())
symbol_in_replacement = StringConstantSymbolContext(
'symbol_in_replacement',
'the replacement',
default_restrictions=asrt_ref_rest.is__w_str_rendering(),
)
input_lines = [
symbol_in_regex.str_value,
]
expected_lines = [
symbol_in_replacement.str_value,
]
quoting_cases = [
None,
QuoteType.SOFT,
]
for line_filter_case in LINE_FILTER_CASES:
all_symbols = line_filter_case.value.symbols + [
symbol_in_regex,
symbol_in_replacement,
]
for preserve_new_lines in [False, True]:
for quoting_variant in quoting_cases:
source = ReplaceRegexAbsStx(
StringLiteralAbsStx(
symbol_in_regex.name__sym_ref_syntax,
quoting_variant),
symbol_in_replacement.abstract_syntax,
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
source,
model_constructor.of_lines(self, input_lines),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols), ),
expectation_of_successful_replace_execution__multi(
symbol_references=SymbolContext.
references_assertion_of_contexts(all_symbols),
may_depend_on_external_resources=line_filter_case.
value.may_depend_on_external_resources,
output_lines=expected_lines,
),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
'quoting': quoting_variant,
'line_filtering': line_filter_case.name,
})
def test_no_lines(self):
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self, Arguments(self.config.arguments),
model_constructor.of_lines(self, []), arrangement_w_tcds(),
expectation_of_successful_execution_2(
symbol_references=asrt.is_empty_sequence,
output_lines=[],
may_depend_on_external_resources=False,
is_identity_transformer=False,
adv=freeze_check.
first_invoked_method_of_source_model__is_freeze,
))
def runTest(self):
# ARRANGE #
py_file = File('stdin-to-upper.py',
_PGM_THAT_OUTPUTS_STDIN_IN_UPPER_CASE)
py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP)
py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name)
program_symbol = ProgramSymbolContext.of_sdv(
'PROGRAM_THAT_EXECUTES_PY_FILE',
program_sdvs.interpret_py_source_file_that_must_exist(py_file_conf.path_sdv)
)
input_model_lines = [
'the\n',
'input\n',
'model',
]
expected_output_model_lines = list(map(str.upper, input_model_lines))
for with_ignored_exit_code in [False, True]:
with self.subTest(with_ignored_exit_code=with_ignored_exit_code):
# ACT && ASSERT #
integration_check.CHECKER__PARSE_FULL.check__w_source_variants_for_full_line_parser(
self,
args.syntax_for_run(
program_args.symbol_ref_command_elements(program_symbol.name),
ignore_exit_code=with_ignored_exit_code,
),
model_constructor.of_lines(self, input_model_lines),
arrangement_w_tcds(
tcds_contents=py_file_rel_opt_conf.populator_for_relativity_option_root(
DirContents([py_file])
),
symbols=program_symbol.symbol_table,
),
MultiSourceExpectation(
symbol_references=program_symbol.references_assertion,
execution=ExecutionExpectation(
main_result=asrt_string_source.pre_post_freeze__matches_lines(
asrt.equals(expected_output_model_lines),
may_depend_on_external_resources=asrt.equals(True),
frozen_may_depend_on_external_resources=asrt.anything_goes(),
)
),
primitive=prim_asrt__constant(
asrt_string_transformer.is_identity_transformer(False)
),
),
)
def runTest(self):
# ARRANGE #
symbol_1 = NameAndValue('symbol_1_name', 'added by 1st transformer')
symbol_2 = NameAndValue('symbol_2_name', 'added by 2nd transformer')
symbol_3 = NameAndValue('symbol_3_name', 'added by 3rd transformer')
cases = [
NameAndValue('2 transformers', [
symbol_1,
symbol_2,
]),
NameAndValue('3 transformers', [
symbol_1,
symbol_2,
symbol_3,
]),
]
for case in cases:
sequenced_transformer_symbols = case.value
arguments = st_args.syntax_for_sequence_of_transformers(
[symbol.name for symbol in sequenced_transformer_symbols])
initial_line = 'initial line\n'
initial_model_lines = [initial_line]
expected_output_lines = [initial_line] + [
symbol.value + '\n' for symbol in sequenced_transformer_symbols
]
symbol_contexts = [
StringTransformerSymbolContext.of_primitive(
symbol.name, string_transformers.add_line(symbol.value))
for symbol in sequenced_transformer_symbols
]
# ACT & ASSERT #
with self.subTest(case.name):
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self, Arguments(arguments),
model_constructor.of_lines(self, initial_model_lines),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
symbol_contexts)),
expectation_of_successful_execution_2(
output_lines=expected_output_lines,
symbol_references=SymbolContext.
references_assertion_of_contexts(symbol_contexts),
may_depend_on_external_resources=False,
is_identity_transformer=False,
))
def _check(
self,
pattern: str,
replacement_str: str,
lines_selector: LineMatcherSymbolContext,
input_lines__wo_nl: List[str],
output_lines__wo_nl: List[str],
):
# ARRANGE #
input_lines = with_appended_new_lines(input_lines__wo_nl)
output_lines = with_appended_new_lines(output_lines__wo_nl)
pattern_symbol = StringConstantSymbolContext(
'PATTERN_SYMBOL',
pattern,
default_restrictions=asrt_regex.is_reference_restrictions__regex(),
)
replacement_symbol = StringConstantSymbolContext(
'REPLACEMENT_SYMBOL',
replacement_str,
default_restrictions=asrt_ref_rest.is__w_str_rendering(),
)
all_symbol = [lines_selector, pattern_symbol, replacement_symbol]
for preserve_new_lines in [False, True]:
syntax = ReplaceRegexAbsStx(
pattern_symbol.abstract_syntax,
replacement_symbol.abstract_syntax,
preserve_new_lines=preserve_new_lines,
lines_filter=lines_selector.abstract_syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
syntax,
model_constructor.of_lines(self, input_lines),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbol), ),
expectation_of_successful_replace_execution__multi(
symbol_references=SymbolContext.
references_assertion_of_contexts(all_symbol),
output_lines=output_lines,
may_depend_on_external_resources=True,
),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
})
def _check(
put: unittest.TestCase,
input_lines: List[str],
expected_lines: List[str],
):
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
put, Arguments(args.strip_space()),
model_constructor.of_lines(put, input_lines), arrangement_w_tcds(),
expectation_of_successful_execution_2(
symbol_references=asrt.is_empty_sequence,
output_lines=expected_lines,
may_depend_on_external_resources=False,
is_identity_transformer=False,
adv=freeze_check.first_invoked_method_of_source_model__is_freeze,
))
def runTest(self):
successful_transformer = StringTransformerSymbolContext.of_identity(
'successful_transformer')
for case in validation_cases.failing_validation_cases(
'failing_transformer'):
failing_symbol_context = case.value.symbol_context
symbols = SymbolContext.symbol_table_of_contexts([
failing_symbol_context,
successful_transformer,
])
order_cases = [
NameAndValue(
'1st transformer fails',
[failing_symbol_context.name, successful_transformer.name
]),
NameAndValue(
'2nd transformer fails',
[successful_transformer.name, failing_symbol_context.name
]),
]
for order_case in order_cases:
arguments = st_args.syntax_for_sequence_of_transformers(
order_case.value)
expected_symbol_references = asrt.matches_sequence([
is_reference_to_string_transformer(symbol_name)
for symbol_name in order_case.value
])
with self.subTest(validation_case=case.name,
order_case=order_case.name):
integration_check.CHECKER__PARSE_FULL.check__w_source_variants(
self, Arguments(arguments),
model_constructor.of_lines(self, []),
arrangement_w_tcds(symbols=symbols),
Expectation(
ParseExpectation(
symbol_references=expected_symbol_references),
ExecutionExpectation(
validation=case.value.expectation, ),
prim_asrt__constant(
is_identity_transformer(False)),
))
def runTest(self):
input_lines = ['1st\n', '2nd\n', '3rd\n']
range_expr = '1+1'
evaluated_expr = 2
expected_output_lines = input_lines[:evaluated_expr]
arguments = single_line_arguments(range_expr)
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants_for_full_line_parser_2(
self, arguments.as_arguments,
model_constructor.of_lines(self,
input_lines,
may_depend_on_external_resources=False),
arrangement_w_tcds(),
integration_check.expectation_of_successful_execution_2(
symbol_references=asrt.is_empty_sequence,
output_lines=expected_output_lines,
may_depend_on_external_resources=False,
is_identity_transformer=False,
))
def _check_lines_for_constant_regex__equivalent_for_preserve_new_lines(
self,
lines_for: Callable[[str], List[str]],
source_cases: List[TransformationCase],
):
for line_filter_case in LINE_FILTER_CASES:
for preserve_new_lines in [False, True]:
for source_case in source_cases:
source = ReplaceRegexAbsStx.of_str(
source_case.regex,
source_case.replacement,
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
source,
model_constructor.of_lines(
self, lines_for(source_case.regex)),
arrangement_w_tcds(
symbols=line_filter_case.value.symbol_table, ),
MultiSourceExpectation(
symbol_references=line_filter_case.value.
references_assertion,
execution=ExecutionExpectation(
main_result=asrt_string_source.
pre_post_freeze__matches_lines__identical(
asrt.equals(
lines_for(source_case.replacement)),
may_depend_on_external_resources=asrt.
equals(line_filter_case.value.
may_depend_on_external_resources),
)),
adv=freeze_check.
first_invoked_method_of_source_model__is_freeze,
),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
'source': repr(source.as_str__default()),
'line_filter_case': line_filter_case.name,
})
def runTest(self):
# ARRANGE #
input_lines = ['1\n', '2\n', '3\n']
single_range_1_symbol = StringIntConstantSymbolContext(
'RANGE_SYMBOL_1',
1,
default_restrictions=IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS,
)
single_range_2_symbol = StringIntConstantSymbolContext(
'RANGE_SYMBOL_2',
3,
default_restrictions=IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS,
)
symbols = [single_range_1_symbol, single_range_2_symbol]
expected_output_lines = [
input_lines[single_range_1_symbol.int_value - 1],
input_lines[single_range_2_symbol.int_value - 1]
]
arguments = args.filter_line_nums__multi([
range_args.SingleLineRange(
single_range_1_symbol.name__sym_ref_syntax),
range_args.SingleLineRange(
single_range_2_symbol.name__sym_ref_syntax),
])
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants_for_full_line_parser_2(
self, arguments.as_arguments,
model_constructor.of_lines(self,
input_lines,
may_depend_on_external_resources=False),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(symbols), ),
integration_check.expectation_of_successful_execution_2(
symbol_references=SymbolContext.
references_assertion_of_contexts(symbols),
output_lines=expected_output_lines,
may_depend_on_external_resources=False,
is_identity_transformer=False,
))
def runTest(self):
# ARRANGE #
input_lines = ['1\n', '2\n', '3\n']
expected_output_lines = input_lines[:2]
range_expr = StringSymbolContext.of_constant(
'RANGE_SYMBOL',
'2',
default_restrictions=IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS,
)
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants_for_full_line_parser_2(
self,
single_line_arguments(
range_expr.name__sym_ref_syntax).as_arguments,
model_constructor.of_lines(self,
input_lines,
may_depend_on_external_resources=False),
arrangement_w_tcds(symbols=range_expr.symbol_table, ),
integration_check.expectation_of_successful_execution_2(
symbol_references=range_expr.references_assertion,
output_lines=expected_output_lines,
may_depend_on_external_resources=False,
is_identity_transformer=False,
))
def runTest(self):
# ARRANGE #
model = ['the line']
line_matcher__constant_false = LineMatcherSymbolContextOfPrimitiveConstant(
'MATCHER',
False,
)
after_bin_op = 'after bin op'
lm_argument = lm_args.And([
lm_args.SymbolReference(line_matcher__constant_false.name),
lm_args.Custom(after_bin_op),
])
arguments = st_args.syntax_for_filter_transformer(lm_argument.as_str)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check(
self,
source=remaining_source(arguments),
input_=model_constructor.of_lines(self, model),
arrangement=arrangement_w_tcds(
symbols=line_matcher__constant_false.symbol_table,
),
expectation=expectation_of_successful_execution(
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__constant_false.references_assertion,
output_lines=[],
may_depend_on_external_resources=True,
frozen_may_depend_on_external_resources=asrt.anything_goes(),
is_identity_transformer=False,
)
)
def test_other_scenarios(self):
cases = [
NameAndValue(
'trailing new lines should be removed from line matcher model, but not from transformer output',
(line_matcher_from_predicates(line_contents_predicate=lambda x: x == 'X'),
['X\n'],
['X\n'])
),
NameAndValue(
'line numbers should be paired with lines in order of iterator (1)',
(is_identical_to(1, 'i'),
with_appended_new_lines([
'i',
'ii',
]),
with_appended_new_lines(['i'])
)
),
NameAndValue(
'line numbers should be paired with lines in order of iterator (2)',
(is_identical_to(2, 'ii'),
with_appended_new_lines([
'i',
'ii',
]),
with_appended_new_lines(['ii'])
)
),
NameAndValue(
'line numbers should be propagated to line matcher',
(line_matcher_from_predicates(line_num_predicate=lambda x: x in {1, 3}),
with_appended_new_lines([
'i',
'ii',
'iii',
'iv',
]),
with_appended_new_lines([
'i',
'iii',
])
)
),
]
line_matcher_name = 'the_line_matcher_symbol_name'
line_matcher_arg = lm_args.SymbolReference(line_matcher_name)
arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg))
for case in cases:
matcher, input_lines, expected_output_lines = case.value
with self.subTest(case_name=case.name):
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants(
self,
Arguments(arguments),
model_constructor.of_lines(self, input_lines),
arrangement_w_tcds(
symbols=LineMatcherSymbolContext.of_primitive(
line_matcher_name,
matcher,
).symbol_table,
),
expectation_of_successful_filter_execution(
output_lines=expected_output_lines,
symbol_references=asrt.matches_singleton_sequence(
references.is_reference_to_line_matcher(line_matcher_name)
)
)
)
def model(self,
may_depend_on_external_resources: bool) -> ModelConstructor:
model_lines = ['{}\n'.format(n + 1) for n in range(10)]
return model_constructor.of_lines(self, model_lines,
may_depend_on_external_resources)
def test_insertion_of_new_line_into_a_line_SHOULD_split_that_line(self):
# ARRANGE #
input_lines = [
'P\n',
'---\n',
'aPbPc\n',
'---\n',
'P',
]
expected_lines = [
'\n',
'\n',
'---\n',
'a\n',
'b\n',
'c\n',
'---\n',
'\n',
]
replacement_string_cases = [
NameAndValue(
'literate new line',
'\n',
),
NameAndValue(
'new line escape sequence, as interpreted by Python replace',
r'\n',
),
]
for line_filter_case in LINE_FILTER_CASES:
for preserve_new_lines in [False, True]:
for case in replacement_string_cases:
with self.subTest(case.name,
preserve_new_lines=preserve_new_lines,
line_filtering=line_filter_case.name):
nl_string_symbol = StringConstantSymbolContext(
'NL',
case.value,
default_restrictions=asrt_regex.
is_reference_restrictions__regex(),
)
all_symbols = line_filter_case.value.symbols + [
nl_string_symbol
]
source = ReplaceRegexAbsStx(
StringLiteralAbsStx('P'),
nl_string_symbol.abstract_syntax,
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__abs_stx(
self, source,
model_constructor.of_lines(self, input_lines),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols)),
expectation_of_successful_replace_execution(
symbol_references=SymbolContext.
references_assertion_of_contexts(all_symbols),
may_depend_on_external_resources=line_filter_case
.value.may_depend_on_external_resources,
output_lines=expected_lines,
))
