def test_symbol_ref_not_equals_symbol_ref_with_different_symbol_name(self):
# ARRANGE #
expected = list_sdvs.symbol_element(reference_to__on_direct_and_indirect('expected_symbol_name'))
actual = list_sdvs.symbol_element(reference_to__on_direct_and_indirect('actual_symbol_name'))
assertion = sut.equals_list_sdv_element(expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, actual)
def test_symbol_ref_not_equals_string(self):
# ARRANGE #
string_element = list_sdvs.str_element('value')
symbol_reference_element = list_sdvs.symbol_element(reference_to__on_direct_and_indirect('symbol_name'))
assertion = sut.equals_list_sdv_element(symbol_reference_element)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, string_element)
def test_symbol_that_does_not_meet_restriction_in_validate_symbols(self):
test_case = _single_successful_instruction_in_each_phase()
symbol_name = 'symbol_name'
reference_to_string_symbol = data_references.reference_to__on_direct_and_indirect(
symbol_name, value_restrictions.is_string())
definition_of_path_symbol = arbitrary_path_symbol_context(
symbol_name).definition
symbol_usages = [
definition_of_path_symbol,
reference_to_string_symbol,
]
self._check(
Arrangement(test_case, atc_symbol_usages=do_return(symbol_usages)),
Expectation(
asrt_result.matches2(
ExecutionFailureStatus.VALIDATION_ERROR,
asrt_result.has_no_sds(),
asrt_result.has_no_action_to_check_outcome(),
ExpectedFailureForPhaseFailure.new_with_step(
phase_step.ACT__VALIDATE_SYMBOLS),
),
[
phase_step.ACT__PARSE,
phase_step.SETUP__VALIDATE_SYMBOLS,
phase_step.ACT__VALIDATE_SYMBOLS,
],
))
def test_equals(self):
cases = [
list_sdvs.from_str_constants(['value']),
list_sdvs.from_elements([list_sdvs.symbol_element(reference_to__on_direct_and_indirect('symbol_name'))]),
]
for sdv in cases:
with self.subTest(msg=str(sdv)):
sut.equals_list_sdv(sdv).apply_without_message(self, sdv)
def test_equals(self):
test_cases = [
list_sdvs.str_element('value'),
list_sdvs.symbol_element(reference_to__on_direct_and_indirect('symbol_name')),
]
for element in test_cases:
with self.subTest(msg=str(element)):
sut.equals_list_sdv_element(element).apply_without_message(self, element)
def test_expect_no_symbol_usages(self):
self._check_raises_test_error__single_and_multi(
_constant_line_matcher_type_parser_of_matcher_sdv(
sdv_ddv.sdv_from_primitive_value(
references=[
data_references.reference_to__on_direct_and_indirect('symbol_name')])
),
is_expectation_of_execution_result_of(True),
)
def test_that_default_expectation_assumes_no_symbol_usages(self):
unexpected_symbol_usages = [
data_references.reference_to__on_direct_and_indirect('symbol_name')]
self._check_source_and_exe_variants__failing_assertions(
ParserThatGives(
instruction_embryo_that__phase_agnostic(
symbol_usages=do_return(unexpected_symbol_usages))),
Arrangement.phase_agnostic(),
Expectation.phase_agnostic(),
)
def test_not_equals__list(self):
# ARRANGE #
expected = list_sdvs.from_str_constants(['value'])
actual = list_sdvs.from_elements([
list_sdvs.symbol_element(
data_references.reference_to__on_direct_and_indirect(
'symbol_name'))
])
# ACT & ASSERT #
assert_that_assertion_fails(sut.equals_data_type_sdv(expected), actual)
def test_SHOULD_match_WHEN_references_match(self):
# ARRANGE #
actual_reference = data_references.reference_to__on_direct_and_indirect(
'referenced element')
actual_references = [actual_reference]
actual_sdv = arbitrary_sdv_with_references(actual_references)
assertion_to_check = _matches_string_matcher_sdv(
references=asrt.matches_sequence([asrt.is_(actual_reference)]), )
# ACT & ASSERT #
assertion_to_check.apply_without_message(self, actual_sdv)
def test_fragments(self):
# ARRANGE #
fragment_1 = impl.ConstantStringFragmentSdv('fragment 1 value')
fragment_2 = impl.SymbolStringFragmentSdv(
data_references.reference_to__on_direct_and_indirect(
'symbol_name'))
sdv = sut.StringSdv((fragment_1, fragment_2))
# ACT #
actual = sdv.fragments
# ASSERT #
assertion = equals_string_fragments([fragment_1, fragment_2])
assertion.apply_without_message(self, actual)
def test_elements(self):
# ARRANGE #
element_1 = list_sdvs.str_element('constant value')
element_2 = list_sdvs.symbol_element(
data_references.reference_to__on_direct_and_indirect('symbol_name'))
sdv = sut.ListSdv([element_1, element_2])
# ACT #
actual = sdv.elements
# ASSERT #
assertion = asrt.matches_sequence([equals_list_sdv_element(element_1),
equals_list_sdv_element(element_2)])
assertion.apply_without_message(self, actual)
def test_that_default_expectation_assumes_no_symbol_usages(self):
with self.assertRaises(utils.TestError):
unexpected_symbol_usages = [
data_references.reference_to__on_direct_and_indirect('symbol_name')]
self._check(
utils.ParserThatGives(
before_assert_phase_instruction_that(
symbol_usages=do_return(unexpected_symbol_usages))),
single_line_source(),
sut.arrangement(),
sut.Expectation(),
)
def test_fail_due_to_unexpected_references(self):
# ARRANGE #
reference = data_references.reference_to__on_direct_and_indirect(
'symbol_name')
string_sdv_with_single_reference = _StringSdvTestImpl(
explicit_references=[reference])
assertion = sut.matches_sdv(asrt.anything_goes(),
asrt.is_empty_sequence,
asrt.anything_goes())
# ACT & ASSERT #
test_of_test_resources_util.assert_that_assertion_fails(
assertion, string_sdv_with_single_reference)
def test_success(self):
# ARRANGE #
path_symbol = PathDdvSymbolContext(
'symbol_name', path_ddvs.of_rel_option(RelOptionType.REL_ACT))
reference = data_references.reference_to__on_direct_and_indirect(
path_symbol.name)
path_sdv = PathSdvTestImplWithConstantPathAndSymbolReferences(
path_symbol.ddv, [reference])
assertion = sut.matches_sdv(asrt.is_instance(PathSdv),
asrt.len_equals(1),
asrt.is_(path_symbol.ddv),
asrt.is_(path_sdv),
symbols=path_symbol.symbol_table)
# ACT & ASSERT #
assertion.apply_without_message(self, path_sdv)
def test_that_fails_due_to_missing_symbol_reference(self):
symbol_usages_of_matcher = []
symbol_usages_of_expectation = [
data_references.reference_to__on_direct_and_indirect('symbol_name')]
self._check_raises_test_error__single_and_multi(
_constant_line_matcher_type_parser_of_matcher_sdv(
sdv_ddv.sdv_from_primitive_value(references=symbol_usages_of_matcher)
),
Expectation(
ParseExpectation(
symbol_references=sym_asrt.equals_symbol_references__w_str_rendering(
symbol_usages_of_expectation)
),
)
)
def test_resolve_of_list_symbol_SHOULD_give_list_value(self):
# ARRANGE #
string_value_1 = 'string value 1'
string_value_2 = 'string value 2'
list_symbol = ListConstantSymbolContext(
'the_symbol_name', [string_value_1, string_value_2])
symbol_reference = data_references.reference_to__on_direct_and_indirect(
list_symbol.name)
fragment = impl.SymbolStringFragmentSdv(symbol_reference)
symbol_table = list_symbol.symbol_table
# ACT #
actual = fragment.resolve(symbol_table)
# ASSERT #
self.assertIsInstance(actual, csv.ListFragmentDdv)
assertion = equals_string_fragment_ddv(
csv.ListFragmentDdv(list_symbol.ddv))
assertion.apply_without_message(self, actual)
def test_string_token(self):
# ARRANGE #
plain_string = 'plain'
symbol_name = 'symbol_name'
string_symbol = StringSymbolContext.of_arbitrary_value(symbol_name)
cases = [
Case.of(
'plain string',
ArgumentOfRichStringAbsStx.of_str(plain_string),
ARRANGEMENT__NEUTRAL,
Expectation(
elements=[list_sdvs.str_element(plain_string)],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of(
'continuation token followed by plain string on next line',
ContinuationTokenFollowedByArgumentAbsStx(
ArgumentOfRichStringAbsStx.of_str(plain_string)),
ARRANGEMENT__NEUTRAL,
Expectation(
elements=[list_sdvs.str_element(plain_string)],
validators=asrt.is_empty_sequence,
references=asrt.is_empty_sequence,
)),
Case.of(
'symbol reference',
ArgumentOfSymbolReferenceAbsStx(symbol_name),
Arrangement(string_symbol.symbol_table),
Expectation(
elements=[
list_sdvs.symbol_element(
reference_to__on_direct_and_indirect(symbol_name))
],
validators=asrt.is_empty_sequence,
references=asrt.matches_sequence(
[string_symbol.reference_assertion__w_str_rendering]),
)),
]
# ACT & ASSERT #
_test_cases_w_source_variants(self, cases)
def test_SHOULD_not_match_WHEN_references_do_not_match(self):
# ARRANGE #
actual_reference = data_references.reference_to__on_direct_and_indirect(
'referenced element')
actual_references = [actual_reference]
actual_sdv = arbitrary_sdv_with_references(actual_references)
cases = [
NameAndValue('assert no references', asrt.is_empty_sequence),
NameAndValue(
'assert single invalid reference',
asrt.matches_sequence([asrt.not_(asrt.is_(actual_reference))
])),
]
for case in cases:
with self.subTest(name=case.name):
assertion_to_check = _matches_string_matcher_sdv(
references=case.value)
# ACT & ASSERT #
assert_that_assertion_fails(assertion_to_check, actual_sdv)
def test_symbol_that_does_meet_restriction_in_validate_symbols(self):
test_case = _single_successful_instruction_in_each_phase()
symbol_name = 'symbol_name'
reference_to_string_symbol = data_references.reference_to__on_direct_and_indirect(
symbol_name, value_restrictions.is_string())
definition_of_string_symbol = StringConstantSymbolContext(
symbol_name).definition
symbol_usages = [
definition_of_string_symbol,
reference_to_string_symbol,
]
self._check(
Arrangement(
test_case,
atc_symbol_usages=do_return(symbol_usages),
atc_execute=execute_action_that_returns_exit_code(128)),
Expectation(
asrt_result.matches2(
None,
asrt_result.has_sds(),
asrt_result.has_action_to_check_outcome_with_exit_code(
128),
ExpectedFailureForNoFailure(),
),
[phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__ONCE +
PRE_SDS_VALIDATION_STEPS__ONCE + [
phase_step.SETUP__MAIN,
phase_step.SETUP__VALIDATE_POST_SETUP,
phase_step.ACT__VALIDATE_POST_SETUP,
phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP,
phase_step.ASSERT__VALIDATE_POST_SETUP,
phase_step.ACT__VALIDATE_EXE_INPUT,
phase_step.ACT__PREPARE,
phase_step.ACT__EXECUTE,
phase_step.BEFORE_ASSERT__MAIN,
phase_step.ASSERT__MAIN,
(phase_step.CLEANUP__MAIN, PreviousPhase.ASSERT),
],
))
def test_reference_to_undefined_symbol_in_validate_symbols(self):
test_case = _single_successful_instruction_in_each_phase()
symbol_usages_with_ref_to_undefined_symbol = [
data_references.reference_to__on_direct_and_indirect(
'undefined_symbol')
]
self._check(
Arrangement(test_case,
atc_symbol_usages=do_return(
symbol_usages_with_ref_to_undefined_symbol)),
Expectation(
asrt_result.matches2(
ExecutionFailureStatus.VALIDATION_ERROR,
asrt_result.has_no_sds(),
asrt_result.has_no_action_to_check_outcome(),
ExpectedFailureForPhaseFailure.new_with_step(
phase_step.ACT__VALIDATE_SYMBOLS),
),
[
phase_step.ACT__PARSE,
phase_step.SETUP__VALIDATE_SYMBOLS,
phase_step.ACT__VALIDATE_SYMBOLS,
],
))
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_string_constant_SHOULD_raise_exception(self):
fragment = impl.SymbolStringFragmentSdv(
data_references.reference_to__on_direct_and_indirect(
'the_symbol_name'))
with self.assertRaises(ValueError):
fragment.string_constant
def test_should_be_string_constant(self):
fragment = impl.SymbolStringFragmentSdv(
data_references.reference_to__on_direct_and_indirect(
'the_symbol_name'))
self.assertFalse(fragment.is_string_constant)
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_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 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)
