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