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(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 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_file_path(self): relativity_test_cases = [ (RelOptionType.REL_HDS_CASE, True), (RelOptionType.REL_ACT, False), ] path_suffix_str = 'path-suffix-file.txt' path_suffix_test_cases = [ (path_part_sdvs.from_constant_str(path_suffix_str), ()), (path_part_sdvs.from_string( string_sdv_of_single_symbol_reference( 'path_suffix_symbol', reference_restrictions.is_any_type_w_str_rendering())), (StringConstantSymbolContext('path_suffix_symbol', path_suffix_str).entry, )), ] for rel_option, exists_pre_sds in relativity_test_cases: # ARRANGE # path_component_from_referenced_path = 'path-component-from-referenced-file-ref' referenced_sym = ConstantSuffixPathDdvSymbolContext( 'path_symbol', rel_option, path_component_from_referenced_path) for path_suffix, symbol_table_entries in path_suffix_test_cases: fr_sdv_to_check = sut.PathSdvRelSymbol( path_suffix, _symbol_reference_of_path_with_accepted( referenced_sym.name, rel_option)) symbol_table = referenced_sym.symbol_table symbol_table.add_all(symbol_table_entries) tcds = fake_tcds() expected_root_path = _root_path_of_option(rel_option, tcds) expected_path = expected_root_path / path_component_from_referenced_path / path_suffix_str expected_path_str = str(expected_path) environment = PathResolvingEnvironmentPreOrPostSds( tcds, symbol_table) with self.subTest(msg=str(rel_option)): # ACT # path_to_check = fr_sdv_to_check.resolve( environment.symbols) if exists_pre_sds: tested_path_msg = 'value_pre_sds' actual_path = path_to_check.value_pre_sds( environment.hds) else: tested_path_msg = 'value_post_sds' actual_path = path_to_check.value_post_sds( environment.sds) actual_path_pre_or_post_sds = path_to_check.value_of_any_dependency( environment.tcds) # ASSERT # self.assertEqual(expected_path_str, str(actual_path), tested_path_msg) self.assertEqual(expected_path_str, str(actual_path_pre_or_post_sds), 'value_of_any_dependency')
def runTest(self): # ARRANGE # text_printed_by_program = StringSymbolContext.of_constant('STRING_TO_PRINT_SYMBOL', 'hello world') dst_file_symbol = ConstantSuffixPathDdvSymbolContext( 'DST_FILE_SYMBOL', RelOptionType.REL_ACT, 'dst-file-name.txt', sut.REL_OPT_ARG_CONF.options.accepted_relativity_variants, ) to_upper_transformer = TO_UPPER_TRANSFORMER_SYMBOL transformed_program_output_contents_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx( ProcOutputFile.STDOUT, program_abs_stx.FullProgramAbsStx( program_abs_stx.ProgramOfPythonInterpreterAbsStx.of_execute_python_src_string( py_programs.single_line_pgm_that_prints_to( ProcOutputFile.STDOUT, text_printed_by_program.name__sym_ref_syntax ) ), transformation=to_upper_transformer.abstract_syntax, ) ) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file_symbol.abstract_syntax, transformed_program_output_contents_syntax ) symbols = SymbolContext.symbol_table_of_contexts([ dst_file_symbol, text_printed_by_program, to_upper_transformer, ]) # ACT & ASSERT # checker = integration_check.checker(False) checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( symbols=symbols, tcds=TcdsArrangement(), ), MultiSourceExpectation.phase_agnostic( main_result=IS_SUCCESS, symbol_usages=asrt.matches_sequence([ dst_file_symbol.reference_assertion__path_or_string, text_printed_by_program.reference_assertion__w_str_rendering, to_upper_transformer.reference_assertion, ]), ) )
def runTest(self): # ARRANGE # to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) src_file = fs.File('src-file.txt', 'contents of source file') src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) expected_contents = src_file.contents.upper() path_relativity_variants = PathRelativityVariants({src_file_rel_conf.relativity}, True) checker = integration_check.checker(RelOptionsConfiguration(path_relativity_variants, src_file_rel_conf.relativity)) src_file_symbol = ConstantSuffixPathDdvSymbolContext( 'SRC_FILE_SYMBOL', src_file_rel_conf.relativity, src_file.name, path_relativity_variants, ) string_source_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx(src_file_symbol.abstract_syntax), to_upper_transformer.abstract_syntax, ) symbol_table = SymbolContext.symbol_table_of_contexts([ src_file_symbol, to_upper_transformer, ]) # ACT & ASSERT # checker.check__abs_stx__layouts__std_source_variants__wo_input( self, OptionallyOnNewLine(string_source_syntax), arrangement_w_tcds( symbols=symbol_table, hds_contents=src_file_rel_conf.populator_for_relativity_option_root__hds( DirContents([src_file])) ), MultiSourceExpectation.of_prim__const( asrt_string_source.pre_post_freeze__matches_str__const( expected_contents, may_depend_on_external_resources=True, ), symbol_references=asrt.matches_sequence([ src_file_symbol.reference_assertion__path_or_string, to_upper_transformer.reference_assertion, ]), ), )
def _test_symbol_reference_in_dst_file_and_contents( self, symbol_ref_syntax_2_contents_arguments: Callable[ [str], StringSourceAbsStx], symbol_value_2_expected_contents: Callable[[str], str]): sub_dir_symbol = ConstantSuffixPathDdvSymbolContext( 'sub_dir_symbol', RelOptionType.REL_ACT, 'sub-dir', ACCEPTED_DST_RELATIVITY_VARIANTS, ) contents_symbol = StringConstantSymbolContext( 'contents_symbol_name', 'contents symbol value', default_restrictions=asrt_rest.is__w_str_rendering(), ) expected_file_contents = symbol_value_2_expected_contents( contents_symbol.str_value) expected_file = fs.File('a-file-name.txt', expected_file_contents) symbols = [sub_dir_symbol, contents_symbol] expected_symbol_references = SymbolContext.references_assertion_of_contexts( symbols) symbol_table = SymbolContext.symbol_table_of_contexts(symbols) contents_arguments = symbol_ref_syntax_2_contents_arguments( symbol_reference_syntax_for_name(contents_symbol.name)) instruction_syntax = instr_abs_stx.create_w_explicit_contents( path_abs_stx.PathStringAbsStx.of_plain_components( [sub_dir_symbol.name__sym_ref_syntax, expected_file.name]), contents_arguments, ) integration_check.CHECKER__AFTER_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=symbol_table, ), Expectation.phase_agnostic( main_result=IS_SUCCESS, symbol_usages=expected_symbol_references, main_side_effects_on_sds=dir_contains_exactly( sub_dir_symbol.rel_option_type, fs.DirContents( [fs.Dir(sub_dir_symbol.path_suffix, [expected_file])])), ))
def test_resolve_of_path_symbol_SHOULD_give_string_constant(self): # ARRANGE # symbol = ConstantSuffixPathDdvSymbolContext('the_symbol_name', RelOptionType.REL_ACT, 'file-name') fragment = impl.SymbolStringFragmentSdv( symbol.reference__w_str_rendering) symbol_table = symbol.symbol_table # ACT # actual = fragment.resolve(symbol_table) # ASSERT # self.assertIsInstance(actual, csv.PathFragmentDdv) assertion = equals_string_fragment_ddv(csv.PathFragmentDdv(symbol.ddv)) assertion.apply_without_message(self, actual)
def test_exists_pre_sds(self): # ARRANGE # relativity_test_cases = [ ( RelOptionType.REL_HDS_CASE, True, ), ( RelOptionType.REL_TMP, False, ), ] path_suffix_test_cases = [ (path_part_sdvs.from_constant_str('file.txt'), []), ( path_part_sdvs.from_string( string_sdv_of_single_symbol_reference( 'path_suffix_symbol_name', reference_restrictions.is_any_type_w_str_rendering()), ), [ StringConstantSymbolContext('path_suffix_symbol_name', 'path-suffix').entry ], ), ] for rel_option_type_of_referenced_symbol, expected_exists_pre_sds in relativity_test_cases: referenced_path = ConstantSuffixPathDdvSymbolContext( 'SYMBOL_NAME', rel_option_type_of_referenced_symbol, 'referenced-file-name') for path_suffix, sym_tbl_entries in path_suffix_test_cases: symbol_table = referenced_path.symbol_table symbol_table.add_all(sym_tbl_entries) with self.subTest( msg='rel_option_type={} ,path_suffix_type={}'.format( rel_option_type_of_referenced_symbol, path_suffix)): path_sdv_to_check = sut.PathSdvRelSymbol( path_suffix, _symbol_reference_of_path_with_accepted( referenced_path.name, rel_option_type_of_referenced_symbol)) # ACT # actual = path_sdv_to_check.resolve( symbol_table).exists_pre_sds() # ASSERT # self.assertEqual(expected_exists_pre_sds, actual, 'existence pre SDS')
def runTest(self): sub_dir_of_home = 'sub-dir' dir_symbol = ConstantSuffixPathDdvSymbolContext('dir_symbol_name', RelOptionType.REL_HDS_ACT, sub_dir_of_home, PATH_RELATIVITY_VARIANTS_FOR_FILE_TO_RUN) source_file_name_symbol = StringConstantSymbolContext('source_file_name_symbol_name', 'the-source-file.py') argument = 'argument_string' expected_output = lines_content([argument]) command_line = '{dir}/{file_name} {argument} '.format( dir=dir_symbol.name__sym_ref_syntax, file_name=source_file_name_symbol.name__sym_ref_syntax, argument=argument, ) executable_file = fs.File( source_file_name_symbol.str_value, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES) arrangement = arrangement_w_tcds( hds_contents=contents_in(RelHdsOptionType.REL_HDS_ACT, fs.DirContents([ fs.Dir(sub_dir_of_home, [executable_file]) ])), symbol_table=SymbolContext.symbol_table_of_contexts([ dir_symbol, source_file_name_symbol, ]) ) expectation = Expectation( symbol_usages=asrt.matches_sequence([ dir_symbol.reference_assertion__path_or_string, source_file_name_symbol.reference_assertion__path_component, ]), execute=eh_assertions.is_exit_code(0), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=pr.stdout(asrt.Equals(expected_output, 'CLI arguments, one per line')) ), ) self._check(command_line, arrangement, expectation)
def test_multiple_symbol_references_in_executable(self): sub_dir_of_home = 'sub-dir' dir_symbol = ConstantSuffixPathDdvSymbolContext( 'dir_symbol_name', RelOptionType.REL_HDS_ACT, sub_dir_of_home, PATH_RELATIVITY_VARIANTS_FOR_FILE_TO_RUN) executable_file_name_symbol = StringConstantSymbolContext( 'executable_file_name_symbol_name', 'the-executable-file') argument = 'argument_string' expected_output = lines_content([argument]) command_line = '{dir}/{file_name} {argument} '.format( dir=dir_symbol.name__sym_ref_syntax, file_name=executable_file_name_symbol.name__sym_ref_syntax, argument=argument, ) executable_file = fs.python_executable_file( executable_file_name_symbol.str_value, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) arrangement = arrangement_w_tcds( hds_contents=relativity_configurations.ATC_FILE. populator_for_relativity_option_root__hds( fs.DirContents([fs.Dir(sub_dir_of_home, [executable_file])])), symbol_table=SymbolContext.symbol_table_of_contexts([ dir_symbol, executable_file_name_symbol, ])) expectation = Expectation( symbol_usages=asrt.matches_sequence([ dir_symbol.reference_assertion__path_or_string, executable_file_name_symbol. reference_assertion__string__w_all_indirect_refs_are_strings, ]), execute=eh_assertions.is_exit_code(0), post_sds=PostSdsExpectation. constant(sub_process_result_from_execute=pr.stdout( asrt.Equals(expected_output, 'CLI arguments, one per line'))), ) check_execution(self, sut.actor(), [instr([command_line])], arrangement, expectation)
def test(self): file_symbol = ConstantSuffixPathDdvSymbolContext( 'file_symbol', RelOptionType.REL_TMP, 'first_path_component') string_symbol = StringConstantSymbolContext('string_symbol', 'string symbol value') reference_of_relativity_symbol = SymbolReference( file_symbol.name, path_relativity_restriction( syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options. accepted_relativity_variants)) reference_of_path_string_symbol_as_path_component = SymbolReference( string_symbol.name, ReferenceRestrictionsOnDirectAndIndirect( direct=value_restrictions.is_string(), indirect=value_restrictions.is_string()), ) symbols = SymbolContext.symbol_table_of_contexts([ file_symbol, string_symbol, ]) cases = [ Case.of( 'symbol references in file', RelSymbolPathAbsStx(file_symbol.name, string_symbol.name__sym_ref_syntax), arguments=(), expectation=ExpectationOnExeFile( path_ddv=path_ddvs.stacked( file_symbol.ddv, path_ddvs.constant_path_part(string_symbol.str_value)), expected_symbol_references=[ reference_of_relativity_symbol, reference_of_path_string_symbol_as_path_component ], symbol_for_value_checks=symbols, ), source_after_parse=asrt_source.is_at_end_of_line(1), ), ] for case in cases: with self.subTest(name=case.name): _parse_and_check(self, case)
def runTest(self): symbol = ConstantSuffixPathDdvSymbolContext('symbol_name', RelOptionType.REL_ACT, 'the-path-suffix') program_that_prints_value_of_symbol = 'print("{symbol}")' single_source_line = program_that_prints_value_of_symbol.format( symbol=symbol.name__sym_ref_syntax, ) self._check( single_source_line, 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=asrt_pr.stdout( str_asrt.contains(symbol.path_suffix))), ))
def test(self): expected_defined_symbol = ConstantSuffixPathDdvSymbolContext( 'name', type_parser.REL_OPTIONS_CONFIGURATION.default_option, 'component') instruction_argument = src2(ValueType.PATH, expected_defined_symbol.name, 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( 'name', expected_defined_symbol.value. assert_matches_container_of_sdv)))
def _path_case(contents_transformation: Callable[[str], str]) -> Case: relativity = RelOptionType.REL_TMP path_suffix = 'the path suffix' def get_assertion_on_primitive( env: AssertionResolvingEnvironment) -> Assertion[StringSource]: path_as_str = str(env.tcds.sds.user_tmp_dir / path_suffix) return asrt_string_source.pre_post_freeze__matches_str__const( contents_transformation(path_as_str), may_depend_on_external_resources=False) symbol_context = ConstantSuffixPathDdvSymbolContext( 'PATH_SYMBOL', relativity, path_suffix, ARBITRARY_FILE_RELATIVITIES.accepted_relativity_variants, ) return Case( StringSourceOfStringAbsStx.of_plain( StringLiteralAbsStx(symbol_context.name__sym_ref_syntax, QuoteType.SOFT)), symbol_context, get_assertion_on_primitive, )
def test_resolve(self): string_constant_1 = 'string constant 1' string_constant_2 = 'string constant 2' string_symbol = StringConstantSymbolContext('string_symbol_name', 'string symbol value') path_symbol = ConstantSuffixPathDdvSymbolContext( 'path_symbol_name', RelOptionType.REL_ACT, 'file-name') list_symbol = ListConstantSymbolContext( 'list_symbol_name', ['list element 1', 'list element 2']) cases = [ ( 'no fragments', sut.StringSdv(()), empty_symbol_table(), csv.StringDdv(()), ), ( 'single string constant fragment', sut.StringSdv( (impl.ConstantStringFragmentSdv(string_constant_1), )), empty_symbol_table(), csv.StringDdv((csv.ConstantFragmentDdv(string_constant_1), )), ), ( 'multiple single string constant fragments', sut.StringSdv( (impl.ConstantStringFragmentSdv(string_constant_1), impl.ConstantStringFragmentSdv(string_constant_2))), empty_symbol_table(), csv.StringDdv((csv.ConstantFragmentDdv(string_constant_1), csv.ConstantFragmentDdv(string_constant_2))), ), ( 'single symbol fragment/symbol is a string', sut.StringSdv((impl.SymbolStringFragmentSdv( string_symbol.reference__w_str_rendering), )), string_symbol.symbol_table, csv.StringDdv( (csv.ConstantFragmentDdv(string_symbol.str_value), )), ), ( 'single symbol fragment/symbol is a path', sut.StringSdv((impl.SymbolStringFragmentSdv( path_symbol.reference__w_str_rendering), )), path_symbol.symbol_table, csv.StringDdv((csv.PathFragmentDdv(path_symbol.ddv), )), ), ( 'single symbol fragment/symbol is a list', sut.StringSdv((impl.SymbolStringFragmentSdv( list_symbol.reference__w_str_rendering), )), list_symbol.symbol_table, csv.StringDdv((csv.ListFragmentDdv(list_symbol.ddv), )), ), ( 'multiple fragments of different types', sut.StringSdv(( impl.SymbolStringFragmentSdv( string_symbol.reference__w_str_rendering), impl.ConstantStringFragmentSdv(string_constant_1), impl.SymbolStringFragmentSdv( path_symbol.reference__w_str_rendering), impl.SymbolStringFragmentSdv( list_symbol.reference__w_str_rendering), )), SymbolContext.symbol_table_of_contexts([ string_symbol, path_symbol, list_symbol, ]), csv.StringDdv(( csv.ConstantFragmentDdv(string_symbol.str_value), csv.ConstantFragmentDdv(string_constant_1), csv.PathFragmentDdv(path_symbol.ddv), csv.ListFragmentDdv(list_symbol.ddv), )), ), ] for test_name, string_value, symbol_table, expected in cases: with self.subTest(test_name=test_name): actual = string_value.resolve(symbol_table) assertion = equals_string_ddv(expected) assertion.apply_without_message(self, actual)
def test_symbol_usages(self): # ARRANGE # to_upper_transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) src_file = fs.File('src-file.txt', 'contents of source file') src_file_rel_conf = conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) expected_dst_file = fs.File('dst-file-name.txt', src_file.contents.upper()) dst_file_symbol = ConstantSuffixPathDdvSymbolContext( 'DST_FILE_SYMBOL', RelOptionType.REL_TMP, expected_dst_file.name, sut.REL_OPT_ARG_CONF.options.accepted_relativity_variants, ) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) src_file_rel_opt_conf = src_rel_opt_arg_conf_for_phase( phase_is_after_act) src_file_symbol = ConstantSuffixPathDdvSymbolContext( 'SRC_FILE_SYMBOL', src_file_rel_conf.relativity_option, src_file.name, src_file_rel_opt_conf.options.accepted_relativity_variants, ) transformed_file_contents = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_symbol.abstract_syntax), StringTransformerSymbolReferenceAbsStx( to_upper_transformer.name)) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file_symbol.abstract_syntax, transformed_file_contents, ) symbols = SymbolContext.symbol_table_of_contexts([ dst_file_symbol, src_file_symbol, to_upper_transformer, ]) with self.subTest(phase_is_after_act=phase_is_after_act): # ACT & ASSERT # checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( symbols=symbols, tcds=TcdsArrangement( hds_contents=src_file_rel_conf. populator_for_relativity_option_root__hds( DirContents([src_file]))), ), MultiSourceExpectation.phase_agnostic( main_result=IS_SUCCESS, symbol_usages=asrt.matches_sequence([ dst_file_symbol. reference_assertion__path_or_string, src_file_symbol. reference_assertion__path_or_string, is_reference_to_string_transformer__usage( to_upper_transformer.name), ]), ), )