def test_pass(self):
a_symbol = NameAndValue('symbol name',
ASymbolTableValue('symbol value'))
a_different_symbol = NameAndValue(
'a different symbol name',
ASymbolTableValue('a different symbol value'))
cases = [
(
'empty table',
frozenset(),
empty_symbol_table(),
),
(
'table with a single value',
{a_symbol.name},
SymbolTable({
a_symbol.name: a_symbol.value,
}),
),
(
'table with a multiple values',
{a_symbol.name, a_different_symbol.name},
SymbolTable({
a_symbol.name: a_symbol.value,
a_different_symbol.name: a_different_symbol.value,
}),
),
]
for name, expected_keys, actual_symbol_table in cases:
with self.subTest(name=name):
# ARRANGE #
assertion = sut.assert_symbol_table_keys_equals(expected_keys)
# ACT #
assertion.apply_without_message(self, actual_symbol_table)
def __init__(self,
all_definitions: Sequence[SymbolDefinition],
builtin_symbols: SymbolTable):
self._symbol_table = SymbolTable({
definition.name: definition.symbol_container
for definition in all_definitions
})
self._symbol_table.add_table(builtin_symbols)
def _assert_table_contains(put: unittest.TestCase,
table: sut.SymbolTable,
expected_symbol: NameAndValue[ASymbolTableValue]):
put.assertTrue(table.contains(expected_symbol.name),
'table SHOULD contain the value')
put.assertIn(expected_symbol.name,
table.names_set,
'names set should contain the value')
put.assertIs(expected_symbol.value,
table.lookup(expected_symbol.name),
'lookup should fins the value')
def _assert_table_contains(put: unittest.TestCase,
table: sut.SymbolTable,
expected_symbol: NameAndValue):
put.assertTrue(table.contains(expected_symbol.name),
'table SHOULD contain the value')
put.assertIn(expected_symbol.name,
table.names_set,
'names set should contain the value')
put.assertIs(expected_symbol.value,
table.lookup(expected_symbol.name),
'lookup should fins the value')
def ret_val(symbols: SymbolTable) -> StringDdv:
container = symbols.lookup(symbol_name)
assert isinstance(
container,
SymbolContainer), 'Value in Symbol Table must be SymbolContainer'
assert container.value_type == ValueType.STRING, 'Value type must be STRING'
return container.sdv.resolve(symbols)
def resolve(self, symbols: SymbolTable) -> FilesSourceDdv:
container = symbols.lookup(self._symbol_name)
assert isinstance(container, SymbolContainer)
sdv = container.sdv
assert isinstance(
sdv, FilesSourceSdv), 'Referenced symbol must be FilesSourceSdv'
return sdv.resolve(symbols)
def execute(self):
# SETUP #
self.__initial_hds_dir_path = pathlib.Path().resolve()
# ACT #
initial_hds_dir_path = self.initial_hds_dir_path.resolve()
exe_conf = ExecutionConfiguration(self.__default_environ_getter,
self.__environ,
self.__timeout_in_seconds,
self.__os_services,
sandbox_root_name_resolver.for_test(),
2 ** 10,
SymbolTable())
configuration_builder = ConfigurationBuilder(initial_hds_dir_path,
initial_hds_dir_path,
NameAndValue('the actor',
self._actor()))
full_result = execution.execute(
exe_conf,
configuration_builder,
True,
self._test_case())
# ASSERT #
self.__full_result = full_result
self._assertions()
# CLEANUP #
os.chdir(str(self.initial_hds_dir_path))
if not self.__dbg_do_not_delete_dir_structure and self.sds:
shutil.rmtree(str(self.sds.root_dir))
else:
if self.sds:
print(str(self.sds.root_dir))
def _file_contents_cases(self) -> InvalidDestinationFileTestCasesData:
file_contents_cases = [
NameAndValue('empty file', fs_abs_stx.FileContentsEmptyAbsStx()),
]
return InvalidDestinationFileTestCasesData(file_contents_cases,
SymbolTable({}))
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
# ARRANGE #
named_transformer = StringTransformerSymbolContext.of_primitive(
'the_transformer', every_line_empty())
original_file_contents = 'some\ntext'
symbols = SymbolTable(
{named_transformer.name: named_transformer.symbol_table_container})
expected_symbol_reference_to_transformer = is_reference_to_string_transformer(
named_transformer.name)
expected_symbol_usages = asrt.matches_sequence(
[expected_symbol_reference_to_transformer])
self._check_with_source_variants(
test_configuration.arguments_for(
args(
'{transform_option} {the_transformer} {maybe_not} {empty}',
the_transformer=named_transformer.name,
maybe_not=maybe_not.
nothing__if_positive__not_option__if_negative)),
model_constructor.of_str(self, original_file_contents),
arrangement_w_tcds(post_population_action=
MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY,
symbols=symbols),
Expectation(
ParseExpectation(symbol_references=expected_symbol_usages),
ExecutionExpectation(
main_result=maybe_not.pass__if_positive__fail__if_negative,
),
))
def _symbols_for(self,
operands: List[NameAndValue[MatcherBehaviour]],
) -> SymbolTable:
return SymbolTable({
operand.name: self._symbol_definition_for(operand)
for operand in operands
})
def __init__(
self,
default_test_case_handling_setup: TestCaseHandlingSetup,
default_case_sandbox_root_dir_name_sdv: SandboxRootDirNameResolver,
test_case_definition: TestCaseDefinitionForMainProgram,
test_suite_definition: TestSuiteDefinition,
mem_buff_size: int,
):
self._test_suite_definition = test_suite_definition
predefined_symbols = SymbolTable({
bs.name: bs.container
for bs in test_case_definition.builtin_symbols
})
self._mem_buff_size = mem_buff_size
self._test_case_definition = TestCaseDefinition(
test_case_definition.test_case_parsing_setup,
PredefinedProperties(
os_proc_env.ENV_VARS_GETTER__DEFAULT,
os_proc_env.ENV_VARS__DEFAULT,
os_proc_env.TIMEOUT__DEFAULT,
predefined_symbols,
))
self._default_test_case_handling_setup = default_test_case_handling_setup
self._test_case_def_for_m_p = test_case_definition
self._default_case_sandbox_root_dir_name_sdv = default_case_sandbox_root_dir_name_sdv
self._commands = {
common_cli_options.HELP_COMMAND:
self._parse_and_execute_help,
common_cli_options.SUITE_COMMAND:
self._parse_and_execute_test_suite,
common_cli_options.SYMBOL_COMMAND:
self._parse_and_execute_symbol_inspection
}
def test_fail(self):
a_symbol = NameAndValue('symbol name',
ASymbolTableValue('symbol value'))
a_different_symbol = NameAndValue(
'a different symbol name',
ASymbolTableValue('a different symbol value'))
a_different_symbol_2 = NameAndValue(
'a different symbol name 2',
ASymbolTableValue('a different symbol value 2'))
cases = [
(
'expecting a single key but actual table is empty',
{a_symbol.name},
empty_symbol_table(),
),
(
'expecting empty set of keys but actual table is non-empty',
frozenset(),
SymbolTable({
a_symbol.name: a_symbol.value,
}),
),
(
'number of keys is expected, but value is different',
{a_symbol.name},
SymbolTable({
a_different_symbol.name: a_different_symbol.value,
}),
),
(
'number of keys is expected, but one of the keys is not expected',
{a_symbol.name, a_different_symbol.name},
SymbolTable({
a_symbol.name:
a_symbol.value,
a_different_symbol_2.name:
a_different_symbol_2.value,
}),
),
]
for name, expected_keys, actual_symbol_table in cases:
with self.subTest(name=name):
# ARRANGE #
assertion = sut.assert_symbol_table_keys_equals(expected_keys)
# ACT #
assert_that_assertion_fails(assertion, actual_symbol_table)
def symbols(self, put: unittest.TestCase) -> SymbolTable:
return SymbolTable({
self.files_matcher_name:
model_checker.matcher__sym_tbl_container(
put,
self._helper.model_file_path(),
self._expected,
)
})
def _validate_symbol_definition(symbol_table: SymbolTable,
definition: su.SymbolDefinition,
) -> Optional[PartialInstructionControlledFailureInfo]:
if symbol_table.contains(definition.name):
already_defined_resolver_container = symbol_table.lookup(definition.name)
assert isinstance(already_defined_resolver_container, SymbolContainer), \
'Value in SymTbl must be ResolverContainer'
return PartialInstructionControlledFailureInfo(
PartialControlledFailureEnum.VALIDATION_ERROR,
error_messages.duplicate_symbol_definition(already_defined_resolver_container.source_location,
definition.name))
else:
for referenced_value in definition.references:
failure_info = validate_symbol_usage(referenced_value, symbol_table)
if failure_info is not None:
return failure_info
symbol_table.add(definition.symbol_table_entry)
return None
def symbols(self, put: unittest.TestCase) -> SymbolTable:
return SymbolTable({
self.files_matcher_name:
model_checker.matcher__sym_tbl_container(
put,
self._helper.model_file_path(),
test_data.strip_file_type_info(self._case.data.expected),
)
})
class PresentationBlockConstructor:
def __init__(self,
all_definitions: Sequence[SymbolDefinition],
builtin_symbols: SymbolTable):
self._symbol_table = SymbolTable({
definition.name: definition.symbol_container
for definition in all_definitions
})
self._symbol_table.add_table(builtin_symbols)
def block_for(self, sdv: SymbolDependentValue) -> ResolvedValuePresentationBlock:
if isinstance(sdv, FullDepsSdv):
return _of_full_deps(sdv.resolve(self._symbol_table))
elif isinstance(sdv, DataTypeSdv):
constructor = _WStrRenderingTypeBlockConstructor(self._symbol_table)
return constructor.visit(sdv)
else:
raise TypeError('Unknown {} type: {}'.format(str(SymbolDependentValue), str(sdv)))
def resolve(self, symbols: SymbolTable) -> List[StringDdv]:
container = symbols.lookup(self._symbol_reference.name)
ddv = container.sdv.resolve(symbols)
if isinstance(ddv, StringDdv):
return [ddv]
if isinstance(ddv, PathDdv):
return [ddvs.string_ddv_of_single_path(ddv)]
if isinstance(ddv, ListDdv):
return list(ddv.string_elements)
raise TypeError('Unknown Symbol Value: ' + str(ddv))
def resolve(self, symbols: SymbolTable) -> List[StringValue]:
container = symbols.lookup(self._symbol_reference.name)
value = container.resolver.resolve(symbols)
if isinstance(value, StringValue):
return [value]
if isinstance(value, FileRef):
return [csv.string_value_of_single_file_ref(value)]
if isinstance(value, ListValue):
return list(value.string_value_elements)
raise TypeError('Unknown Symbol Value: ' + str(value))
def _validate_reference(symbol_reference: su.SymbolReference,
symbols: SymbolTable) -> Optional[str]:
referenced_resolver_container = symbols.lookup(symbol_reference.name)
assert isinstance(referenced_resolver_container, SymbolContainer), \
'Values in SymbolTable must be ResolverContainer'
result = symbol_reference.restrictions.is_satisfied_by(symbols, symbol_reference.name,
referenced_resolver_container)
if result is None:
return None
return restriction_failures.error_message(symbol_reference.name, symbols, result)
def resolve(self, symbols: SymbolTable) -> StringSourceDdv:
container = symbols.lookup(self._symbol_name)
assert isinstance(container, SymbolContainer) # Type info for IDE
sdv = container.sdv
if isinstance(sdv, StringSourceSdv):
return sdv.resolve(symbols)
elif isinstance(sdv, StringSdv):
return sdvs.ConstantStringStringSourceSdv(sdv).resolve(symbols)
else:
raise TypeError('Expected string-source or string, found: ' +
str(container.value_type))
def _validate_reference(symbol_reference: SymbolReference,
symbols: SymbolTable) -> Optional[TextRenderer]:
referenced_sdv_container = symbols.lookup(symbol_reference.name)
assert isinstance(referenced_sdv_container, SymbolContainer), \
'Values in SymbolTable must be SymbolContainer'
result = symbol_reference.restrictions.is_satisfied_by(
symbols, symbol_reference.name, referenced_sdv_container)
if result is None:
return None
return restriction_failures.ErrorMessage(symbol_reference.name, symbols,
result)
def fake_post_sds_environment() -> InstructionEnvironmentForPostSdsStep:
sds = fake_sds()
return InstructionEnvironmentForPostSdsStep(
fake_hds(),
ProcessExecutionSettings.with_empty_environ(),
sds,
TmpFileStorage(sds.internal_tmp_dir / 'instruction-dir',
lambda path: DirFileSpaceThatDoNotCreateFiles(path)),
SymbolTable.empty(),
2 ** 10,
)
def resolve(self, symbols: SymbolTable) -> PathDdv:
symbol_value_2_path = _WStrRenderingValueSymbol2PathResolverVisitor(
self._suffix_sdv, self.default_relativity, symbols)
container = symbols.lookup(self._path_or_string_symbol.name)
assert isinstance(
container,
SymbolContainer), 'Implementation consistency/SymbolContainer'
sdv = container.sdv
assert isinstance(
sdv, DataTypeSdv), 'Implementation consistency/DataTypeSdv'
return symbol_value_2_path.visit(sdv)
def _validate_symbol_definition(
symbol_table: SymbolTable,
definition: SymbolDefinition,
) -> Optional[PartialInstructionControlledFailureInfo]:
if symbol_table.contains(definition.name):
already_defined_sdv_container = symbol_table.lookup(definition.name)
assert isinstance(already_defined_sdv_container, SymbolContainer), \
'Value in SymTbl must be ResolverContainer'
return PartialInstructionControlledFailureInfo(
PartialControlledFailureEnum.VALIDATION_ERROR,
error_messages.duplicate_symbol_definition(
already_defined_sdv_container.source_location,
definition.name))
else:
for referenced_value in definition.references:
failure_info = validate_symbol_usage(referenced_value,
symbol_table)
if failure_info is not None:
return failure_info
symbol_table.add(definition.symbol_table_entry)
return None
def symbol_table_with_values_matching_references(references: Sequence[SymbolReference]) -> SymbolTable:
value_constructor = _ValueCorrespondingToValueRestriction()
elements = {}
for ref in references:
restrictions = ref.restrictions
assert isinstance(restrictions,
ReferenceRestrictionsOnDirectAndIndirect), 'Only handled/needed case for the moment'
value_restriction = restrictions.direct
assert isinstance(value_restriction, ValueRestriction)
value_type, value = value_constructor.visit(value_restriction)
elements[ref.name] = SymbolContainer(value, value_type, None)
return SymbolTable(elements)
def __assertions_on_reference_restrictions(self, put: unittest.TestCase,
actual: PathSdv,
symbols: SymbolTable):
for idx, reference in enumerate(actual.references):
assert isinstance(reference, SymbolReference) # Type info for IDE
container = symbols.lookup(reference.name)
assert isinstance(container, SymbolContainer)
result = reference.restrictions.is_satisfied_by(
symbols, reference.name, container)
put.assertIsNone(
result,
'Restriction on reference #{}: expects None=satisfaction'.
format(idx))
def resolving_env_w_custom_dir_space(
sds: SandboxDs,
mem_buff_size: int = 2**10,
) -> FullResolvingEnvironment:
return FullResolvingEnvironment(
SymbolTable.empty(), fake_tcds(),
ApplicationEnvironment(
OsServicesThatRaises(),
proc_exe_env_for_test(),
tmp_file_spaces.tmp_dir_file_space_for_test(
sds.internal_tmp_dir / 'string-model-dir-for-test'),
mem_buff_size,
))
def test_fail(self):
a_symbol = NameAndValue('symbol name',
ASymbolTableValue('symbol value'))
a_different_symbol = NameAndValue(
'a different symbol name',
ASymbolTableValue('a different symbol value'))
cases = [
(
'table is empty',
empty_symbol_table(),
a_symbol.name,
asrt.anything_goes(),
),
(
'table is singleton but contains a different name',
SymbolTable({a_symbol.name: a_symbol.value}),
a_different_symbol.name,
asrt.anything_goes(),
),
('table is singleton with given name but value assertion fails',
SymbolTable({a_symbol.name: a_symbol.value}), a_symbol.name,
assert_string_value_equals(a_different_symbol.value.value)),
(
'table contains more than one element',
SymbolTable({
a_symbol.name: a_symbol.value,
a_different_symbol.name: a_different_symbol.value
}),
a_symbol.name,
asrt.anything_goes(),
),
]
for name, table, symbol_name, value_assertion in cases:
with self.subTest(name=name):
assertion = sut.assert_symbol_table_is_singleton(
symbol_name, value_assertion)
assert_that_assertion_fails(assertion, table)
def __init__(
self,
initial_symbols: SymbolTable,
test_case: TestCase,
action_to_check: ActionToCheck,
mk_atc_failure_con: Callable[[PhaseStep],
PhaseStepFailureResultConstructor],
):
self._symbols = initial_symbols.copy()
self._test_case = test_case
self._action_to_check = action_to_check
self._mk_atc_failure_con = mk_atc_failure_con
self._validation_executor = ValidateSymbolsExecutor(self._symbols)
def _validate_symbol_reference(symbol_table: SymbolTable,
reference: su.SymbolReference,
) -> Optional[PartialInstructionControlledFailureInfo]:
assert isinstance(reference, su.SymbolReference)
if not symbol_table.contains(reference.name):
error_message = error_messages.undefined_symbol(reference)
return PartialInstructionControlledFailureInfo(
PartialControlledFailureEnum.VALIDATION_ERROR,
error_message)
else:
err_msg = _validate_reference(reference, symbol_table)
if err_msg is not None:
return PartialInstructionControlledFailureInfo(PartialControlledFailureEnum.VALIDATION_ERROR, err_msg)
return None
def resolve(self, symbols: SymbolTable) -> sv.StringFragment:
container = symbols.lookup(self._symbol_reference.name)
assert isinstance(container, struct.SymbolContainer), 'Value in SymTbl must be SymbolContainer'
value_resolver = container.resolver
assert isinstance(value_resolver, DataValueResolver), 'Value must be a DataValueResolver'
value = value_resolver.resolve(symbols)
if isinstance(value, sv.StringValue):
return csv.StringValueFragment(value)
elif isinstance(value, FileRef):
return csv.FileRefFragment(value)
elif isinstance(value, ListValue):
return csv.ListValueFragment(value)
else:
raise TypeError('Not a {}: {}'.format(str(DataValueResolver),
value))
def _validate_symbol_reference(
symbol_table: SymbolTable,
reference: SymbolReference,
) -> Optional[PartialInstructionControlledFailureInfo]:
assert isinstance(reference, SymbolReference)
if not symbol_table.contains(reference.name):
return PartialInstructionControlledFailureInfo(
PartialControlledFailureEnum.VALIDATION_ERROR,
error_messages.undefined_symbol(reference))
else:
err_msg = _validate_reference(reference, symbol_table)
if err_msg is not None:
return PartialInstructionControlledFailureInfo(
PartialControlledFailureEnum.VALIDATION_ERROR, err_msg)
return None
def test_succeed_WHEN_table_contains_the_expected_element(self):
a_symbol = NameAndValue('symbol name',
ASymbolTableValue('symbol value'))
cases = [
('assertion is', a_symbol, asrt.is_(a_symbol.value)),
('assertion has expected value', a_symbol,
assert_string_value_equals(a_symbol.value.value)),
]
for name, symbol, value_assertion in cases:
with self.subTest(name=name):
# ARRANGE #
actual = SymbolTable({symbol.name: symbol.value})
assertion = sut.assert_symbol_table_is_singleton(
symbol.name, value_assertion)
# ACT #
assertion.apply_without_message(self, actual)
def resolve(self, symbols: SymbolTable) -> sv.StringFragmentDdv:
container = symbols.lookup(self._symbol_reference.name)
assert isinstance(
container,
SymbolContainer), 'Value in SymTbl must be SymbolContainer'
value_sdv = container.sdv
assert isinstance(value_sdv,
DataTypeSdv), 'Value must be a DataTypeSdv'
value = value_sdv.resolve(symbols)
if isinstance(value, sv.StringDdv):
return csv.StringDdvFragmentDdv(value)
elif isinstance(value, PathDdv):
return csv.PathFragmentDdv(value)
elif isinstance(value, ListDdv):
return csv.ListFragmentDdv(value)
else:
raise TypeError('Not a {}: {}'.format(str(DataTypeSdv), value))
def get_command_assertion(tcds: TestCaseDs) -> Assertion[Command]:
symbols = SymbolTable.empty()
return asrt_command.matches_command(
asrt.anything_goes(),
asrt.equals(
interpreter_arguments_symbol.constant_list +
[
str(relativity_configurations.ATC_FILE
.named_file_conf(exe_file.name)
.path_sdv
.resolve(symbols)
.value_of_any_dependency__d(tcds)
.primitive
),
argument_to_act_file,
]
)
)
def check__abs_stx__expr_parse_source_variants(
self,
put: unittest.TestCase,
syntax: AbstractSyntax,
symbols: Optional[SymbolTable],
expectation: Expectation[T],
sub_test_identifiers: Mapping[str, Any] = MappingProxyType({}),
):
if symbols is None:
symbols = SymbolTable.empty()
for formatting_case in abs_stx_utils.formatting_cases(syntax):
for equivalent_source_case in equivalent_source_variants.expr_parse__s__nsc(
formatting_case.value):
with put.subTest(
zz_formatting=formatting_case.name,
zz_following_source_variant=equivalent_source_case.
name,
**sub_test_identifiers):
parse_source = equivalent_source_case.source
with token_stream_parser.from_parse_source(
parse_source) as token_parser:
# ACT
sdv = self._parser.parse(token_parser)
# ASSERT #
equivalent_source_case.expectation.apply_with_message(
put,
parse_source,
'source after parse',
)
expectation.symbol_references.apply_with_message(
put,
sdv.references,
'symbol references',
)
expectation.sdv.apply_with_message(
put, sdv, 'custom sdv expectation')
# ACT #
ddv = sdv.resolve(symbols)
# ASSERT #
expectation.ddv.apply_with_message(
put,
ddv,
'ddv',
)
def _check_indirect(self,
symbol_table: SymbolTable,
path_to_referring_symbol: tuple,
references: list) -> FailureOfIndirectReference:
for reference in references:
container = symbol_table.lookup(reference.name)
result = self._indirect.is_satisfied_by(symbol_table, reference.name, container)
if result is not None:
return FailureOfIndirectReference(
failing_symbol=reference.name,
path_to_failing_symbol=list(path_to_referring_symbol),
error=result,
meaning_of_failure=self._meaning_of_failure_of_indirect_reference)
result = self._check_indirect(symbol_table,
path_to_referring_symbol + (reference.name,),
container.resolver.references)
if result is not None:
return result
return None
def ret_val(symbols: SymbolTable) -> StringValue:
container = symbols.lookup(symbol_name)
assert isinstance(container, SymbolContainer), 'Value in SymTbl must be SymbolContainer'
return container.resolver.resolve(symbols)
def custom_main(self, symbols: SymbolTable):
symbols.put(self.symbol.name,
self.symbol.resolver_container)
def lookup_container(symbols: SymbolTable, name: str) -> SymbolContainer:
container = symbols.lookup(name)
assert isinstance(container, SymbolContainer), 'Value in SymTbl must be SymbolContainer'
return container