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