def test_not_equals__same_length__different_values(self): # ARRANGE # expected = (string_sdvs.str_fragment('expected value'), ) actual = (string_sdvs.str_fragment('actual value'), ) assertion = sut.equals_string_fragments(expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, actual)
def test_not_equals(self): expected_string = 'expected value' cases = [ NEA( 'differs__resolved_value', string_sdvs.str_constant(expected_string), string_sdvs.str_constant('actual value'), ), NEA( 'differs__number_of_references', string_sdvs.str_constant(expected_string), sdv_with_references([ SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any())) ]), ), NEA( 'different_number_of_references', StringSdvTestImpl(expected_string, [ SymbolReference( 'expected_symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any())) ]), StringSdvTestImpl(expected_string, [ SymbolReference( 'actual_symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any())) ]), ), NEA( 'different_number_of_fragments', StringSdvTestImpl(expected_string, [], (string_sdvs.str_fragment('value'), )), StringSdvTestImpl(expected_string, [], (())), ), NEA( 'different_fragments', StringSdvTestImpl(expected_string, [], (string_sdvs.str_fragment('value 1'), )), StringSdvTestImpl(expected_string, [], (string_sdvs.str_fragment('value 2'), )), ), ] for case in cases: with self.subTest(case.name): assertion = sut.equals_string_sdv(case.expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, case.actual)
def test_equals(self): test_cases = [ ( (), (), ), ( (string_sdvs.str_fragment('abc'), ), (string_sdvs.str_fragment('abc'), ), ), ( (string_sdvs.symbol_fragment( SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), ), (string_sdvs.symbol_fragment( SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), ), ), ( ( string_sdvs.str_fragment('abc'), string_sdvs.symbol_fragment( SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any( )))), ), ( string_sdvs.str_fragment('abc'), string_sdvs.symbol_fragment( SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any( )))), ), ), ] for fragments1, fragments2 in test_cases: with self.subTest(msg=str(fragments1) + ' ' + str(fragments2)): sut.equals_string_fragments(fragments1).apply_without_message( self, fragments2) sut.equals_string_fragments(fragments2).apply_without_message( self, fragments1)
def test_not_equals(self): # ARRANGE # value = 'a_value' cases = [ NEA( 'different constants', string_sdvs.str_fragment('some value'), string_sdvs.str_fragment('some other value'), ), NEA( 'constant and reference', string_sdvs.str_fragment(value), string_sdvs.symbol_fragment( SymbolReference( value, ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), ), NEA( 'references with different names', string_sdvs.symbol_fragment( SymbolReference( 'a name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), string_sdvs.symbol_fragment( SymbolReference( 'a different name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), ), # NEA( # 'references with different restrictions', # string_sdvs.symbol_fragment( # SymbolReference( # 'common name', # ReferenceRestrictionsOnDirectAndIndirect(AnyDataTypeRestriction())) # ), # string_sdvs.symbol_fragment( # SymbolReference( # 'common name', # TypeCategoryRestriction(TypeCategory.LOGIC)) # ), # ), ] # ACT & ASSERT # for case in cases: with self.subTest(case.name, order='expected == actual'):
def test_not_equals__different_number_of_fragments__non_empty__empty(self): # ARRANGE # expected = (string_sdvs.str_fragment('value'), ) actual = () assertion = sut.equals_string_fragments(expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, actual)
def fragment_sdv_from_fragment(fragment: symbol_syntax.Fragment, reference_restrictions: ReferenceRestrictions) -> StringFragmentSdv: if fragment.is_constant: return string_sdvs.str_fragment(fragment.value) else: sr = SymbolReference(fragment.value, reference_restrictions) return string_sdvs.symbol_fragment(sr)
def fragment_sdv_from_fragment(fragment: Fragment) -> StringFragmentSdv: if fragment.is_constant: return string_sdvs.str_fragment(fragment.value) else: sr = SymbolReference( fragment.value, ReferenceRestrictionsOnDirectAndIndirect( direct=ArbitraryValueWStrRenderingRestriction.of_any(), indirect=None)) return string_sdvs.symbol_fragment(sr)
def test_not_equals__same_length__different_types(self): # ARRANGE # expected = (string_sdvs.str_fragment('value'), ) actual = (string_sdvs.symbol_fragment( SymbolReference( 'value', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), ) assertion = sut.equals_string_fragments(expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, actual)
def test_equals(self): a_string = 'a string' an_identical_string = 'a string' test_cases = [ NEA( 'constant strings', string_sdvs.str_fragment(a_string), string_sdvs.str_fragment(an_identical_string), ), NEA( 'symbol references', string_sdvs.symbol_fragment( SymbolReference( a_string, ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), string_sdvs.symbol_fragment( SymbolReference( an_identical_string, ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), ), NEA( 'symbol references with different restrictions (surprisingly)', string_sdvs.symbol_fragment( SymbolReference( a_string, ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any()))), string_sdvs.symbol_fragment( SymbolReference(an_identical_string, ValueTypeRestriction([ValueType.PROGRAM ]))), ), ] for case in test_cases: with self.subTest(case.name): sut.equals_string_fragment_sdv_with_exact_type( case.expected).apply_without_message(self, case.actual) sut.equals_string_fragment_sdv_with_exact_type( case.actual).apply_without_message(self, case.expected)
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 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 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)