def program_sdv_w_stdin__wo_sym_refs(contents_of_stdin: str) -> ProgramSdv: return program_sdvs.system_program( string_sdvs.str_constant('the-system-program'), stdin=[str_src_sdvs.ConstantStringStringSourceSdv( string_sdvs.str_constant(contents_of_stdin) )], )
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 for_system_program__from_pgm_and_args( pgm_and_args: ProgramAndArguments) -> CommandSdv: program = string_sdvs.str_constant(pgm_and_args.program) arguments = list_sdvs.from_str_constants(pgm_and_args.arguments) additional_arguments = ArgumentsSdv.new_without_validation(arguments) return for_system_program(program).new_with_additional_arguments( additional_arguments)
def test_equals(self): test_cases = [ ( 'Plain string', string_sdvs.str_constant('string value'), empty_symbol_table(), ), ( 'String with reference', sdv_with_references([ SymbolReference( 'symbol_name', ReferenceRestrictionsOnDirectAndIndirect( ArbitraryValueWStrRenderingRestriction.of_any())) ]), empty_symbol_table(), ), ] for test_case_name, string_value, symbol_table in test_cases: assert isinstance(string_value, StringSdv), 'Type info for IDE' with self.subTest(msg='{}::with checked references::{}'.format( sut.equals_string_sdv.__name__, test_case_name)): assertion = sut.equals_string_sdv(string_value) assertion.apply_with_message(self, string_value, test_case_name)
def run_test(self): def resolve_validator_that_fails_pre_sds( symbols: SymbolTable) -> DdvValidator: return ConstantDdvValidator.of_pre_sds( asrt_text_doc.new_single_string_text_for_test('err msg')) referenced_system_program_sdv_w_invalid_arguments = program_sdvs.system_program( string_sdvs.str_constant('valid-system-program'), ArgumentsSdv(list_sdvs.from_str_constant('the arg'), [resolve_validator_that_fails_pre_sds])) valid_program_symbol = ProgramSymbolContext.of_sdv( 'VALID_PROGRAM', referenced_system_program_sdv_w_invalid_arguments) argument_syntax = ArgumentOfRichStringAbsStx.of_str('valid-arg') reference_and_additional_invalid_argument = self.source_to_parse( valid_program_symbol.name, [argument_syntax], ) # ACT & ASSERT # self.integration_checker( ).check__abs_stx__layouts__source_variants__wo_input( self.put, equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc, reference_and_additional_invalid_argument, arrangement_w_tcds(symbols=valid_program_symbol.symbol_table, ), MultiSourceExpectation.of_const( symbol_references=valid_program_symbol.references_assertion, primitive=asrt.anything_goes(), execution=ExecutionExpectation( validation=validation.ValidationAssertions. pre_sds_fails__w_any_msg(), )), )
def run_test(self): relativity_conf = relativity_options.conf_rel_any( self._missing_file_relativity) referenced_program_arguments = [ 'valid arg 1 of referenced', 'valid arg 2 of referenced' ] referenced_system_program_sdv = program_sdvs.system_program( string_sdvs.str_constant('valid-system-program'), ArgumentsSdv.new_without_validation( list_sdvs.from_str_constants(referenced_program_arguments))) valid_program_symbol = ProgramSymbolContext.of_sdv( 'VALID_PROGRAM', referenced_system_program_sdv) invalid_argument_syntax = ArgumentOfExistingPathAbsStx( relativity_conf.path_abs_stx_of_name('non-existing-file')) reference_and_additional_invalid_argument = self.source_to_parse( valid_program_symbol.name, [invalid_argument_syntax], ) # ACT & ASSERT # self.integration_checker( ).check__abs_stx__layouts__source_variants__wo_input( self.put, equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc, reference_and_additional_invalid_argument, arrangement_w_tcds(symbols=valid_program_symbol.symbol_table, ), MultiSourceExpectation.of_const( symbol_references=valid_program_symbol.references_assertion, primitive=asrt.anything_goes(), execution=ExecutionExpectation( validation=FAILING_VALIDATION_ASSERTION_FOR_PARTITION[ relativity_conf.directory_structure_partition], )), )
def _source_interpreter_with_system_command( cmd_and_args: List[str]) -> NameAndValue[Actor]: command_sdv = command_sdvs.for_system_program( string_sdvs.str_constant(cmd_and_args[0]), ArgumentsSdv(list_sdvs.from_str_constants(cmd_and_args[1:])), ) return NameAndValue(actors.SOURCE_INTERPRETER_ACTOR.singular_name, actor.actor(command_sdv))
def of_primitive_constant( contents: str, definition_source: Optional[ SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION, ) -> 'StringSourceSymbolValueContext': return StringSourceSymbolValueContext.of_sdv( sdvs.ConstantStringStringSourceSdv( string_sdvs.str_constant(contents)), definition_source, )
def all_strings() -> Tuple[BuiltinSymbol, ...]: return ( BuiltinSymbol( OS_LINE_SEP, ValueType.STRING, string_sdvs.str_constant(os.linesep), CustomSymbolDocumentation( "The {plain_string} that separates text lines on the {current_os} ({NL}, {WIN_LINE_SEP}, e.g.)." .format( NL=misc_texts.NEW_LINE_STRING_CONSTANT, WIN_LINE_SEP=formatting.string_constant('\\r\\n'), current_os=misc_texts.CURRENT_OS, plain_string=misc_texts.PLAIN_STRING, ), SectionContents.empty(), ), ), BuiltinSymbol( NEW_LINE, ValueType.STRING, string_sdvs.str_constant('\n'), CustomSymbolDocumentation( "The new-line character ({NL}), the line separator of {string:s} handled by {program_name}" .format( NL=misc_texts.NEW_LINE_STRING_CONSTANT, string=types.STRING_TYPE_INFO.name, program_name=program_info.PROGRAM_NAME.capitalize(), ), _TP.section_contents(_NEW_LINE_DESCRIPTION), ), ), BuiltinSymbol( TAB, ValueType.STRING, string_sdvs.str_constant('\t'), CustomSymbolDocumentation( 'The tab character.', SectionContents.empty(), ), ), )
def test_sdv_SHOULD_be_given_as_argument_to_sdv_assertion(self): # ARRANGE # actual_sdv = string_sdvs.str_constant('s') builtin_symbol = StringSymbolValueContext.of_sdv( actual_sdv, definition_source=None) assertion_that_is_expected_to_succeed = asrt.is_(actual_sdv) assertion_to_check = sut.matches_container( asrt.anything_goes(), assertion_that_is_expected_to_succeed, definition_source=asrt.anything_goes()) # ACT & ASSERT # assertion_to_check.apply_without_message(self, builtin_symbol.container)
def program_reference__w_argument_list() -> PgmAndArgsCase: system_program = 'the-system-program' system_program_sdv = program_sdvs.system_program(string_sdvs.str_constant(system_program)) system_program_symbol = ProgramSymbolContext.of_sdv('SYSTEM_PROGRAM_SYMBOL', system_program_sdv) return PgmAndArgsCase.wo_tcds( 'reference to program w argument list', pgm_and_args=ProgramOfSymbolReferenceAbsStx(system_program_symbol.name), symbols=[system_program_symbol], expected_command_driver=prim_asrt__constant( asrt_command.matches_system_program_command_driver( asrt.equals(system_program) )), )
def __init__( self, symbol_name: str, string_transformer_case: str_trans_validation_cases.ValidationCase, ): self._string_transformer_case = string_transformer_case additional_components = AccumulatedComponents.of_transformation( StringTransformerSdvReference( string_transformer_case.symbol_context.name)) program_w_transformer = program_sdvs.system_program( string_sdvs.str_constant('system-program')).new_accumulated( additional_components) self._program_symbol_context = ProgramSymbolContext.of_sdv( symbol_name, program_w_transformer)
def test_arbitrary_failure(self): # ARRANGE # actual_sdv = string_sdvs.str_constant('s') source_line = single_line_sequence(1, 'source line') actual_container = StringSymbolValueContext( actual_sdv, source_location.source_info_for_line_sequence( source_line)).container assertion_that_is_expected_to_fail = asrt.not_( equals_line_sequence(source_line)) assertion_to_check = sut.matches_container( value_type=asrt.anything_goes(), sdv=asrt.anything_goes(), definition_source=assertion_that_is_expected_to_fail) assert_that_assertion_fails(assertion_to_check, actual_container)
def runTest(self): # ARRANGE # symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL', program_sdvs.system_program( string_sdvs.str_constant('non-existing-system-program'))) program_line = args.symbol_ref_command_line(symbol.name).as_str # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [instr([program_line])], arrangement_w_tcds(symbol_table=symbol.symbol_table), Expectation.hard_error_from_execute( symbol_usages=symbol.usages_assertion), )
def test_source_line_SHOULD_be_given_as_argument_to_source_line_assertion( self): # ARRANGE # actual_sdv = string_sdvs.str_constant('s') source_line = single_line_sequence(1, 'source line') actual_container = StringSymbolValueContext( actual_sdv, source_location.source_info_for_line_sequence( source_line)).container assertion_that_is_expected_to_succeed = equals_line_sequence( source_line) assertion_to_check = sut.matches_container( value_type=asrt.anything_goes(), sdv=asrt.anything_goes(), definition_source=assertion_that_is_expected_to_succeed) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_container)
def __init__( self, fm_validation_case: fm_validation_cases.ValidationCase, symbol_name: str, ): self._expectation = fm_validation_case.expectation self._symbol_context = FilesConditionSymbolContext.of_sdv( symbol_name, files_conditions.new_constant([ (string_sdvs.str_constant('a_valid_file_name'), fm_sdvs.new_reference(fm_validation_case.symbol_context.name)) ]), ) self._symbol_table = SymbolContext.symbol_table_of_contexts([ self._symbol_context, fm_validation_case.symbol_context, ])
def test_reference_SHOULD_be_equal_to_referenced_value(self): # ARRANGE # file_name = 'the-file-name' referenced_sdv = files_conditions.new_constant([ (string_sdvs.str_constant(file_name), None) ]) expected = asrt_primitive.files_matches( {PurePosixPath(file_name): asrt.is_none}) symbol = FilesConditionSymbolContext.of_sdv('fc_symbol', referenced_sdv) source = args.SymbolReferenceWReferenceSyntax(symbol.name) # ACT & ASSERT # CHECKER.check__w_source_variants( self, source.as_arguments, None, arrangement_wo_tcds(symbol.symbol_table), Expectation( ParseExpectation( symbol_references=symbol.references_assertion), ExecutionExpectation(), prim_asrt__constant(expected)))
def test_validation_SHOULD_fail_WHEN_resolved_value_is_not_an_integer( self): the_instruction_environment = instruction_environment.fake_pre_sds_environment( ) test_cases = [ 'a', '1+x', 'a b', '10 a', '10a', '1.5', ] for custom_validator in [None, do_return(None)]: for resolved_value in test_cases: with self.subTest( custom_validator_is_none=str(custom_validator is None), resolved_value=resolved_value): # ARRANGE # sdv_to_check = sut.IntegerSdv( string_sdvs.str_constant(resolved_value), custom_validator) with self.subTest(tested_obect='sdv'): # ACT & ASSERT # with self.assertRaises(SvhValidationException) as cm: sdv_to_check.validate_pre_sds( the_instruction_environment. path_resolving_environment) asrt_text_doc.is_any_text().apply_without_message( self, cm.exception.err_msg) with self.subTest(tested_obect='value'): # ACT & ASSERT # value_to_check = sdv_to_check.resolve( the_instruction_environment.symbols) actual = value_to_check.validator( ).validate_pre_sds_if_applicable( the_instruction_environment.hds) asrt_text_doc.is_any_text().apply_without_message( self, actual)
def test_validation_SHOULD_succeed_WHEN_value_is_an_integer_and_custom_validator_succeeds( self): the_instruction_environment = instruction_environment.fake_pre_sds_environment( ) resolved_value = 16 resolved_string_value_cases = [ '16', '8 + 8', '2 * 2 * 2 * 2', ] custom_validator_cases = [ None, CustomValidator( value_that_makes_the_validation_succeed=resolved_value, error_message=validation.new_single_string_text_for_test( 'error message from custom validator')) ] for value_string in resolved_string_value_cases: for custom_validator in custom_validator_cases: sdv_to_check = sut.IntegerSdv( string_sdvs.str_constant(str(value_string)), custom_validator) with self.subTest( custom_validator_is_none=str(custom_validator is None), value_string=value_string): with self.subTest(tested_obect='sdv'): sdv_to_check.validate_pre_sds( the_instruction_environment. path_resolving_environment) with self.subTest(tested_obect='value'): value_to_check = sdv_to_check.resolve( the_instruction_environment.symbols) value_to_check.validator( ).validate_pre_sds_if_applicable( the_instruction_environment.hds) value_to_check.validator( ).validate_post_sds_if_applicable(fake_tcds())
def test_validation_SHOULD_fail_WHEN_custom_validator_fails(self): the_instruction_environment = instruction_environment.fake_pre_sds_environment( ) resolved_value = 1 # ARRANGE # error_message_from_custom_validator = 'error message' sdv_to_check = sut.IntegerSdv( string_sdvs.str_constant(str(resolved_value)), CustomValidator( value_that_makes_the_validation_succeed=resolved_value + 1, error_message=validation.new_single_string_text_for_test( error_message_from_custom_validator))) with self.subTest(tested_obect='sdv'): # ACT & ASSERT # with self.assertRaises(SvhValidationException) as cm: sdv_to_check.validate_pre_sds( the_instruction_environment.path_resolving_environment) err_msg_expectation = asrt_text_doc.is_string_for_test_that_equals( error_message_from_custom_validator) err_msg_expectation.apply_without_message(self, cm.exception.err_msg) with self.subTest(tested_obect='value'): # ACT & ASSERT # value_to_check = sdv_to_check.resolve( the_instruction_environment.symbols) actual = value_to_check.validator().validate_pre_sds_if_applicable( the_instruction_environment.hds) err_msg_expectation = asrt_text_doc.is_string_for_test_that_equals( error_message_from_custom_validator) err_msg_expectation.apply_without_message(self, actual)
def test_stdin_in_referenced_program_and_as_source_argument(self): # ARRANGE # str_src_contents__of_argument = 'the_str_src_contents__of_argument' str_src_contents__of_referenced_pgm = 'the_str_src_contents__of_program' stdin_argument_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str( str_src_contents__of_argument) stdin_sdv__of_referenced = str_src_sdvs.ConstantStringStringSourceSdv( string_sdvs.str_constant(str_src_contents__of_referenced_pgm)) referenced_program__system_program = 'the-system-program' referenced_program__sdv = program_sdvs.system_program( string_sdvs.str_constant(referenced_program__system_program), stdin=[stdin_sdv__of_referenced], ) referenced_program = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', referenced_program__sdv) symbols__symbol_table = [referenced_program] symbols__expected_references = [referenced_program] arguments_cases = [ NameAndValue( 'no arguments', [], ), NameAndValue( 'single argument', ['arg1'], ) ] for arguments_case in arguments_cases: with self.subTest(arguments=arguments_case.name): program_w_stdin = FullProgramAbsStx( ProgramOfSymbolReferenceAbsStx(referenced_program.name, [ ArgumentOfRichStringAbsStx.of_str(arg) for arg in arguments_case.value ]), stdin=stdin_argument_syntax, ) expected_primitive = asrt_pgm_val.matches_program( asrt_command.matches_command( driver=asrt_command. matches_system_program_command_driver( asrt.equals(referenced_program__system_program)), arguments=asrt.equals(arguments_case.value), ), stdin=asrt.matches_sequence([ asrt_str_src.matches__str( asrt.equals(str_src_contents__of_referenced_pgm)), asrt_str_src.matches__str( asrt.equals(str_src_contents__of_argument)), ]), transformer=asrt_pgm_val.is_no_transformation(), ) # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_stdin, arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols__symbol_table), ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( symbols__expected_references), primitive=expected_primitive, ))
def str_element(s: str) -> ElementSdv: return string_element(_string_sdvs.str_constant(s))
def test_stdin_in_referenced_program_and_as_source_argument(self): # ARRANGE # stdin_contents = 'str_src_contents' valid_stdin_sdv = sdvs.ConstantStringStringSourceSdv( string_sdvs.str_constant(stdin_contents)) valid_stdin_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str( stdin_contents) referenced_program__system_program = 'the-system-program' for validation_case in validation_cases.failing_validation_cases(): invalid_stdin_location_cases = [ ValidationCaseWAccumulation( 'in referenced symbol', sdv_of_referenced_program=validation_case.value. symbol_context.sdv, syntax_accumulated=valid_stdin_syntax, symbols=[], ), ValidationCaseWAccumulation( 'as source argument', sdv_of_referenced_program=valid_stdin_sdv, syntax_accumulated=validation_case.value.syntax, symbols=[validation_case.value.symbol_context], ), ] for invalid_stdin_location_case in invalid_stdin_location_cases: referenced_program__sdv = program_sdvs.system_program( string_sdvs.str_constant( referenced_program__system_program), stdin=[ invalid_stdin_location_case.sdv_of_referenced_program ]) referenced_program = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', referenced_program__sdv) program_w_stdin = FullProgramAbsStx( ProgramOfSymbolReferenceAbsStx(referenced_program.name, ), stdin=invalid_stdin_location_case.syntax_of_accumulated, ) symbols__all = [ validation_case.value.symbol_context, referenced_program ] symbols__expected_references = [ referenced_program ] + invalid_stdin_location_case.symbols # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_stdin, arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols__all), ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( symbols__expected_references), execution=ExecutionExpectation( validation=validation_case.value.assertion, ), primitive=asrt.anything_goes(), ), sub_test_identifiers={ 'validation': validation_case.name, 'invalid_stdin_location': invalid_stdin_location_case.name, })
def test_shell_program_via_symbol_reference(self): shell_command_line_of_referenced_program = 'initial shell command line' arguments_of_referenced_program = ['arg1', 'arg 2'] referenced_shell_program_sdv = program_sdvs.shell_program( string_sdvs.str_constant(shell_command_line_of_referenced_program), ArgumentsSdv.new_without_validation( list_sdvs.from_str_constants(arguments_of_referenced_program)), ) referenced_program_symbol = ProgramSymbolContext.of_sdv( 'SHELL_PROGRAM_REFERENCE', referenced_shell_program_sdv, ) string_argument_symbol = StringConstantSymbolContext( 'STRING_ARGUMENT_SYMBOL', 'string argument', ) list_argument_symbol = ListConstantSymbolContext( 'LIST_ARGUMENT_SYMBOL', ['list_arg_value_1', 'list arg value 2']) str_w_list_template = 'before{}after' str_w_list_ref = str_w_list_template.format( list_argument_symbol.name__sym_ref_syntax) expected_argument_strings = ( arguments_of_referenced_program + [string_argument_symbol.str_value] + list_argument_symbol.constant_list + [ str_w_list_template.format(' '.join( list_argument_symbol.constant_list)) ]) symbols = [ referenced_program_symbol, string_argument_symbol, list_argument_symbol ] syntax = ProgramOfSymbolReferenceAbsStx( referenced_program_symbol.name, [ ArgumentOfSymbolReferenceAbsStx(string_argument_symbol.name), ArgumentOfSymbolReferenceAbsStx(list_argument_symbol.name), ArgumentOfRichStringAbsStx.of_str(str_w_list_ref), ]) def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( command=asrt_command.equals_shell_command( command_line=shell_command_line_of_referenced_program, arguments=expected_argument_strings, ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), ) expectation = MultiSourceExpectation( symbol_references=asrt.matches_sequence([ referenced_program_symbol.reference_assertion, string_argument_symbol.reference_assertion__w_str_rendering, list_argument_symbol.reference_assertion__w_str_rendering, list_argument_symbol.reference_assertion__w_str_rendering, ]), primitive=expected_program, ) # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc, syntax, arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbols), ), expectation, )
def test_transformation_in_referenced_program_and_as_source_argument(self): # ARRANGE # transformer__in_referenced_program = StringTransformerPrimitiveSymbolContext( 'TRANSFORMER_IN_REFERENCED_PROGRAM', string_transformers.delete_everything()) referenced_program__system_program = 'the-system-program' referenced_program__sdv = program_sdvs.system_program( string_sdvs.str_constant(referenced_program__system_program), transformations=[transformer__in_referenced_program.reference_sdv]) referenced_program = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', referenced_program__sdv) transformer__in_source = StringTransformerPrimitiveSymbolContext( 'TRANSFORMER_IN_SOURCE', string_transformers.to_uppercase()) symbols__symbol_table = [ referenced_program, transformer__in_referenced_program, transformer__in_source ] symbols__expected_references = [ referenced_program, transformer__in_source ] arguments_cases = [ NameAndValue( 'no arguments', [], ), NameAndValue( 'single argument', ['arg1'], ) ] for arguments_case in arguments_cases: with self.subTest(arguments=arguments_case.name): program_w_transformer = FullProgramAbsStx( ProgramOfSymbolReferenceAbsStx(referenced_program.name, [ ArgumentOfRichStringAbsStx.of_str(arg) for arg in arguments_case.value ]), transformation=transformer__in_source.abstract_syntax) expected_primitive = asrt_pgm_val.matches_program( asrt_command.matches_command( driver=asrt_command. matches_system_program_command_driver( asrt.equals(referenced_program__system_program)), arguments=asrt.equals(arguments_case.value), ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt.matches_sequence([ asrt.is_(transformer__in_referenced_program.primitive), asrt.is_(transformer__in_source.primitive), ]), ) # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_transformer, arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols__symbol_table), ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( symbols__expected_references), primitive=expected_primitive, ))
def _arbitrary_sdv__string() -> Tuple[ValueType, DataTypeSdv]: return ValueType.STRING, string_sdvs.str_constant('a string (from <string value restriction>)')
def all_command_driver_types() -> Sequence[CommandDriverSdvCase]: # ARRANGE # system_program_name = 'system-program' executable_program_file_name = 'executable-program-file' executable_file_relativity = relativity_options.conf_rel_any( RelOptionType.REL_HDS_ACT) executable_file_ddv = path_ddvs.of_rel_option( executable_file_relativity.relativity_option, path_ddvs.constant_path_part(executable_program_file_name)) shell_initial_command = 'shell initial command' def mk_arrangement__executable_file(symbols: SymbolTable) -> Arrangement: return arrangement_w_tcds( symbols=symbols, tcds_contents=executable_file_relativity. populator_for_relativity_option_root( fs.DirContents( [fs.executable_file(executable_program_file_name)]))) def expected_command_driver__system_program( env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]: return asrt_command.matches_system_program_command_driver( asrt.equals(system_program_name)) def expected_command_driver__executable_file( env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]: return asrt_command.matches_executable_file_command_driver( asrt.equals( executable_file_ddv.value_of_any_dependency__d( env.tcds).primitive), ) def expected_command_driver__shell_cmd_line( env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]: return asrt_command.matches_shell_command_driver( asrt.equals(shell_initial_command)) return [ CommandDriverSdvCase( 'system program', command_driver=driver_sdvs.CommandDriverSdvForSystemProgram( string_sdvs.str_constant(system_program_name)), expected_command_driver=expected_command_driver__system_program, mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl ), ), CommandDriverSdvCase( 'executable program file', command_driver=driver_sdvs.CommandDriverSdvForExecutableFile( path_sdvs.constant(executable_file_ddv)), expected_command_driver=expected_command_driver__executable_file, mk_arrangement=mk_arrangement__executable_file, ), CommandDriverSdvCase( 'shell command line', command_driver=driver_sdvs.CommandDriverSdvForShell( string_sdvs.str_constant(shell_initial_command)), expected_command_driver=expected_command_driver__shell_cmd_line, mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl ), ), ]
def test_not_equals__string(self): # ARRANGE # expected = str_constant('expected string') actual = str_constant('actual string') # ACT & ASSERT # assert_that_assertion_fails(sut.equals_data_type_sdv(expected), actual)
def test_not_equals__different_symbol_types(self): # ARRANGE # expected = path_sdvs.constant(path_test_impl('file-name')) actual = str_constant('string value') # ACT & ASSERT # assert_that_assertion_fails(sut.equals_data_type_sdv(expected), actual)
def test_equals__string(self): # ARRANGE # value = str_constant('string') # ACT & ASSERT # sut.equals_data_type_sdv(value).apply_without_message(self, value)