def runTest(self): to_upper_transformer = NameAndValue( 'TRANSFORMER_SYMBOL', StringTransformerSdvConstantTestImpl(to_uppercase())) src_file = fs.File('src-file.txt', 'contents of source file') src_file_symbol = NameAndValue('SRC_FILE_SYMBOL', src_file.name) expected_dst_file = fs.File('dst-file-name.txt', src_file.contents.upper()) dst_file_symbol = NameAndValue('DST_FILE_SYMBOL', expected_dst_file.name) transformed_file_syntax = string_source_abs_stx.TransformedStringSourceAbsStx( string_source_abs_stx.StringSourceOfFileAbsStx( PathSymbolReferenceAbsStx(src_file_symbol.name)), str_trans_abs_stx.StringTransformerSymbolReferenceAbsStx( to_upper_transformer.name)) instruction_syntax = instr_abs_stx.create_w_explicit_contents( PathSymbolReferenceAbsStx(dst_file_symbol.name), transformed_file_syntax, ) # ACT # for layout_case in tokens_layout.STANDARD_LAYOUT_SPECS: with self.subTest(layout_case.name): instruction = self.conf.parse_checker.parse__abs_stx( self, instruction_syntax, layout_case.value) assert isinstance( instruction, TestCaseInstructionWithSymbols) # Sanity check # ASSERT # expected_symbol_usages = [ asrt_sym_ref.matches_reference_2( dst_file_symbol.name, asrt_w_str_rend_rest.equals__w_str_rendering( path_or_string_reference_restrictions( new_file.REL_OPT_ARG_CONF.options. accepted_relativity_variants))), asrt_sym_ref.matches_reference_2( src_file_symbol.name, asrt_w_str_rend_rest.equals__w_str_rendering( path_or_string_reference_restrictions( src_rel_opt_arg_conf_for_phase( self.conf.phase_is_after_act()).options. accepted_relativity_variants))), is_reference_to_string_transformer__usage( to_upper_transformer.name), ] expected_symbol_references = asrt.matches_sequence( expected_symbol_usages) expected_symbol_references.apply_without_message( self, instruction.symbol_usages())
def expected_symbols(self) -> Sequence[Assertion[SymbolReference]]: return [ asrt_sym_ref.matches_reference_2( self.min_depth.name, asrt_data_rest.equals__w_str_rendering( reference_restrictions. is_string__all_indirect_refs_are_strings())), asrt_sym_ref.matches_reference_2( self.max_depth.name, asrt_data_rest.equals__w_str_rendering( reference_restrictions. is_string__all_indirect_refs_are_strings())), self._helper.files_matcher_sym_assertion(), ]
def test_string_token(self): # ARRANGE # plain_string = 'plain' symbol_name = 'symbol_name' cases = [ Case('plain string', plain_string, Expectation( elements=[list_resolvers.str_element(plain_string)], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case('symbol reference', symbol_reference_syntax_for_name(symbol_name), Expectation( elements=[list_resolvers.symbol_element(symbol_reference(symbol_name))], validators=asrt.is_empty_sequence, references=asrt.matches_sequence([asrt_sym_ref.matches_reference_2( symbol_name, is_any_data_type_reference_restrictions()) ]), )), ] # ACT & ASSERT # _test_cases(self, cases)
def test_symbol_usages_of_object_returned_by_parser_SHOULD_be_reported( self): # ARRANGE # symbol_reference = NameAndValue( 'symbol_name', reference_restrictions.is_any_type_w_str_rendering()) expected_symbol_references = [ SymbolReference(symbol_reference.name, symbol_reference.value) ] actor = sut.ActorFromParts( ParserWithConstantResult( SymbolUserWithConstantSymbolReferences( expected_symbol_references)), sut.UnconditionallySuccessfulValidatorConstructor(), _ExecutorConstructorForConstant( UnconditionallySuccessfulExecutor()), ) # ACT & ASSERT # check_execution( self, actor, [], arrangement_w_tcds(), Expectation(symbol_usages=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( symbol_reference.name, data_restrictions_assertions.equals__w_str_rendering( symbol_reference.value)) ])))
def equals_symbol_reference_with_restriction_on_direct_target(expected_name: str, assertion_on_direct_restriction: ValueAssertion ) -> ValueAssertion[su.SymbolReference]: return asrt_sym_ref.matches_reference_2(expected_name, matches_restrictions_on_direct_and_indirect( assertion_on_direct=assertion_on_direct_restriction, assertion_on_every=asrt.ValueIsNone()))
def test(self): # ARRANGE # plain_string1 = 'plain_1' plain_string2 = 'plain_2' symbol_name_1 = 'symbol_name_1' symbol_name_2 = 'symbol_name_2' remaining_part_of_current_line_with_sym_ref = ''.join(['before', symbol_reference_syntax_for_name(symbol_name_2), 'after']) cases = [ Case('plain strings', ab.sequence([plain_string1, plain_string2]).as_str, Expectation( elements=[list_resolvers.str_element(plain_string1), list_resolvers.str_element(plain_string2)], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case('symbol reference + plain string + until-end-of-line', ab.sequence([ab.symbol_reference(symbol_name_1), plain_string1, syntax_elements.REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER, remaining_part_of_current_line_with_sym_ref, ]).as_str, Expectation( elements=[list_resolvers.symbol_element(symbol_reference(symbol_name_1)), list_resolvers.str_element(plain_string1), list_resolvers.string_element(string_resolvers.from_fragments([ string_resolvers.str_fragment('before'), string_resolvers.symbol_fragment(symbol_reference(symbol_name_2)), string_resolvers.str_fragment('after'), ])) ], validators=asrt.is_empty_sequence, references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2(symbol_name_1, is_any_data_type_reference_restrictions()), asrt_sym_ref.matches_reference_2(symbol_name_2, is_any_data_type_reference_restrictions()), ]), )), ] # ACT & ASSERT # _test_cases(self, cases)
def is_reference_to__path_or_string(symbol_name: str, accepted_relativities: PathRelativityVariants, ) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_ref_restriction.equals__w_str_rendering( path_or_string_reference_restrictions(accepted_relativities)) )
def matches_symbol_reference_with_restriction_on_direct_target( expected_name: str, assertion_on_direct_restriction: Assertion[ValueRestriction] ) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2(expected_name, asrt_w_str_rend_rest.matches__on_direct_and_indirect( assertion_on_direct=assertion_on_direct_restriction, assertion_on_indirect=asrt.ValueIsNone()))
def equals_data_type_symbol_reference(expected: SymbolReference) -> Assertion[SymbolReference]: restrictions = expected.restrictions if not isinstance(restrictions, WithStrRenderingTypeRestrictions): raise ValueError('Restrictions must be {}. Found {}'.format( WithStrRenderingTypeRestrictions, restrictions, )) return asrt_sym_ref.matches_reference_2(expected.name, asrt_w_str_rend_rest.equals__w_str_rendering(restrictions))
def equals_list_sdv_element(expected: list_sdv.ElementSdv, symbols: SymbolTable = None) -> Assertion[list_sdv.ElementSdv]: if symbols is None: symbols = symbol_table_with_values_matching_references(list(expected.references)) expected_resolved_value_list = expected.resolve(symbols) assertion_on_resolved_value = asrt.matches_sequence( [equals_string_ddv(sv) for sv in expected_resolved_value_list]) component_assertions = [ asrt.sub_component('references', lambda x: list(x.references), equals_symbol_references__w_str_rendering(list(expected.references))), asrt.sub_component('resolved value', lambda x: x.resolve(symbols), assertion_on_resolved_value), ] symbol_reference_assertion = asrt.is_none reference = expected.symbol_reference_if_is_symbol_reference if reference is not None: reference_restrictions = reference.restrictions if not isinstance(reference_restrictions, WithStrRenderingTypeRestrictions): raise ValueError('A list element must reference a data type value') assert isinstance(reference_restrictions, WithStrRenderingTypeRestrictions) # Type info for IDE symbol_reference_assertion = equals_data_type_symbol_reference(reference) asrt_sym_ref.matches_reference_2( reference.name, data_restrictions_assertions.equals__w_str_rendering( reference_restrictions) ) symbol_reference_component_assertion = asrt.sub_component('symbol_reference_if_is_symbol_reference', lambda x: x.symbol_reference_if_is_symbol_reference, symbol_reference_assertion) component_assertions.append(symbol_reference_component_assertion) return asrt.is_instance_with( list_sdv.ElementSdv, asrt.and_(component_assertions))
def test_remaining_part_of_current_line_as_literal(self): # ARRANGE # symbol_name = 'symbol_name' str_with_space_and_invalid_token_syntax = 'before and after space, ' + SOFT_QUOTE_CHAR + 'after quote' cases = [ Case('string with one space after marker, and no space at EOL', ' '.join([ syntax_elements.REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER, str_with_space_and_invalid_token_syntax]), Expectation( elements=[list_resolvers.str_element(str_with_space_and_invalid_token_syntax)], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case('with surrounding space', ' '.join([ syntax_elements.REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER, ' ' + str_with_space_and_invalid_token_syntax + ' \t ']), Expectation( elements=[list_resolvers.str_element(str_with_space_and_invalid_token_syntax)], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case('with symbol reference', ' '.join([ syntax_elements.REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER, ''.join(['before', symbol_reference_syntax_for_name(symbol_name), 'after'])]), Expectation( elements=[list_resolvers.string_element(string_resolvers.from_fragments([ string_resolvers.str_fragment('before'), string_resolvers.symbol_fragment(symbol_reference(symbol_name)), string_resolvers.str_fragment('after'), ])) ], validators=asrt.is_empty_sequence, references=asrt.matches_sequence([asrt_sym_ref.matches_reference_2( symbol_name, is_any_data_type_reference_restrictions()) ]), )), ] # ACT & ASSERT # _test_cases(self, cases)
def is_reference_to__w_str_rendering(symbol_name: str ) -> Assertion[SymbolReference]: return matches_reference_2( symbol_name, asrt_data_ref_restriction.is__w_str_rendering(), )
def is_reference_to__string(symbol_name: str) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, IS_STRING_REFERENCE_RESTRICTION, )
def test(self): # ARRANGE # plain_string1 = 'plain_1' plain_string2 = 'plain_2' symbol_name_1 = 'symbol_name_1' symbol_name_2 = 'symbol_name_2' remaining_part_of_current_line_with_sym_ref = ''.join([ 'before', symbol_reference_syntax_for_name(symbol_name_2), 'after' ]) cases = [ Case.of_multi( 'plain strings', [ ArgumentOfRichStringAbsStx.of_str(plain_string1), ArgumentOfRichStringAbsStx.of_str(plain_string2) ], ARRANGEMENT__NEUTRAL, Expectation( elements=[ list_sdvs.str_element(plain_string1), list_sdvs.str_element(plain_string2) ], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case.of_multi( 'plain strings on several lines (separated by continuation token)', [ ArgumentOfRichStringAbsStx.of_str(plain_string1), ContinuationTokenFollowedByArgumentAbsStx( ArgumentOfRichStringAbsStx.of_str(plain_string2)), ], ARRANGEMENT__NEUTRAL, Expectation( elements=[ list_sdvs.str_element(plain_string1), list_sdvs.str_element(plain_string2) ], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case.of_multi( 'plain strings on several lines (separated by continuation token) / first line empty', [ ContinuationTokenFollowedByArgumentAbsStx( ArgumentOfRichStringAbsStx.of_str(plain_string1)), ArgumentOfRichStringAbsStx.of_str(plain_string2), ], ARRANGEMENT__NEUTRAL, Expectation( elements=[ list_sdvs.str_element(plain_string1), list_sdvs.str_element(plain_string2) ], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case.of_multi( 'symbol reference + plain string + until-end-of-line', [ ArgumentOfSymbolReferenceAbsStx(symbol_name_1), ArgumentOfRichStringAbsStx.of_str(plain_string1), ArgumentOfRichStringAbsStx.of_str_until_eol( remaining_part_of_current_line_with_sym_ref), ], Arrangement( SymbolContext.symbol_table_of_contexts([ StringSymbolContext.of_arbitrary_value(symbol_name_1), StringSymbolContext.of_arbitrary_value(symbol_name_2), ])), Expectation( elements=[ list_sdvs.symbol_element( reference_to__on_direct_and_indirect( symbol_name_1)), list_sdvs.str_element(plain_string1), list_sdvs.string_element( string_sdvs.from_fragments([ string_sdvs.str_fragment('before'), string_sdvs.symbol_fragment( reference_to__on_direct_and_indirect( symbol_name_2)), string_sdvs.str_fragment('after'), ])) ], validators=asrt.is_empty_sequence, references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( symbol_name_1, asrt_data_rest.is__w_str_rendering()), asrt_sym_ref.matches_reference_2( symbol_name_2, asrt_data_rest.is__w_str_rendering()), ]), )), ] # ACT & ASSERT # _test_cases_w_source_variants(self, cases)
def test_remaining_part_of_current_line_as_literal(self): # ARRANGE # symbol_name = 'symbol_name' str_with_space_and_invalid_token_syntax = 'before and after space, ' + SOFT_QUOTE_CHAR + 'after quote' cases = [ Case.of( 'string with one space after marker, and no space at EOL', ArgumentOfRichStringAbsStx.of_str_until_eol( str_with_space_and_invalid_token_syntax), ARRANGEMENT__NEUTRAL, Expectation( elements=[ list_sdvs.str_element( str_with_space_and_invalid_token_syntax) ], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case.of( 'with surrounding space', ArgumentOfRichStringAbsStx.of_str_until_eol( ' ' + str_with_space_and_invalid_token_syntax + ' \t '), ARRANGEMENT__NEUTRAL, Expectation( elements=[ list_sdvs.str_element( str_with_space_and_invalid_token_syntax) ], validators=asrt.is_empty_sequence, references=asrt.is_empty_sequence, )), Case.of( 'with symbol reference', ArgumentOfRichStringAbsStx.of_str_until_eol(''.join([ 'before', symbol_reference_syntax_for_name(symbol_name), 'after' ])), Arrangement( StringSymbolContext.of_arbitrary_value( symbol_name).symbol_table), Expectation( elements=[ list_sdvs.string_element( string_sdvs.from_fragments([ string_sdvs.str_fragment('before'), string_sdvs.symbol_fragment( reference_to__on_direct_and_indirect( symbol_name)), string_sdvs.str_fragment('after'), ])) ], validators=asrt.is_empty_sequence, references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_rest.is__w_str_rendering()) ]), )), ] # ACT & ASSERT # _test_cases_w_source_variants(self, cases)
def is_reference_to_string__w_all_indirect_refs_are_strings(symbol_name: str) -> Assertion[SymbolReference]: return matches_reference_2( symbol_name, asrt_data_ref_restriction.is__string__w_all_indirect_refs_are_strings() )
def symbol_usage_equals_symbol_reference(expected: SymbolReference) -> ValueAssertion[SymbolUsage]: return asrt.is_instance_with( SymbolUsage, asrt_sym_ref.matches_reference_2( expected.name, equals_data_type_reference_restrictions(expected.restrictions)))
def test(self): single_token_value = 'single_token_value' single_token_value_1 = 'single_token_value_1' single_token_value_2 = 'single_token_value_2' symbol_name = 'a_symbol_name' cases = [ Case( 'multiple string constants on line that is the last line', source=remaining_source(single_token_value_1 + ' ' + single_token_value_2), expectation=Expectation( elements=[ list_sdvs.str_element(single_token_value_1), list_sdvs.str_element(single_token_value_2) ], source=asrt_source.is_at_end_of_line(1)), ), Case( 'multiple string constants on line that is followed by an empty line', source=remaining_source( single_token_value_1 + ' ' + single_token_value_2, ['']), expectation=Expectation( elements=[ list_sdvs.str_element(single_token_value_1), list_sdvs.str_element(single_token_value_2) ], source=asrt_source.is_at_end_of_line(1)), ), Case( 'multiple string constants on line that is followed by a non-empty line', source=remaining_source( single_token_value_1 + ' ' + single_token_value_2, [' ']), expectation=Expectation( elements=[ list_sdvs.str_element(single_token_value_1), list_sdvs.str_element(single_token_value_2) ], source=asrt_source.is_at_end_of_line(1)), ), Case( 'symbol-reference and string constant on first line', source=remaining_source('{sym_ref} {string_constant}'.format( sym_ref=symbol_reference_syntax_for_name(symbol_name), string_constant=single_token_value)), expectation=Expectation( elements=[ list_sdvs.symbol_element( reference_to__on_direct_and_indirect(symbol_name)), list_sdvs.str_element(single_token_value) ], references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_rest.is__w_str_rendering()) ]), source=asrt_source.is_at_end_of_line(1)), ), Case( 'complex element (sym-ref and str const) and string constant, ' 'followed by space, ' 'followed by non-empty line', source=remaining_source( symbol_reference_syntax_for_name(symbol_name) + single_token_value + ' ' + single_token_value_1, [' ']), expectation=Expectation( elements=[ list_sdvs.string_element( string_sdvs.from_fragments( [ string_sdvs.symbol_fragment( SymbolReference( symbol_name, reference_restrictions. is_any_type_w_str_rendering()), ), string_sdvs.str_fragment( single_token_value), ])), list_sdvs.str_element(single_token_value_1), ], references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_rest.is__w_str_rendering()) ]), source=asrt_source.is_at_end_of_line(1)), ), Case( 'multiple string constants on line followed by r-paren', source=remaining_source( ' '.join((single_token_value_1, single_token_value_2, reserved_words.PAREN_END, 'constant')), [' ']), expectation=Expectation( elements=[ list_sdvs.str_element(single_token_value_1), list_sdvs.str_element(single_token_value_2) ], source=asrt_source.source_is_not_at_end( current_line_number=asrt.equals(1), remaining_part_of_current_line=asrt.equals(' '.join( (reserved_words.PAREN_END, 'constant'))))), ), Case( '1st string on first line, followed by continuation-token, followed by line with 2nd string', source=remaining_source( single_token_value_1 + ' ' + defs.CONTINUATION_TOKEN, [single_token_value_2]), expectation=Expectation( elements=[ list_sdvs.str_element(single_token_value_1), list_sdvs.str_element(single_token_value_2) ], source=asrt_source.is_at_end_of_line(2)), ), Case( 'multiple elements on two lines, separated by continuation token', source=remaining_source('a b ' + defs.CONTINUATION_TOKEN, [' c d ']), expectation=Expectation( elements=[ list_sdvs.str_element('a'), list_sdvs.str_element('b'), list_sdvs.str_element('c'), list_sdvs.str_element('d'), ], source=asrt_source.is_at_end_of_line(2)), ), ] # ACT & ASSERT # _test_cases(self, cases)
def reference_assertion__path( self, symbol_name: str) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_ref_restriction.equals__w_str_rendering( self.reference_restriction__path))
def test(self): single_token_value = 'single_token_value' string_symbol = NameAndValue('string_symbol_name', 'string symbol value') cases = [ Case('single string constant, at end of line, on the last line', source= remaining_source(single_token_value), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= assert_source(is_at_eof=asrt.is_true)), ), Case('single symbol reference, at end of line, on the last line', source= remaining_source(symbol_reference_syntax_for_name(string_symbol.name)), expectation= Expectation(elements= [list_resolvers.symbol_element(symbol_reference(string_symbol.name))], source= assert_source(is_at_eof=asrt.is_true), references= asrt.matches_sequence([asrt_sym_ref.matches_reference_2( string_symbol.name, is_any_data_type_reference_restrictions()) ])), ), Case('complex element (str const and sym-refs), at end of line, on the last line', source= remaining_source(single_token_value + symbol_reference_syntax_for_name(string_symbol.name)), expectation= Expectation( elements= [ list_resolvers.string_element(string_resolvers.from_fragments([ string_resolvers.str_fragment(single_token_value), string_resolvers.symbol_fragment( SymbolReference(string_symbol.name, reference_restrictions.is_any_data_type()) ), ]))], references= asrt.matches_sequence([asrt_sym_ref.matches_reference_2( string_symbol.name, is_any_data_type_reference_restrictions()) ]), source= asrt_source.is_at_end_of_line(1)), ), Case('single element, followed by more than one space, on the last line', source= remaining_source(single_token_value + ' ', []), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= asrt_source.is_at_line(1, ' ')), ), Case('single element, followed by single space, on the last line', source= remaining_source(single_token_value + ' ', []), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= asrt_source.is_at_end_of_line(1)), ), Case('single element, followed by space, followed by empty line', source= remaining_source(single_token_value + ' ', ['']), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= asrt_source.is_at_line(1, ' ')), ), Case('single element, at end of line, followed by line with only space', source= remaining_source(single_token_value, [' ']), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= asrt_source.is_at_end_of_line(1)), ), Case('single element, followed by space, followed by line with only space', source= remaining_source(single_token_value + ' ', [' ']), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= asrt_source.is_at_line(1, ' ')), ), Case('single element, at end of line, followed by line with invalid quoting', source= remaining_source(single_token_value, ['" ']), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value)], source= asrt_source.is_at_end_of_line(1)), ), ] # ACT & ASSERT # _test_cases(self, cases)
def test(self): single_token_value = 'single_token_value' single_token_value_1 = 'single_token_value_1' single_token_value_2 = 'single_token_value_2' symbol_name = 'a_symbol_name' cases = [ Case('multiple string constants on line that is the last line', source= remaining_source(single_token_value_1 + ' ' + single_token_value_2), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value_1), list_resolvers.str_element(single_token_value_2) ], source=asrt_source.is_at_end_of_line(1)), ), Case('multiple string constants on line that is followed by an empty line', source= remaining_source(single_token_value_1 + ' ' + single_token_value_2, ['']), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value_1), list_resolvers.str_element(single_token_value_2) ], source= asrt_source.is_at_end_of_line(1)), ), Case('multiple string constants on line that is followed by a non-empty line', source= remaining_source(single_token_value_1 + ' ' + single_token_value_2, [' ']), expectation= Expectation(elements= [list_resolvers.str_element(single_token_value_1), list_resolvers.str_element(single_token_value_2) ], source= asrt_source.is_at_end_of_line(1)), ), Case('symbol-reference and string constant on first line', source= remaining_source('{sym_ref} {string_constant}'.format( sym_ref=symbol_reference_syntax_for_name(symbol_name), string_constant=single_token_value)), expectation= Expectation(elements= [list_resolvers.symbol_element(symbol_reference(symbol_name)), list_resolvers.str_element(single_token_value) ], references= asrt.matches_sequence([asrt_sym_ref.matches_reference_2( symbol_name, is_any_data_type_reference_restrictions()) ]), source= asrt_source.is_at_end_of_line(1)), ), Case('complex element (sym-ref and str const) and string constant, ' 'followed by space, ' 'followed by non-empty line', source= remaining_source(symbol_reference_syntax_for_name(symbol_name) + single_token_value + ' ' + single_token_value_1, [' ']), expectation= Expectation( elements= [ list_resolvers.string_element(string_resolvers.from_fragments([ string_resolvers.symbol_fragment(SymbolReference(symbol_name, reference_restrictions.is_any_data_type())), string_resolvers.str_fragment(single_token_value), ])), list_resolvers.str_element(single_token_value_1), ], references= asrt.matches_sequence([asrt_sym_ref.matches_reference_2( symbol_name, is_any_data_type_reference_restrictions()) ]), source= asrt_source.is_at_end_of_line(1)), ), ] # ACT & ASSERT # _test_cases(self, cases)
def is_reference_to_data_type_symbol(symbol_name: str) -> ValueAssertion[su.SymbolReference]: return matches_reference_2(symbol_name, is_any_data_type_reference_restrictions())
def is_reference_to_data_category_symbol(symbol_name: str) -> ValueAssertion[SymbolReference]: return asrt_sym_ref.matches_reference_2(symbol_name, is_type_category_restriction(TypeCategory.DATA))
def matches_data_type_symbol_reference(symbol_name: str, restrictions: WithStrRenderingTypeRestrictions) -> Assertion[ SymbolReference]: return asrt_sym_ref.matches_reference_2(symbol_name, asrt_w_str_rend_rest.equals__w_str_rendering(restrictions))
def is_reference_to__files_source(symbol_name: str) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, IS_FILES_SOURCE_REFERENCE_RESTRICTION, )
def test(self): single_token_value = 'single_token_value' string_symbol = NameAndValue('string_symbol_name', 'string symbol value') cases = [ Case( 'single string constant, at end of line, on the last line', source=remaining_source(single_token_value), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=assert_source(is_at_eof=asrt.is_true)), ), Case( 'single symbol reference, at end of line, on the last line', source=remaining_source( symbol_reference_syntax_for_name(string_symbol.name)), expectation=Expectation( elements=[ list_sdvs.symbol_element( reference_to__on_direct_and_indirect( string_symbol.name)) ], source=assert_source(is_at_eof=asrt.is_true), references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( string_symbol.name, asrt_data_rest.is__w_str_rendering()) ])), ), Case( 'complex element (str const and sym-refs), at end of line, on the last line', source=remaining_source( single_token_value + symbol_reference_syntax_for_name(string_symbol.name)), expectation=Expectation( elements=[ list_sdvs.string_element( string_sdvs.from_fragments( [ string_sdvs.str_fragment( single_token_value), string_sdvs.symbol_fragment( SymbolReference( string_symbol.name, reference_restrictions. is_any_type_w_str_rendering(), )), ])) ], references=asrt.matches_sequence([ asrt_sym_ref.matches_reference_2( string_symbol.name, asrt_data_rest.is__w_str_rendering()) ]), source=asrt_source.is_at_end_of_line(1)), ), Case( 'single element, followed by more than one space, on the last line', source=remaining_source(single_token_value + ' ', []), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(1)), ), Case( 'single element, followed by single space, on the last line', source=remaining_source(single_token_value + ' ', []), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(1)), ), Case( 'single element, followed by space, followed by empty line', source=remaining_source(single_token_value + ' ', ['']), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(1)), ), Case( 'single element, at end of line, followed by line with only space', source=remaining_source(single_token_value, [' ']), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(1)), ), Case( 'single element, followed by space, followed by line with only space', source=remaining_source(single_token_value + ' ', [' ']), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(1)), ), Case( 'single element, at end of line, followed by line with invalid quoting', source=remaining_source(single_token_value, ['" ']), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(1)), ), Case( 'continuation token, followed by line with single element', source=remaining_source(defs.CONTINUATION_TOKEN, [single_token_value]), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(2)), ), Case( 'single element, followed by continuation token, followed by empty line', source=remaining_source( single_token_value + ' ' + defs.CONTINUATION_TOKEN, ['']), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.is_at_end_of_line(2)), ), Case( 'single element, followed by r-paren and more', source=remaining_source( ' '.join((single_token_value, reserved_words.PAREN_END, 'const_str')), ['" ']), expectation=Expectation( elements=[list_sdvs.str_element(single_token_value)], source=asrt_source.source_is_not_at_end( current_line_number=asrt.equals(1), remaining_part_of_current_line=asrt.equals(' '.join( (reserved_words.PAREN_END, 'const_str'))))), ), ] # ACT & ASSERT # _test_cases(self, cases)
def is_reference_to__file_name_part(symbol_name: str) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS, )
def reference_assertion(self, symbol_name: str) -> Assertion[SymbolReference]: return asrt_sym_ref.matches_reference_2( symbol_name, asrt_data_rest.is__w_str_rendering())
def equals_symbol_reference(expected: SymbolReference) -> ValueAssertion[SymbolReference]: return asrt_sym_ref.matches_reference_2(expected.name, equals_data_type_reference_restrictions(expected.restrictions))