def argument_cases(self) -> List[str]:
return [
syntax.as_str__default() for syntax in [
ReplaceRegexAbsStx.of_str('regex', 'replacement', False, None),
ReplaceRegexAbsStx.of_str('regex', 'replacement', True, None),
]
]
def runTest(self):
# ARRANGE #
for validation_case in validation_cases.failing_validation_cases():
for preserve_new_lines in [False, True]:
syntax = ReplaceRegexAbsStx.of_str(
'valid_regex',
'valid_replacement',
preserve_new_lines=preserve_new_lines,
lines_filter=validation_case.value.matcher_abs_stx,
)
line_matcher_symbol_context = validation_case.value.symbol_context
# ACT & ASSERT #
integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants(
self,
syntax,
model_constructor.arbitrary(self),
arrangement_wo_tcds(
symbols=line_matcher_symbol_context.symbol_table),
MultiSourceExpectation(
symbol_references=line_matcher_symbol_context.
references_assertion,
execution=ExecutionExpectation(
validation=validation_case.value.expectation, )),
sub_test_identifiers={
'preserve_new_lines': preserve_new_lines,
'validation': validation_case.name,
})
def runTest(self):
for line_filter_case in LINE_FILTER_CASES:
for preserve_new_lines in [False, True]:
for regex_case in failing_regex_validation_cases():
all_symbols = line_filter_case.value.symbols + regex_case.symbols
source = ReplaceRegexAbsStx.of_str(
regex_case.regex_string,
'arbitrary_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.arbitrary(self),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols)),
MultiSourceExpectation(
symbol_references=line_filter_case.value.
references_assertion__followed_by(
regex_case.reference_assertions),
execution=ExecutionExpectation(
validation=regex_case.expectation),
primitive=prim_asrt__constant(
is_identity_transformer(False)),
),
sub_test_identifiers={
'regex_case': regex_case.case_name,
'preserve_new_lines': preserve_new_lines,
'lines_filtering': line_filter_case.name,
})
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 runTest(self):
line_filter_cases = [
NameAndValue('wo line filter', None),
NameAndValue('w line filter',
LineMatcherSymbolReferenceAbsStx('LM_SYMBOL')),
]
for line_filter_case in line_filter_cases:
for preserve_new_lines in [False, True]:
cases = [
NameAndValue(
'missing regex',
ReplaceRegexAbsStx.of_str(
'',
'replacement',
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value,
),
),
NameAndValue(
'missing replacement',
ReplaceRegexAbsStx.of_str(
'regex',
'',
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value,
),
),
NameAndValue(
'missing regex and replacement',
ReplaceRegexAbsStx.of_str(
'',
'',
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.value,
),
),
]
for case in cases:
with self.subTest(case.name,
preserve_new_lines=preserve_new_lines,
lines_filter=line_filter_case.name):
integration_check.PARSE_CHECKER__FULL.check_invalid_syntax__abs_stx(
self,
case.value,
)
def test_removal_of_new_lines_SHOULD_join_lines(self):
# ARRANGE #
cases = [
NIE('final line not ended by new-line',
input_value=[
'1\n',
'2\n',
'3',
],
expected_value=[
'123',
]),
NIE('final line ended by new-line',
input_value=[
'1\n',
'2\n',
'3\n',
],
expected_value=[
'123',
]),
]
for line_filter_case in LINE_FILTER_CASES:
for case in cases:
with self.subTest(model=case.name,
line_filtering=line_filter_case.name):
nl_string_symbol = StringConstantSymbolContext(
'NL',
'\n',
default_restrictions=asrt_regex.
is_reference_restrictions__regex(),
)
all_symbols = line_filter_case.value.symbols + [
nl_string_symbol
]
source = ReplaceRegexAbsStx(
nl_string_symbol.abstract_syntax,
StringLiteralAbsStx.empty_string(),
preserve_new_lines=False,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__abs_stx(
self, source,
model_constructor.of_lines(self, case.input_value),
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=case.expected_value,
))
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_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 "
lm_op_1 = LineMatcherSymbolReferenceAbsStx('LM_1')
lm_op_2 = LineMatcherSymbolReferenceAbsStx('LM_2')
line_matcher_w_infix_op = LineMatcherInfixOpAbsStx.conjunction([
lm_op_1,
lm_op_2,
])
valid_regex = 'valid_regex'
syntax = ReplaceRegexAbsStx.of_str(
valid_regex,
'valid_replacement',
preserve_new_lines=False,
lines_filter=line_matcher_w_infix_op,
)
# ACT #
integration_check.PARSE_CHECKER__FULL.check_invalid_syntax__abs_stx(
self,
syntax,
)
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,
))