def runTest(self):
# ARRANGE #
string_transformer_argument = ab.binary_operator(
names.SEQUENCE_OPERATOR_NAME,
[
ab.symbol_reference('TRANSFORMER_SYMBOL_1'),
ab.symbol_reference('TRANSFORMER_SYMBOL_2'),
],
)
arguments = args2.Transformed(
str(string_transformer_argument),
args2.SymbolReferenceWReferenceSyntax('STRING_MATCHER_SYMBOL'))
cases = [
NameAndValue(
'parse STRING-MATCHER as simple expr',
sut.parsers().simple,
),
NameAndValue(
'parse STRING-MATCHER as full expr',
sut.parsers().full,
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
with self.assertRaises(
SingleInstructionInvalidArgumentException):
case.value.parse(arguments.as_remaining_source)
def _check_variants_with_expectation_type(
self,
args_variant_constructor: InstructionArgumentsVariantConstructor):
for expectation_type in ExpectationType:
with self.subTest(expectation_type=expectation_type):
args_variant = args_variant_constructor.construct(
expectation_type)
with self.assertRaises(
SingleInstructionInvalidArgumentException):
sut.parsers().full.parse(
test_configuration.source_for(args_variant))
def _check_variants_with_expectation_type_and_any_or_every(
self, args_variant_constructor: tr.
InstructionArgumentsConstructorForExpTypeAndQuantifier):
for expectation_type in ExpectationType:
for quantifier in Quantifier:
with self.subTest(expectation_type=expectation_type,
any_or_every_keyword=quantifier):
args_variant = args_variant_constructor.construct(
expectation_type, quantifier)
with self.assertRaises(
SingleInstructionInvalidArgumentException):
sut.parsers().full.parse(
test_configuration.source_for(args_variant))
def parse(
token_parser: TokenParser
) -> AssertionPart[ComparisonActualFile, StringSource]:
string_matcher_sdv = parsers().full.parse_from_token_parser(token_parser)
return assertion_part.compose(
ConstructFileToCheckAssertionPart(),
StringMatcherAssertionPart(string_matcher_sdv))
def parse(
self,
fs_location_info: FileSystemLocationInfo,
token_parser: TokenParser,
) -> SymbolDependentValue:
return parse_string_matcher.parsers().full.parse_from_token_parser(
token_parser)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
parser = sut.parsers().full
for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES:
for maybe_full_match in FULL_MATCH_OPTION_ALTERNATIVES:
with self.subTest(maybe_with_transformer_option=maybe_with_transformer_option,
maybe_full_match=maybe_full_match):
source = test_configuration.source_for(
args('{maybe_with_transformer_option} {maybe_not} {matches} {maybe_full_match}',
maybe_with_transformer_option=maybe_with_transformer_option,
maybe_full_match=maybe_full_match,
maybe_not=maybe_not.nothing__if_positive__not_option__if_negative),
)
with self.assertRaises(SingleInstructionInvalidArgumentException):
parser.parse(source)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
parser = sut.parsers().full
for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES:
with self.subTest(maybe_with_transformer_option=maybe_with_transformer_option):
source = test_configuration.source_for(
args('{maybe_with_transformer_option} {maybe_not}',
maybe_with_transformer_option=maybe_with_transformer_option,
maybe_not=maybe_not.nothing__if_positive__not_option__if_negative),
)
with self.assertRaises(SingleInstructionInvalidArgumentException) as cm:
parser.parse(source)
assert_is_single_instruction_invalid_argument_exception().apply_with_message(
self,
cm.exception,
'exception from parser'
)
def _check_expectation_variants(
self, common_arguments: CommonArgumentsConstructor,
line_matcher: str,
expected_symbols: Assertion[Sequence[SymbolReference]]):
parser = sut.parsers().full
for expectation_type in ExpectationType:
for quantifier in Quantifier:
with self.subTest(expectation_type=expectation_type,
quantifier=quantifier.name):
arguments_for_implicit_file = arguments_building.ImplicitActualFileArgumentsConstructor(
common_arguments,
arguments_building.
LineMatchesAssertionArgumentsConstructor(
quantifier, line_matcher)).apply(expectation_type)
source = test_configuration.arguments_for(
arguments_for_implicit_file).as_remaining_source
sdv = parser.parse(source)
assert isinstance(sdv, MatcherSdv) # Sanity check
expected_symbols.apply_without_message(
self, sdv.references)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
# ARRANGE #
cases = [
NameAndValue('illegal option',
option_syntax.long_option_syntax('this-is-an-illegal-option')),
NameAndValue('illegal argument',
'this-is-an-illegal-argument'),
]
parser = sut.parsers().full
for case in cases:
with self.subTest(case_name=case.name):
source = test_configuration.source_for(
args('{illegal_argument} {maybe_not} {empty}',
illegal_argument=case.value,
maybe_not=maybe_not.nothing__if_positive__not_option__if_negative),
)
with self.assertRaises(SingleInstructionInvalidArgumentException) as cm:
parser.parse(source)
assert_is_single_instruction_invalid_argument_exception().apply_with_message(
self,
cm.exception,
'exception from parser'
)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
cases = [
NameAndValue('illegal option',
'this-is-an-illegal-argument'),
]
parser = sut.parsers().full
for case in cases:
for maybe_with_transformer_option in TRANSFORMER_OPTION_ALTERNATIVES:
with self.subTest(illegal_check=case.name,
maybe_with_transformer_option=maybe_with_transformer_option):
source = test_configuration.source_for(
args('{maybe_with_transformer_option} {maybe_not} {illegal_check}',
maybe_with_transformer_option=maybe_with_transformer_option,
maybe_not=maybe_not.nothing__if_positive__not_option__if_negative,
illegal_check=case.value,
),
)
with self.assertRaises(SingleInstructionInvalidArgumentException) as cm:
parser.parse(source)
assert_is_single_instruction_invalid_argument_exception().apply_with_message(
self,
cm.exception,
'exception from parser'
)
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess):
# ARRANGE #
string_to_prepend = '.'
initial_model_contents = '\n'
model_after_2_transformations = ''.join(
[string_to_prepend, string_to_prepend, initial_model_contents])
initial_model = model_constructor.of_str(self, initial_model_contents)
equals_expected_matcher = StringMatcherSymbolContext.of_primitive(
'EQUALS_EXPECTED',
EqualsMatcherTestImpl(model_after_2_transformations))
prepend_transformer_symbol = StringTransformerSymbolContext.of_primitive(
'PREPEND_TRANSFORMER',
string_transformers.of_line_transformer__w_preserved_line_ending(
'prepend to each line', lambda line:
(line + string_to_prepend)))
prepend_trans_arg = str_trans_syntax.syntax_for_transformer_option(
prepend_transformer_symbol.name)
trans_and_eq_expected_matcher_source = remaining_source(
'{prepend_trans_arg} {equals_expected_matcher}'.format(
prepend_trans_arg=prepend_trans_arg,
equals_expected_matcher=equals_expected_matcher.name,
))
# ACT & ASSERT #
parser = sut.parsers().full
prepend_and_equals_expected_matcher_sdv = parser.parse(
trans_and_eq_expected_matcher_source)
prepend_and_equals_expected_matcher = StringMatcherSymbolContext.of_sdv(
'PREPEND_AND_EQUALS_EXPECTED',
prepend_and_equals_expected_matcher_sdv)
symbols = SymbolContext.symbol_table_of_contexts([
equals_expected_matcher,
prepend_transformer_symbol,
prepend_and_equals_expected_matcher,
])
expected_symbol_references = asrt.matches_sequence([
is_reference_to_string_transformer(
prepend_transformer_symbol.name),
is_reference_to_string_matcher(
prepend_and_equals_expected_matcher.name),
])
self._check_with_source_variants(
test_configuration.arguments_for(
args(
'{prepend_trans_arg} {maybe_not} {prepend_and_equals_expected_matcher}',
prepend_trans_arg=prepend_trans_arg,
maybe_not=maybe_not.
nothing__if_positive__not_option__if_negative,
prepend_and_equals_expected_matcher=
prepend_and_equals_expected_matcher.name)), initial_model,
arrangement_w_tcds(symbols=symbols),
Expectation(
ParseExpectation(
symbol_references=expected_symbol_references, ),
ExecutionExpectation(
main_result=maybe_not.pass__if_positive__fail__if_negative,
),
))
def parsers_for_expr_on_any_line(
self) -> GrammarParsers[MatcherSdv[StringSource]]:
return parse_string_matcher.parsers()
def _parse_regular_file_contents(token_parser: TokenParser) -> FileMatcherSdv:
string_matcher = parse_string_matcher.parsers().simple.parse_from_token_parser(token_parser)
return regular_file_contents.sdv(string_matcher)
from exactly_lib.impls.types.string_matcher import parse_string_matcher
from exactly_lib_test.impls.types.logic.test_resources import integration_check
from exactly_lib_test.impls.types.matcher.test_resources.matcher_checker import \
MatcherPropertiesConfiguration
CHECKER__PARSE_FULL = integration_check.IntegrationChecker(
parse_string_matcher.parsers().full,
MatcherPropertiesConfiguration(),
False,
)
CHECKER__PARSE_SIMPLE = integration_check.IntegrationChecker(
parse_string_matcher.parsers().simple,
MatcherPropertiesConfiguration(),
False,
)
def parse(self, token_parser: TokenParser) -> LineMatcherSdv:
from exactly_lib.impls.types.string_matcher import parse_string_matcher
string_matcher_parser = parse_string_matcher.parsers(False).simple
contents_matcher = string_matcher_parser.parse_from_token_parser(
token_parser)
return sdv(contents_matcher)