def test_not_matches(self):
cases = [
NEA(
'different keys',
expected={'expected key': sut.equals('value')},
actual={'actual key': 'value'},
),
NEA(
'different values',
expected={'key': sut.equals('expected value')},
actual={'key': 'actual value'},
),
NEA(
'more elements in actual than in expected',
expected={1: sut.equals('value')},
actual={
1: 'value',
2: 'value'
},
),
NEA(
'more elements in expected than in actual',
expected={
1: sut.equals('value'),
2: sut.equals('value')
},
actual={1: 'value'},
),
]
for nea in cases:
with self.subTest(nea.name):
assertion = sut.matches_mapping(nea.expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, nea.actual)
def test_matches(self):
value1 = 'a value'
value2 = 'a value'
cases = [
NEA(
'empty',
expected=[],
actual=[],
),
NEA(
'single element / list',
expected=[sut.equals(value1)],
actual=[value1],
),
NEA(
'single element / tuple',
expected=(sut.equals(value1), ),
actual=(value1, ),
),
NEA(
'many values',
expected=[sut.equals(value1),
sut.equals(value2)],
actual=[value1, value2],
),
]
for nea in cases:
with self.subTest(nea.name):
assertion = sut.matches_sequence(nea.expected)
# ACT & ASSERT #
assertion.apply_without_message(self, nea.actual)
def test_matches(self):
cases = [
NEA(
'empty',
expected=dict(),
actual=dict(),
),
NEA(
'single element',
expected={1: sut.equals('value')},
actual={1: 'value'},
),
NEA(
'many values',
expected={
1: sut.anything_goes(),
5: sut.anything_goes()
},
actual={
1: 'one value',
5: 'another value'
},
),
]
for nea in cases:
with self.subTest(nea.name):
assertion = sut.matches_mapping(nea.expected)
# ACT & ASSERT #
assertion.apply_without_message(self, nea.actual)
def test_not_matches__different_size(self):
element = 'an element'
equals_element = sut.equals(element)
cases = [
NEA(
'actual is empty',
expected=[equals_element],
actual=[],
),
NEA(
'actual is non empty',
expected=[],
actual=[element],
),
NEA(
'both are non-empty tuples',
expected=(equals_element, ),
actual=(element, element),
),
NEA(
'both are non-empty / more elements in expected',
expected=[equals_element, equals_element],
actual=[element],
),
NEA(
'both are non-empty / more elements in actual',
expected=[equals_element],
actual=[element, element],
),
]
for nea in cases:
with self.subTest(nea.name):
assertion = sut.matches_sequence(nea.expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, nea.actual)
def test_not_matches(self):
cases = [
NEA(
'default/not an external process error',
expected=sut.matches_external_process(),
actual=err_descr.of_message(rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/message',
expected=sut.matches_external_process(
message=asrt_renderer.is_renderer_of_minor_blocks(
asrt.len_equals(1))),
actual=err_descr.of_external_process_error2(
self._EPR, message=rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/external-process-error',
expected=sut.matches_external_process(
external_process_error=asrt.sub_component(
'exit_code', ExternalProcessError.exit_code.fget,
asrt.equals(self._EPR.exit_code + 1))),
actual=err_descr.of_external_process_error2(
self._EPR, message=rend_comb.ConstantSequenceR([])),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_matches(self):
expected_string = 'expected string'
cases = [
NEA(
'default/False',
expected=sut.is_string(),
actual=StringLineObject('anything', False),
),
NEA(
'default/True',
expected=sut.is_string(),
actual=StringLineObject('anything', True),
),
NEA('string',
expected=sut.is_string(string=asrt.equals(expected_string)),
actual=StringLineObject(expected_string, True)),
NEA(
'string is line ended',
expected=sut.is_string(string_is_line_ended=asrt.equals(True)),
actual=StringLineObject('anything', True),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_not_equals(self):
location1 = SourceLocation(self.line_sequence_1, self.path_a)
location2 = SourceLocation(self.line_sequence_2, self.path_b)
cases = [
NEA(
'without inclusion chain/different location',
expected=source_location_path_without_inclusions(location1),
actual=source_location_path_without_inclusions(location2),
),
NEA(
'with inclusion chain/different location',
expected=SourceLocationPath(location1, [location1]),
actual=SourceLocationPath(location2, [location1]),
),
NEA(
'different inclusion chain / different size',
expected=SourceLocationPath(location1, [location1]),
actual=SourceLocationPath(location1, []),
),
NEA(
'different inclusion chain / different contents',
expected=SourceLocationPath(location1, [location1]),
actual=SourceLocationPath(location1, [location2]),
),
]
for nea in cases:
with self.subTest(nea.name):
assertion = sut.equals_source_location_path(nea.expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, nea.actual)
def test_matches(self):
expected_string = 'expected string'
cases = [
NEA('default/False',
expected=
sut.is_pre_formatted_string_detail(),
actual=
sut.PreFormattedStringDetail('anything', False),
),
NEA('default/True',
expected=
sut.is_pre_formatted_string_detail(),
actual=
sut.PreFormattedStringDetail('anything', True),
),
NEA('object_with_to_string',
expected=
sut.is_pre_formatted_string_detail(to_string_object=asrt_to_string.equals(expected_string)),
actual=
sut.PreFormattedStringDetail(expected_string, True)
),
NEA('string is line ended',
expected=
sut.is_pre_formatted_string_detail(string_is_line_ended=asrt.equals(True)),
actual=
sut.PreFormattedStringDetail('anything', True),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_not_matches(self):
# ARRANGE #
cases = [
NEA(
'different header',
expected=sut.Node('the expected header', None, (), ()),
actual=sut.Node('the actual header', None, (), ()),
),
NEA(
'different data',
expected=sut.Node('', 'expected', (), ()),
actual=sut.Node('', 'actual', (), ()),
),
NEA(
'different number of children',
expected=sut.Node('', None, (), (sut.Node('child', None, (), ()),)),
actual=sut.Node('', None, (), ()),
),
NEA(
'different child',
expected=
sut.Node('', None, (), (sut.Node('expected child', None, (), ()),)),
actual=
sut.Node('', None, (), (sut.Node('actual child', None, (), ()),)),
),
]
for case in cases:
with self.subTest(case.name):
assertion = sut.header_data_and_children_equal_as(case.expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, case.actual)
def test_not_matches(self):
cases = [
NEA(
'actual is empty list of line elements',
expected=sut.matches_major_block(
asrt.not_(asrt.is_empty_sequence)),
actual=MajorBlock([]),
),
NEA(
'actual element is unexpected',
expected=sut.matches_major_block(
asrt.matches_sequence(
[asrt.not_(asrt.is_instance(MinorBlock))])),
actual=MajorBlock([MinorBlock([])]),
),
NEA(
'unexpected element properties',
expected=sut.matches_major_block(
asrt.anything_goes(),
properties=asrt.not_(asrt.is_instance(ElementProperties))),
actual=MajorBlock(
[MinorBlock([], ELEMENT_PROPERTIES__NEUTRAL)]),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_symlink(self):
link_target = 'link-target-file'
file_to_check = 'file-to-check'
cases = [
NEA('match: symlink to regular',
True,
DirContents([File.empty(link_target),
sym_link(file_to_check, link_target)]),
),
NEA('match: symlink to directory',
True,
DirContents([Dir.empty(link_target),
sym_link(file_to_check, link_target)]),
),
NEA('match: broken symlink',
True,
DirContents([sym_link(file_to_check, 'non-existing-target-file')]),
),
NEA('not match: actual is regular',
False,
DirContents([File.empty(file_to_check)]),
),
]
for case in cases:
with self.subTest(case_name=case.name):
self._check(file_type_to_check_for=FileType.SYMLINK,
expected_result=case.expected,
base_name_of_file_to_check=file_to_check,
dir_contents=case.actual)
def test_not_matches(self):
cases = [
NEA(
'color - different values',
expected=sut.matches_text_style(color=asrt.equals(
ForegroundColor.GREEN), ),
actual=TextStyle(ForegroundColor.RED, None),
),
NEA(
'color - actual is None',
expected=sut.matches_text_style(color=asrt.equals(
ForegroundColor.GREEN), ),
actual=TextStyle(None, None),
),
NEA(
'font_style - different values',
expected=sut.matches_text_style(font_style=asrt.equals(
FontStyle.UNDERLINE), ),
actual=TextStyle(None, FontStyle.BOLD),
),
NEA(
'font_style - actual is None',
expected=sut.matches_text_style(font_style=asrt.equals(
FontStyle.UNDERLINE), ),
actual=TextStyle(None, None),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_matches(self):
cases = [
NEA(
'default',
expected=sut.matches_element_properties(),
actual=ElementProperties(Indentation(1, ''),
TEXT_STYLE__NEUTRAL),
),
NEA(
'indentation',
expected=sut.matches_element_properties(
indentation=sut.matches_indentation(
level=asrt.equals(69)), ),
actual=ElementProperties(Indentation(69, ''),
TEXT_STYLE__NEUTRAL),
),
NEA(
'text_style',
expected=sut.matches_element_properties(
text_style=sut.matches_text_style(
color=asrt.equals(ForegroundColor.GREEN)), ),
actual=ElementProperties(
INDENTATION__NEUTRAL, TextStyle(ForegroundColor.GREEN,
None)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_not_equals__num_children(self):
child_name = 'child-name'
cases__pos_dir = [
NEA('expected: 0',
[],
[element(child_name)],
),
NEA('expected: 1',
[element(child_name)],
[element(child_name), element(child_name)],
),
NEA('expected: 2',
[element(child_name), element(child_name)],
[element(child_name), element(child_name), element(child_name), element(child_name)],
),
]
for children_level_case in CHILDREN_LEVEL_CASES:
cases = _with_positive_and_negative_direction([
NEA(c.name,
children_level_case.value(c.expected),
children_level_case.value(c.actual),
)
for c in cases__pos_dir
])
for case in cases:
with self.subTest(children_level_case=children_level_case.name,
children_sequence=case.name):
with self.assertRaises(TestException):
sut.equals(case.expected).apply_without_message(self.put, case.actual)
def _test_all_element_types(
self, builder: sut.SectionContentElementBuilder,
assertion_on_file_path: Assertion[pathlib.Path],
assertion_on_file_inclusion_chain: Assertion[
Sequence[SourceLocation]]):
# ARRANGE #
description = 'a description'
line_sequence = single_line_sequence(10, 'the text')
cases = [
NEA('empty',
expected=matches_section_contents_element(
ElementType.EMPTY,
instruction_info=asrt.is_none,
source_location_info=matches_source_location_info2(
source=equals_line_sequence(line_sequence),
file_path_rel_referrer=assertion_on_file_path,
file_inclusion_chain=assertion_on_file_inclusion_chain,
)),
actual=builder.new_empty(line_sequence)),
NEA('comment',
expected=matches_section_contents_element(
ElementType.COMMENT,
instruction_info=asrt.is_none,
source_location_info=matches_source_location_info2(
source=equals_line_sequence(line_sequence),
file_path_rel_referrer=assertion_on_file_path,
file_inclusion_chain=assertion_on_file_inclusion_chain,
)),
actual=builder.new_comment(line_sequence)),
NEA('instruction without description',
expected=matches_section_contents_element(
ElementType.INSTRUCTION,
instruction_info=matches_instruction_info(
asrt.is_none,
equals_instruction_in_section(INSTRUCTION)),
source_location_info=matches_source_location_info2(
source=equals_line_sequence(line_sequence),
file_path_rel_referrer=assertion_on_file_path,
file_inclusion_chain=assertion_on_file_inclusion_chain,
)),
actual=builder.new_instruction(line_sequence, INSTRUCTION,
None)),
NEA('instruction with description',
expected=matches_section_contents_element(
ElementType.INSTRUCTION,
instruction_info=matches_instruction_info(
asrt.equals(description),
equals_instruction_in_section(INSTRUCTION)),
source_location_info=matches_source_location_info2(
source=equals_line_sequence(line_sequence),
file_path_rel_referrer=assertion_on_file_path,
file_inclusion_chain=assertion_on_file_inclusion_chain,
)),
actual=builder.new_instruction(line_sequence, INSTRUCTION,
description)),
]
for nea in cases:
with self.subTest(nea.name):
# ASSERT #
nea.expected.apply_without_message(self, nea.actual)
def test(self):
# ARRANGE #
const_pi = Paragraph([])
cases = [
NEA('empty sequence of paragraphs',
expected=asrt.matches_sequence([]),
actual=[]
),
NEA('single paragraph',
expected=asrt.matches_sequence([
asrt.is__any(const_pi)
]),
actual=[const_pi]
),
]
for case in cases:
with self.subTest(case.name):
# ACT #
actual = sut.constant(case.actual).apply(CONSTRUCTION_ENVIRONMENT)
# ASSERT #
case.expected.apply_without_message(self, actual)
def unequal_attributes_cases() -> List[NEA[ET.Element, ET.Element]]:
cases_positive_direction = [
NEA(
'number of attributes / one empty',
{},
{'a': 'A'}
),
NEA(
'number of attributes / no one empty',
{'a': 'A'},
{'a': 'A', 'b': 'A'},
),
NEA(
'non-empty set of attributes / diff key',
{'a': 'value'},
{'b': 'value'},
),
NEA(
'non-empty set of attributes / diff value',
{'a': 'value 1'},
{'a': 'value 2'},
),
]
tag = 'attr-test'
return _with_positive_and_negative_direction([
NEA(c.name,
element(tag, c.expected),
element(tag, c.actual),
)
for c in cases_positive_direction
])
def test_matches(self):
accessor_error = sut.AccessorError(
sut.AccessErrorType.PRE_PROCESS_ERROR,
self._ERROR_INFO_WITH_DESCRIPTION)
cases = [
NEA(
'default',
actual=accessor_error,
expected=sut.accessor_error_matches(),
),
NEA(
'error',
actual=accessor_error,
expected=sut.accessor_error_matches(
error=asrt.is_(accessor_error.error)),
),
NEA(
'error_info',
actual=accessor_error,
expected=sut.accessor_error_matches(
error_info=asrt.is_(accessor_error.error_info)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_not_matches(self):
cases = [
NEA(
'default assertion/object of unexpected type',
actual='not an ' + str(sut.TestCaseFileReference),
expected=sut.equals_test_case_reference(_ARBITRARY_FILE_REF),
),
NEA(
'unexpected file_path',
actual=sut.TestCaseFileReference(
_ARBITRARY_FILE_REF.file_path / 'unexpected',
_ARBITRARY_FILE_REF.path_relativity_root_dir),
expected=sut.equals_test_case_reference(_ARBITRARY_FILE_REF),
),
NEA(
'unexpected relativity root dir',
actual=sut.TestCaseFileReference(
_ARBITRARY_FILE_REF.file_path,
_ARBITRARY_FILE_REF.path_relativity_root_dir /
'unexpected'),
expected=sut.equals_test_case_reference(_ARBITRARY_FILE_REF),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_directory(self):
dir_to_check = 'dir-to-check'
cases = [
NEA('match',
True,
DirContents([Dir.empty(dir_to_check)]),
),
NEA('match: symlink to directory',
True,
DirContents([Dir.empty('the dir'),
sym_link(dir_to_check, 'the dir')]),
),
NEA('not match: actual is regular',
False,
DirContents([File.empty(dir_to_check)]),
),
NEA('not match: actual is broken symlink',
False,
DirContents([File.empty('the file.txt'),
sym_link(dir_to_check, 'name-of-non-existing-file')]),
),
]
for case in cases:
with self.subTest(case_name=case.name):
self._check(file_type_to_check_for=FileType.DIRECTORY,
expected_result=case.expected,
base_name_of_file_to_check=dir_to_check,
dir_contents=case.actual)
def test_not_equals(self):
cases = [
NEA(
'unexpected driver type',
expected=sut.matches_command(
sut.equals_shell_command_driver(
CommandDriverForShell('command')),
asrt.equals(['arg'])),
actual=Command(CommandDriverForSystemProgram('command'),
['arg']),
),
NEA(
'unexpected driver data',
expected=sut.matches_command(
sut.equals_system_program_command_driver(
CommandDriverForSystemProgram('expected')),
asrt.equals([])),
actual=Command(CommandDriverForSystemProgram('unexpected'),
[]),
),
NEA(
'unexpected argument',
expected=sut.matches_command(
sut.equals_system_program_command_driver(
CommandDriverForSystemProgram('command')),
asrt.equals(['expected'])),
actual=Command(CommandDriverForSystemProgram('command'),
['expected', 'unexpected']),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_not_matches__non_matching_element(self):
actual_element = 'actual element'
expected_element = 'expected element'
equals_expected_element = sut.equals(expected_element)
cases = [
NEA(
'one element / list',
expected=[equals_expected_element],
actual=[actual_element],
),
NEA(
'one element / tuple',
expected=(equals_expected_element, ),
actual=(actual_element, ),
),
NEA(
'two elements',
expected=[equals_expected_element, equals_expected_element],
actual=[actual_element, actual_element],
),
]
for nea in cases:
with self.subTest(nea.name):
assertion = sut.matches_sequence(nea.expected)
# ACT & ASSERT #
assert_that_assertion_fails(assertion, nea.actual)
def test_matches(self):
cases = [
NEA(
'default 1',
expected=sut.matches_text_style(),
actual=TextStyle(None, None),
),
NEA(
'default/w color',
expected=sut.matches_text_style(),
actual=TextStyle(ForegroundColor.GREEN, None),
),
NEA(
'default/w style',
expected=sut.matches_text_style(),
actual=TextStyle(None, FontStyle.BOLD),
),
NEA(
'color',
expected=sut.matches_text_style(color=asrt.equals(
ForegroundColor.GREEN), ),
actual=TextStyle(ForegroundColor.GREEN, None),
),
NEA(
'font_style',
expected=sut.matches_text_style(font_style=asrt.equals(
FontStyle.BOLD), ),
actual=TextStyle(None, FontStyle.BOLD),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def test_not_matches(self):
cases = [
NEA(
'default/not an exception',
expected=sut.matches_exception(),
actual=err_descr.of_message(rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/message',
expected=sut.matches_exception(
message=asrt_renderer.is_renderer_of_minor_blocks(
asrt.len_equals(1))),
actual=err_descr.of_exception(
ValueError('an exception'),
message=rend_comb.ConstantSequenceR([])),
),
NEA(
'custom/exception',
expected=sut.matches_exception(
exception=asrt.is_instance(NotImplementedError)),
actual=err_descr.of_exception(ValueError('an exception')),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected, case.actual)
def test_matches(self):
cases = [
NEA(
'empty list of line elements',
expected=sut.matches_line_element(
asrt.is_instance(LineObjectForTest), ),
actual=LineElement(LineObjectForTest()),
),
NEA(
'line object',
expected=sut.matches_line_element(
asrt.is_instance(LineObjectForTest)),
actual=LineElement(LineObjectForTest()),
),
NEA(
'element properties',
expected=sut.matches_line_element(
asrt.anything_goes(),
properties=asrt.is_instance(ElementProperties),
),
actual=LineElement(LineObjectForTest(),
ELEMENT_PROPERTIES__NEUTRAL),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
class SelectorShouldBeApplied(MultipleExecutionCasesGenerator):
min_depth = 1
max_depth = 1
num_regular_files_eq_1 = [
Dir('lvl0', [
File.empty('lvl1-included'),
Dir('lvl1-not-included', [
File.empty('lvl2-not-included-file'),
Dir.empty('lvl2-not-included-dir'),
])
])
]
num_regular_files_eq_2 = [
Dir('lvl0', [
File.empty('lvl1-included-1'),
File.empty('lvl1-included-2'),
Dir('lvl1-not-included', [
File.empty('lvl2-not-included-file'),
Dir.empty('lvl2-not-included-dir'),
])
])
]
num_files_setup = NumFilesSetup(comparators.EQ, 2, [
NEA(
'not match',
False,
num_regular_files_eq_1,
),
NEA(
'match',
True,
num_regular_files_eq_2,
),
])
def arguments(self) -> FileMatcherArg:
return _as_arguments(
RecWLimArguments(
fms_args.Selection(fm_args.Type(FileType.REGULAR),
self.num_files_setup.num_files_arg()),
self.min_depth,
self.max_depth,
))
def expected_symbols(self) -> Sequence[Assertion[SymbolReference]]:
return ()
def execution_cases(
self) -> Sequence[NExArr[ExecutionResult, Arrangement]]:
return [
NExArr(
num_files_setup.name,
FullExecutionResult(num_files_setup.expected),
Arrangement(tcds=self._helper.
tcds_arrangement_for_contents_of_checked_dir(
num_files_setup.actual)))
for num_files_setup in self.num_files_setup.cases
]
def test_matches(self):
cases = [
NEA(
'empty list of blocks',
expected=sut.matches_major_block(asrt.is_empty_sequence),
actual=MajorBlock([]),
),
NEA(
'non-empty list of blocks',
expected=sut.matches_major_block(
asrt.matches_sequence([asrt.is_instance(MinorBlock)])),
actual=MajorBlock([MinorBlock([])]),
),
NEA(
'test of element properties',
expected=sut.matches_major_block(
asrt.anything_goes(),
properties=sut.matches_element_properties(
indentation=sut.matches_indentation(
level=asrt.equals(72))),
),
actual=MajorBlock([],
ElementProperties(Indentation(72, ''),
TEXT_STYLE__NEUTRAL)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected.apply_without_message(self, case.actual)
def indentation_cases(indent_str: str) -> List[NEA[str, Indentation]]:
level_cases = [
NEA(
'indentation level of ' + str(level),
expected=indent_str * level,
actual=Indentation(level, ''),
) for level in [0, 1, 2]
]
suffix_value = '<indent suffix>'
suffix_cases = [
NEA(
'indentation suffix of ' + suffix_value,
expected=suffix_value,
actual=Indentation(0, suffix_value),
)
]
level_value = 2
mixed_cases = [
NEA(
'indentation level {} and suffix of {}'.format(
level_value, suffix_value),
expected=indent_str * level_value + suffix_value,
actual=Indentation(level_value, suffix_value),
)
]
return level_cases + suffix_cases + mixed_cases
def test_false(self):
cases = [
NEA(
'not none/unexpected type',
expected=sut.is_none_or_instance_with__many(int, []),
actual="1",
),
NEA(
'not none/unexpected type',
expected=sut.is_none_or_instance_with__many(int, []),
actual=['not an integer'],
),
NEA(
'not none/single failing custom assertion',
expected=sut.is_none_or_instance_with__many(
int, [sut.equals(2)]),
actual=1,
),
NEA(
'not none/multiple custom assertions, last fails',
expected=sut.is_none_or_instance_with__many(
int, [sut.equals(1), sut.equals(2)]),
actual=1,
),
NEA(
'not none/multiple custom assertions, non-last fails',
expected=sut.is_none_or_instance_with__many(
int, [sut.equals(1),
sut.equals(2),
sut.equals(1)]),
actual=1,
),
]
self._check_false_cases(cases)
def test_empty_blocks_SHOULD_BE_separated_by_single_block_separator(self):
# Have not implemented filtering of non-empty blocks.
# Reason is that such blocks should not be constructed.
# But implement it if it appears to be useful for making
# construction easier.
# ARRANGE #
string_1 = 'the 1st string'
empty_block = s.MajorBlock([
s.MinorBlock(
[],
s.ELEMENT_PROPERTIES__NEUTRAL,
),
], s.ELEMENT_PROPERTIES__NEUTRAL)
non_empty_block = s.MajorBlock(
[
single_line_minor_block_w_plain_properties(string_1),
],
s.ELEMENT_PROPERTIES__NEUTRAL,
)
cases = [
NEA(
'two empty blocks',
lines_content([
MAJOR_BLOCKS_SEPARATOR,
]),
[
empty_block,
empty_block,
],
),
NEA(
'first non-empty, second empty',
lines_content([
string_1,
MAJOR_BLOCKS_SEPARATOR,
]),
[
non_empty_block,
empty_block,
],
),
NEA(
'first non-empty, second empty',
lines_content([
string_1,
MAJOR_BLOCKS_SEPARATOR,
]),
[
non_empty_block,
empty_block,
],
),
]
for case in cases:
check_block_sequence_and_document(self, case)