def failing_validation_cases__multi_exe( symbol_name: str = 'files_matcher_symbol' ) -> Sequence[NExArr[PrimAndExeExpectation, Arrangement]]: return [ NExArr( case.name, PrimAndExeExpectation.of_exe(validation=case.value.expectation, ), arrangement_wo_tcds( symbols=case.value.symbol_context.symbol_table, ), ) for case in failing_validation_cases(symbol_name) ]
def test_file_matcher_SHOULD_be_parsed_as_full_expression(self): # ARRANGE # file_name = 'file-name' fm_1 = FileMatcherSymbolContextOfPrimitiveConstant( 'file_matcher_1', False) fm_2 = FileMatcherSymbolContextOfPrimitiveConstant( 'file_matcher_2', True) symbols = [fm_1, fm_2] arguments = args.FilesCondition([ args.FileCondition( file_name, fm_args.disjunction([fm_1.argument, fm_2.argument])) ]) expected_result = fm_1.result_value or fm_2.result_value # ACT & ASSERT # CHECKER.check__w_source_variants( self, arguments=arguments.as_arguments, input_=None, arrangement=arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbols)), expectation=Expectation( ParseExpectation(symbol_references=SymbolContext. references_assertion_of_contexts(symbols)), primitive=prim_asrt__constant( asrt_primitive.files_matches({ PurePosixPath(file_name): asrt_primitive.is_matcher_that_gives(expected_result) }))))
def test_string_symbol_reference(self): for other_valid_file_spec_case in OTHER_VALID_FILE_SPECS: for file_name_case in INVALID_FILE_NAMES: file_name_symbol = StringSymbolContext.of_constant( 'FILE_NAME_SYMBOL', file_name_case.value, default_restrictions=asrt_rest.is__string__w_all_indirect_refs_are_strings(), ) file_name_abs_stx = file_name_symbol.abstract_syntax for file_spec_case in file_type_and_contents_variants(file_name_abs_stx): integration_check.CHECKER.check__abs_stx__layout__std_source_variants( self, LiteralFilesSourceAbsStx(other_valid_file_spec_case.value + [file_spec_case.value]), models.empty(), arrangement_wo_tcds( symbols=file_name_symbol.symbol_table ), MultiSourceExpectation( symbol_references=file_name_symbol.references_assertion, execution=ExecutionExpectation( validation=ValidationAssertions.pre_sds_fails__w_any_msg() ) ), sub_test_identifiers={ 'file-name': file_name_case.name, 'type-and-contents': file_spec_case.name, 'other-valid-file-spec': other_valid_file_spec_case.name, } )
def test_one_file_wo_matcher_and_one_w_matcher(self): # ARRANGE # file_name_w_matcher = 'file-name-with-matcher' file_name_wo_matcher = 'file-name-without-matcher' fm_symbol = 'file_matcher' arguments = args.FilesCondition([ args.FileCondition(file_name_wo_matcher), args.FileCondition( file_name_w_matcher, fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)), ]) # ACT & ASSERT # CHECKER.check_multi__w_source_variants( self, arguments.as_arguments, asrt.matches_sequence([is_reference_to_file_matcher(fm_symbol)]), None, [ NExArr( 'FileMatcher should give {}'.format(expected_result), PrimAndExeExpectation.of_prim__const( asrt_primitive.files_matches({ PurePosixPath(file_name_wo_matcher): asrt.is_none, PurePosixPath(file_name_w_matcher): asrt_primitive.is_matcher_that_gives( expected_result) })), arrangement_wo_tcds( FileMatcherSymbolContext.of_primitive_constant( fm_symbol, expected_result).symbol_table), ) for expected_result in [False, True] ])
def _check_case(self, invalid_file_spec: FileSpecAbsStx, contents_case: ContentsCase, validation_case: NameAndValue[ValidationCaseWSymbolContextAndAssertion], ): symbol_context = validation_case.value.symbol_context integration_check.CHECKER.check__abs_stx__layout__std_source_variants( self, LiteralFilesSourceAbsStx(contents_case.other_valid_file_spec.value + [invalid_file_spec]), models.empty(), arrangement_wo_tcds( symbols=symbol_context.symbol_table ), MultiSourceExpectation( symbol_references=symbol_context.references_assertion, execution=ExecutionExpectation( validation=validation_case.value.assertion ) ), sub_test_identifiers={ 'validation': validation_case.name, 'other-valid-file-spec': contents_case.other_valid_file_spec.name, 'modification-type': contents_case.modification_type, } )
def test_transformer_component(self): checker = integration_check.checker__w_arbitrary_file_relativities() for validation_case in failing_validation_cases(): transformer_symbol = validation_case.value.symbol_context program_syntax = program_abs_stx.FullProgramAbsStx( program_abs_stx.ProgramOfSystemCommandLineAbsStx.of_str( 'a-system-command'), transformation=transformer_symbol.abstract_syntax, ) string_source_syntax = string_source_abs_stx.StringSourceOfProgramAbsStx( ProcOutputFile.STDOUT, program_syntax, ignore_exit_code=False, ) with self.subTest(validation_case.name): checker.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, OptionallyOnNewLine(string_source_syntax), arrangement_wo_tcds( symbols=transformer_symbol.symbol_table), MultiSourceExpectation( symbol_references=transformer_symbol. references_assertion, execution=ExecutionExpectation( validation=validation_case.value.expectation)))
def runTest(self): # ARRANGE # for result in [False, True]: string_matcher = StringMatcherSymbolContextOfPrimitiveConstant( 'STRING_MATCHER', result, ) # ACT & ASSERT # with self.subTest(string_matcher_result=result): integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, arguments=lm_args.Contents( sm_args2.SymbolReferenceWReferenceSyntax( string_matcher.name), ).as_arguments, input_=models.ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=string_matcher.symbol_table, ), expectation=Expectation( ParseExpectation(symbol_references=string_matcher. references_assertion), ExecutionExpectation( main_result=asrt_matching_result. matches_value__w_header( asrt.equals(string_matcher.result_value), header=TRACE_HEADER_EXPECTATION, ))), )
def runTest(self): string_matcher = StringMatcherSymbolContextOfPrimitiveConstant( 'STRING_MATCHER', True, ) after_bin_op = 'after bin op' integration_check.CHECKER__PARSE_SIMPLE.check( self, source=lm_args.Contents( sm_args2.conjunction([ sm_args2.SymbolReference(string_matcher.name), sm_args2.Custom(after_bin_op), ]), ).as_remaining_source, input_=models.ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=string_matcher.symbol_table, ), expectation=Expectation( ParseExpectation( source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=logic.AND_OPERATOR_NAME + ' ' + after_bin_op), symbol_references=string_matcher.references_assertion), ExecutionExpectation( main_result=asrt_matching_result.matches_value__w_header( asrt.equals(string_matcher.result_value), header=TRACE_HEADER_EXPECTATION, ))), )
def test_glob_pattern(self): match_anything_glob_pattern_string_symbol = StringSymbolContext.of_constant( 'glob_pattern_symbol', '*', default_restrictions=glob_pattern.is_reference_restrictions__glob_pattern_string() ) arguments = self.conf.arguments( NameGlobPatternVariant(match_anything_glob_pattern_string_symbol.name__sym_ref_syntax) ) integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, arguments= arguments.as_arguments, input_= ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=match_anything_glob_pattern_string_symbol.symbol_table ), expectation=Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ match_anything_glob_pattern_string_symbol.reference_assertion, ]), ), ExecutionExpectation( main_result=asrt_matching_result.matches_value__w_header( asrt.equals(True), asrt.equals(self.conf.node_name) ) ), ) )
def runTest(self): # ARRANGE # for validation_case in validation_cases.failing_validation_cases(): for preserve_new_lines in [False, True]: syntax = ReplaceRegexAbsStx.of_str( 'valid_regex', 'valid_replacement', preserve_new_lines=preserve_new_lines, lines_filter=validation_case.value.matcher_abs_stx, ) line_matcher_symbol_context = validation_case.value.symbol_context # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__abs_stx__layout__std_source_variants( self, syntax, model_constructor.arbitrary(self), arrangement_wo_tcds( symbols=line_matcher_symbol_context.symbol_table), MultiSourceExpectation( symbol_references=line_matcher_symbol_context. references_assertion, execution=ExecutionExpectation( validation=validation_case.value.expectation, )), sub_test_identifiers={ 'preserve_new_lines': preserve_new_lines, 'validation': validation_case.name, })
def runTest(self): # ARRANGE # program_ref_case = pgm_and_args_cases.program_reference__w_argument_list() def expected_program(env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( asrt_command.matches_command( driver=program_ref_case.expected_command_driver(env), arguments=asrt.is_empty_sequence, ), stdin=asrt_pgm_val.is_no_stdin(), 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, OptionallyOnNewLine(WithinParensAbsStx(program_ref_case.pgm_and_args, end_paren_on_separate_line=False)), arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts(program_ref_case.symbols), ), MultiSourceExpectation( symbol_references=SymbolContext.references_assertion_of_contexts(program_ref_case.symbols), primitive=expected_program, ) )
def runTest(self): # ARRANGE # for case in validation_cases.failing_validation_cases(): line_matcher_symbol_context = case.value.symbol_context line_matcher_arg = lm_args.SymbolReference(line_matcher_symbol_context.name) arguments = st_args.syntax_for_filter_transformer(str(line_matcher_arg)) with self.subTest(case.name): # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, []), arrangement_wo_tcds( symbols=line_matcher_symbol_context.symbol_table ), Expectation( ParseExpectation( symbol_references=line_matcher_symbol_context.references_assertion ), ExecutionExpectation( validation=case.value.expectation, ) ) )
def test_that_symbols_from_arrangement_exist_in_environment(self): symbol = StringConstantSymbolContext('symbol_name', 'the symbol value') symbol_table_of_arrangement = symbol.symbol_table expected_symbol_table = symbol.symbol_table expectation = asrt_sym.equals_symbol_table(expected_symbol_table) sdv_that_checks_symbols = MatcherSdvThatAssertsThatSymbolsAreAsExpected(self, expectation) cases = [ NameAndValue('arrangement without tcds', arrangement_wo_tcds( symbol_table_of_arrangement) ), NameAndValue('arrangement with tcds', arrangement_w_tcds( symbols=symbol_table_of_arrangement) ), ] for arrangement in cases: with self.subTest(arrangement.name): self._check___single_and_multi( utils.single_line_arguments(), ARBITRARY_MODEL, _constant_line_matcher_type_parser_of_matcher_sdv(sdv_that_checks_symbols), arrangement.value, Expectation(), )
def test_single_file_name_with_matcher(self): # ARRANGE # file_name = 'file-name' fm_symbol = 'file_matcher' cases = [ NameAndValue( 'single name entry', args.FilesCondition([ args.FileCondition( file_name, fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)) ]), ), NameAndValue( 'two entries with same file name, 1st without and 2nd with FileMatcher', args.FilesCondition([ args.FileCondition(file_name), args.FileCondition( file_name, fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)), ]), ), NameAndValue( 'two entries with same file name, 1st with and 2nd without FileMatcher', args.FilesCondition([ args.FileCondition( file_name, fm_args.SymbolReferenceWReferenceSyntax(fm_symbol)), args.FileCondition(file_name), ]), ), ] # ACT & ASSERT # for case in cases: with self.subTest(case.name): CHECKER.check_multi__w_source_variants( self, case.value.as_arguments, asrt.matches_sequence( [is_reference_to_file_matcher(fm_symbol)]), None, [ NExArr( 'FileMatcher should give {}'.format( expected_result), PrimAndExeExpectation.of_prim__const( asrt_primitive.files_matches({ PurePosixPath(file_name): asrt_primitive.is_matcher_that_gives( expected_result) })), arrangement_wo_tcds( FileMatcherSymbolContext.of_primitive_constant( fm_symbol, expected_result).symbol_table), ) for expected_result in [False, True] ])
def check_with_source_variants(put: unittest.TestCase, arguments: Arguments, model_constructor: ModelConstructor, arrangement: Optional[SymbolTable] = None, expectation: Expectation = Expectation()): CHECKER.check__w_source_variants( put, arguments, model_constructor, arrangement_wo_tcds(arrangement), expectation, )
def check(put: unittest.TestCase, source: ParseSource, model_constructor: ModelConstructor, arrangement: Optional[SymbolTable] = None, expectation: Expectation = Expectation()): CHECKER.check( put, source, model_constructor, arrangement_wo_tcds(arrangement), expectation, )
def runTest(self): cases = [ NameAndValue( 'just space', ' ', ), NameAndValue( 'just space, w new-line', ' \n ', ), NameAndValue( 'just a separator', '{SEPARATOR}', ), NameAndValue( 'just two separators', '{SEPARATOR}{SEPARATOR}', ), NameAndValue( 'too many separators 1', '{SEPARATOR}1{SEPARATOR}', ), NameAndValue( 'too many separators 2', '1{SEPARATOR}{SEPARATOR}', ), NameAndValue( 'too many separators 3', '1{SEPARATOR}2{SEPARATOR}', ), ] for case in cases: with self.subTest(case.name, expr=case.value): range_expr_symbol = StringSymbolContext.of_constant( 'RANGE_SYMBOL', case.value, default_restrictions= IS_RANGE_EXPR_STR_REFERENCE_RESTRICTIONS, ) arguments = args.filter_line_nums( range_args.CustomRange( range_expr_symbol.name__sym_ref_syntax)) integration_check.CHECKER__PARSE_SIMPLE.check( self, arguments.as_remaining_source, model_constructor.arbitrary(self), arrangement_wo_tcds( symbols=range_expr_symbol.symbol_table, ), Expectation( ParseExpectation(symbol_references=range_expr_symbol. references_assertion, ), ExecutionExpectation(validation=ValidationAssertions. pre_sds_fails__w_any_msg(), ), ))
def _check_cases( self, cases: Sequence[NArrEx[ArgumentElementsRenderer, Assertion[IntIntervalWInversion]]]): for case in cases: with self.subTest(case.name, arguments=case.arrangement.as_str): integration_check.CHECKER__PARSE_SIMPLE.check( self, args.LineNum2(case.arrangement).as_remaining_source, models.ARBITRARY_MODEL, arrangement_wo_tcds(), Expectation(primitive=prim_asrt__constant( IntervalOfMatcherAssertion(case.expectation, ))), )
def wo_tcds(name: str, pgm_and_args: PgmAndArgsAbsStx, expected_command_driver: Callable[[AssertionResolvingEnvironment], Assertion[CommandDriver]], symbols: Sequence[SymbolContext] = (), ) -> 'PgmAndArgsCase': return PgmAndArgsCase( name, pgm_and_args, expected_command_driver, symbols, tcds_populators.empty(), lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl) )
def test_shell_program(self): argument_string_template = 'first {string_symbol} between {list_symbol} after' string_argument_symbol = StringConstantSymbolContext( 'STRING_ARGUMENT_SYMBOL', 'string argument', ) list_argument_symbol = ListConstantSymbolContext( 'LIST_ARGUMENT_SYMBOL', ['list_arg_value_1', 'list arg value 2']) symbols = [string_argument_symbol, list_argument_symbol] command_line_syntax_str = argument_string_template.format( string_symbol=string_argument_symbol.name__sym_ref_syntax, list_symbol=list_argument_symbol.name__sym_ref_syntax, ) command_line_str = argument_string_template.format( string_symbol=string_argument_symbol.str_value, list_symbol=' '.join(list_argument_symbol.constant_list), ) syntax = ProgramOfShellCommandLineAbsStx( StringLiteralAbsStx(command_line_syntax_str)) def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( command=asrt_command.equals_shell_command( command_line=command_line_str, arguments=[], ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), ) expectation = MultiSourceExpectation( symbol_references=asrt.matches_sequence([ string_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_without_reference_to_existing_file(self): # ARRANGE # abstract_syntax = RawSystemCommandLineAbsStx.of_str( 'program_name', [ArgumentOfRichStringAbsStx.of_str('argument-that-is-not-a-file')]) # 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, abstract_syntax, arrangement_wo_tcds(), MultiSourceExpectation(execution=ExecutionExpectation( validation=validation.ValidationAssertions.all_passes())), )
def test_failing_validation(self): # ARRANGE # symbol_not_an_int = StringSymbolContext.of_constant('SYMBOL_NOT_AN_INT', 'notAnInt') cases = [ ValidationCase(comparators.EQ.name + ' not a number', remaining_source(comparators.EQ.name + ' notANumber'), source_assertion= assert_source(is_at_eol=asrt.is_true), ), ValidationCase(comparators.EQ.name + ' not an int', remaining_source(comparators.EQ.name + ' 0.5'), source_assertion= assert_source(is_at_eol=asrt.is_true), ), ValidationCase(comparators.EQ.name + ' invalid expression syntax', remaining_source(comparators.EQ.name + ' (1'), source_assertion= assert_source(is_at_eol=asrt.is_true), ), ValidationCase(comparators.EQ.name + ' with symbol references', remaining_source( '== {}'.format(symbol_reference_syntax_for_name(symbol_not_an_int.name)) ), source_assertion= assert_source(is_at_eol=asrt.is_true), references=asrt.matches_singleton_sequence( symbol_not_an_int.reference_assertion__string__w_all_indirect_refs_are_strings), symbols=symbol_not_an_int.symbol_table ), ] for case in cases: with self.subTest(case.name): integration_check.CHECKER__PARSE_SIMPLE.check( self, case.source, input_=integration_check.ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=case.symbols, ), expectation=Expectation( ParseExpectation( source=case.source_assertion, symbol_references=case.references, ), ExecutionExpectation( validation=validation.ValidationAssertions.pre_sds_fails__w_any_msg(), ), ) )
def test_application(self): conf = self.configuration for value in [False, True]: conf.checker_for_parser_of_full_expr().check__w_source_variants( self, arguments=matcher_argument.Constant(value).as_arguments, input_=conf.arbitrary_model, arrangement=arrangement_wo_tcds(), expectation=Expectation(execution=ExecutionExpectation( main_result=asrt_matching_result.matches( asrt.equals(value), trace=_utils.trace_equals( tree.Node.leaf(logic.CONSTANT_MATCHER, value, ( tree.StringDetail(logic.BOOLEANS[value]), )))))))
def __init__(self, name: str, pgm_and_args: PgmAndArgsAbsStx, expected_command_driver: Callable[[AssertionResolvingEnvironment], Assertion[CommandDriver]], symbols: Sequence[SymbolContext] = (), tcds: TcdsPopulator = tcds_populators.empty(), mk_arrangement: Callable[[SymbolTable], Arrangement] = lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl), ): self.name = name self.pgm_and_args = pgm_and_args self.symbols = symbols self.expected_command_driver = expected_command_driver self.tcds = tcds self.mk_arrangement = mk_arrangement
def test_tcds_SHOULD_not_exist_WHEN_flag_for_not_creating_tcds_is_given(self): def make_primitive(tcds: TestCaseDs) -> MatcherWTrace[int]: return constant.MatcherWithConstantResult(True) self._check___single_and_multi( utils.single_line_arguments(), ARBITRARY_MODEL, _constant_line_matcher_type_parser_of_matcher_ddv( sdv_ddv.MatcherDdvFromPartsTestImpl( make_primitive, ValidatorThatAssertsThatTcdsDirsDoesNotDenoteExistingDirectories(self), ) ), arrangement_wo_tcds(), Expectation(), )
def test_two_different_files_w_matcher(self): # ARRANGE # file_name__constant = 'file-name-with-constant-matcher' file_name__w_variations = 'file-name-with-matcher-with-variations' fm__constant = FileMatcherSymbolContextOfPrimitiveConstant( 'fm_constant', True) fm__w_variations = 'fm_w_variations' arguments = args.FilesCondition([ args.FileCondition( file_name__constant, fm_args.SymbolReferenceWReferenceSyntax(fm__constant.name)), args.FileCondition( file_name__w_variations, fm_args.SymbolReferenceWReferenceSyntax(fm__w_variations)), ]) # ACT & ASSERT # CHECKER.check_multi__w_source_variants( self, arguments.as_arguments, asrt.matches_sequence([ fm__constant.reference_assertion, is_reference_to_file_matcher(fm__w_variations), ]), None, [ NExArr( 'FileMatcher with variations should give {}'.format( expected_result_of_matcher_w_variations), PrimAndExeExpectation.of_prim__const( asrt_primitive.files_matches({ PurePosixPath(file_name__constant): asrt_primitive.is_matcher_that_gives( fm__constant.result_value), PurePosixPath(file_name__w_variations): asrt_primitive.is_matcher_that_gives( expected_result_of_matcher_w_variations) })), arrangement_wo_tcds( SymbolContext.symbol_table_of_contexts([ fm__constant, FileMatcherSymbolContext.of_primitive_constant( fm__w_variations, expected_result_of_matcher_w_variations), ])), ) for expected_result_of_matcher_w_variations in [False, True] ])
def check__w_max_as_lines_invocations__wo_max_lines_from_iter( put: unittest.TestCase, range_expr: Sequence[range_args.Range], input_and_expected: InputAndExpected, max_as_lines_invocations: int = 1, ): arguments = args.filter_line_nums__multi(range_expr) integration_check.CHECKER__PARSE_SIMPLE__WO_IMPLICIT_MODEL_EVALUATION.check( put, arguments.as_remaining_source, model_constructor.of_lines__w_max_invocations( put, input_and_expected.input, max_as_lines_invocations, ), arrangement_wo_tcds(), expectation_of_successful_execution__check_only_as_lines( symbol_references=asrt.is_empty_sequence, output_lines=input_and_expected.expected, ))
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_back_slash_should_not_separate_parts(self): # ARRANGE # file_name_with_back_slash = '\\'.join(FILE_NAME_PARTS) expected_file_names = { PurePosixPath(file_name_with_back_slash): asrt.is_none } source = args.FilesCondition([ args.FileCondition( surrounded_by_hard_quotes(file_name_with_back_slash)), ]) # ACT & ASSERT # CHECKER.check__w_source_variants( self, source.as_arguments, None, arrangement_wo_tcds(), Expectation( ParseExpectation(), ExecutionExpectation(), primitive=prim_asrt__constant( asrt_primitive.files_matches(expected_file_names))))
def runTest(self): invalid_int_expr = range_args.SingleLineRange('1.5') valid_int_expr = range_args.SingleLineRange('1') range_expression_cases = [ [invalid_int_expr, valid_int_expr, valid_int_expr], [valid_int_expr, invalid_int_expr, valid_int_expr], [valid_int_expr, valid_int_expr, invalid_int_expr], ] for range_expressions in range_expression_cases: with self.subTest([str(r) for r in range_expressions]): integration_check.CHECKER__PARSE_SIMPLE.check( self, args.filter_line_nums__multi( range_expressions).as_remaining_source, model_constructor.arbitrary(self), arrangement_wo_tcds(), Expectation( ParseExpectation(), ExecutionExpectation(validation=ValidationAssertions. pre_sds_fails__w_any_msg(), ), ))