Esempio n. 1
0
 def _test_case__sym_ref_or_string_parser(self, parser: ParserFromTokens,
                                          tc: TC):
     # ARRANGE #
     token_stream = TokenStream(tc.source_string)
     token_parser = TokenParser(token_stream)
     expected_fragments = tc.expectation.fragments
     head_is_plain = TokenStream(tc.source_string).head.is_plain
     assertion_on_value = (_EqualsEitherOfSymbolName(
         expected_fragments[0].value)
                           if head_is_plain and len(expected_fragments) == 1
                           and expected_fragments[0].is_symbol else
                           _EqualsEitherOfStringSdv(expected_fragments))
     # ACT #
     actual = parser.parse(token_parser)
     # ASSERT #
     tc.expectation.token_stream.apply_with_message(self, token_stream,
                                                    'token_stream')
     assertion_on_value.apply_with_message(self, actual, 'fragment')
 def test_head_token_pass(self):
     # ARRANGE #
     token_stream = TokenStream('a_token')
     passing_token_assertion = asrt.sub_component('token_type',
                                                  Token.is_quoted.fget,
                                                  asrt.is_false)
     assertion = sut.assert_token_stream(head_token=passing_token_assertion)
     # ACT & ASSERT #
     assertion.apply_without_message(self, token_stream)
 def test_look_ahead_state_pass(self):
     # ARRANGE #
     assertion = sut.assert_token_stream(look_ahead_state=asrt.is_(LookAheadState.NULL))
     # ACT & ASSERT #
     token_stream = TokenStream('')
     self.assertTrue(token_stream.look_ahead_state is LookAheadState.NULL,
                     'sanity check: this test assumes that the constructor of the token parser '
                     'sets correct look-ahead state')
     assertion.apply_without_message(self, token_stream)
 def test_fail(self):
     # ARRANGE #
     assertion = sut.assert_token_stream(look_ahead_state=asrt.is_(LookAheadState.NULL))
     # ACT & ASSERT #
     token_stream = TokenStream('a_token')
     self.assertTrue(token_stream.look_ahead_state is LookAheadState.HAS_TOKEN,
                     'sanity check: this test assumes that the constructor of the token parser '
                     'sets correct look-ahead state')
     assert_that_assertion_fails(assertion, token_stream)
Esempio n. 5
0
def remaining_source(remaining_contents_of_first_line: str,
                     following_lines: Sequence[str] = ()) -> TokenParser:
    """
    :param remaining_contents_of_first_line: Part of the first line that has not been consumed.
    :return: Source with some initial content of the first line that has been consumed.
    """
    content = '\n'.join([remaining_contents_of_first_line] + list(following_lines))
    token_stream = TokenStream(content)
    return TokenParser(token_stream)
 def test_head_token_fail(self):
     # ARRANGE #
     token_stream = TokenStream('a_token')
     failing_token_assertion = asrt.sub_component('token_type',
                                                  Token.is_quoted.fget,
                                                  asrt.is_true)
     assertion = sut.assert_token_stream(head_token=failing_token_assertion)
     # ACT & ASSERT #
     assert_that_assertion_fails(assertion, token_stream)
Esempio n. 7
0
 def _test_case(self, tc: TC):
     with self.subTest(token_stream=tc.source_string):
         # ARRANGE #
         token_stream = TokenStream(tc.source_string)
         # ACT #
         actual = sut.parse_fragments_from_tokens(token_stream,
                                                  CONFIGURATION)
         # ASSERT #
         self.assertEqual(tc.expectation.fragments, actual, 'fragment')
         tc.expectation.token_stream.apply_with_message(
             self, token_stream, 'token_stream')
Esempio n. 8
0
 def _test_case__parse_string_sdv(self, tc: TC):
     # ARRANGE #
     token_stream = TokenStream(tc.source_string)
     # ACT #
     actual = sut.parse_string_sdv(token_stream, CONFIGURATION)
     # ASSERT #
     tc.expectation.token_stream.apply_with_message(self, token_stream,
                                                    'token_stream')
     assertion_on_result = assert_equals_string_sdv(
         tc.expectation.fragments)
     assertion_on_result.apply_with_message(self, actual, 'fragment')
Esempio n. 9
0
def new_token_stream(source: str) -> TokenStream:
    """
    Constructs a :class:`TokenStream`
    :rtype: :class:`TokenStream`
    :raises :class:`SingleInstructionInvalidArgumentException` Invalid syntax
    """
    try:
        return TokenStream(source)
    except TokenSyntaxError as ex:
        raise SingleInstructionInvalidArgumentException(
            std_error_message_text_for_token_syntax_error_from_exception(ex))
Esempio n. 10
0
 def check(self, put: unittest.TestCase, arrangement: Arrangement,
           expectation: Expectation):
     # ARRANGE #
     ts = TokenStream(arrangement.source)
     # ACT #
     actual = sut.parse_path(ts,
                             arrangement.rel_option_argument_configuration,
                             arrangement.source_file_path)
     # ASSERT #
     equals_path_sdv(expectation.path_sdv).apply_with_message(
         put, actual, 'path sdv')
     expectation.token_stream.apply_with_message(put, ts, 'token-stream')
 def test_pass_when_no_explicit_component_assertion(self):
     test_cases = [
         NameAndValue('Empty source', ''),
         NameAndValue('Single token source', 'a_token'),
         NameAndValue('Two token source', 'first_token second'),
     ]
     for test_case in test_cases:
         with self.subTest(test_case.name):
             # ARRANGE #
             token_stream = TokenStream(test_case.value)
             assertion = sut.assert_token_stream()
             # ACT & ASSERT #
             assertion.apply_without_message(self, token_stream)
Esempio n. 12
0
 def test_return_value_from_parser_WHEN_command_is_found(self):
     command_name = 'command'
     return_value_from_parser = 'parser return value'
     command_parser = do_return(return_value_from_parser)
     command_name_2_parser = {
         command_name: command_parser,
     }
     # ARRANGE #
     token_stream = TokenStream(command_name)
     parser = sut.TokenParser(token_stream)
     # ACT #
     actual = parser.parse_optional_command(command_name_2_parser)
     # ASSERT #
     self.assertEqual(return_value_from_parser, actual)
Esempio n. 13
0
 def check2(self, put: unittest.TestCase, arrangement: Arrangement,
            expectation: Expectation2):
     # ARRANGE #
     ts = TokenStream(arrangement.source)
     # ACT #
     actual = sut.parse_path(ts,
                             arrangement.rel_option_argument_configuration,
                             arrangement.source_file_path)
     # ASSERT #
     self.__assertions_on_reference_restrictions(
         put, actual, expectation.
         symbol_table_in_with_all_ref_restrictions_are_satisfied)
     expectation.path_sdv.apply_with_message(put, actual, 'path-sdv')
     expectation.token_stream.apply_with_message(put, ts, 'token-stream')
     self.__assertions_on_hypothetical_reference_to_sdv(
         put, actual, expectation.
         symbol_table_in_with_all_ref_restrictions_are_satisfied)
Esempio n. 14
0
 def assert_raises_invalid_argument_exception(
         self,
         put: unittest.TestCase,
         source_string: str,
         test_name: str = '',
         path_suffix_is_required_cases: Sequence[bool] = (False, True),
 ):
     for path_suffix_is_required in path_suffix_is_required_cases:
         rel_opt_arg_conf = ARBITRARY_REL_OPT_ARG_CONF.config_for(
             path_suffix_is_required)
         for source_file_location in [None, Path('/source/file/location')]:
             with put.subTest(
                     test_name=test_name,
                     path_suffix_is_required=path_suffix_is_required,
                     source_file_location=source_file_location):
                 token_stream = TokenStream(source_string)
                 with put.assertRaises(
                         SingleInstructionInvalidArgumentException):
                     sut.parse_path(
                         token_stream,
                         rel_opt_arg_conf,
                         source_file_location=source_file_location)
Esempio n. 15
0
def _token_parser_of(source: str) -> TokenParser:
    return TokenParser(TokenStream(source))
 def test_source_pass(self):
     # ARRANGE #
     token_stream = TokenStream('a_token')
     assertion = sut.assert_token_stream(source=asrt.equals('a_token'))
     # ACT & ASSERT #
     assertion.apply_without_message(self, token_stream)
 def test_position_fail(self):
     # ARRANGE #
     token_stream = TokenStream('a_token')
     assertion = sut.assert_token_stream(position=asrt.equals(2))
     # ACT & ASSERT #
     assert_that_assertion_fails(assertion, token_stream)
 def test_remaining_part_of_current_line_fail(self):
     # ARRANGE #
     token_stream = TokenStream('first line\nsecond line')
     assertion = sut.assert_token_stream(remaining_part_of_current_line=asrt.equals('second line'))
     # ACT & ASSERT #
     assert_that_assertion_fails(assertion, token_stream)
 def test_remaining_source_fail(self):
     # ARRANGE #
     token_stream = TokenStream('a_token')
     assertion = sut.assert_token_stream(remaining_source=asrt.equals('not remaining source'))
     # ACT & ASSERT #
     assert_that_assertion_fails(assertion, token_stream)
Esempio n. 20
0
 def test_missing_argument__parse_string_sdv(self):
     with self.assertRaises(SingleInstructionInvalidArgumentException):
         sut.parse_string_sdv(TokenStream(''))
Esempio n. 21
0
 def test_parse_string_sdv(self):
     for reserved in reserved_words.RESERVED_TOKENS:
         with self.subTest(reserved):
             with self.assertRaises(
                     SingleInstructionInvalidArgumentException):
                 sut.parse_string_sdv(TokenStream(reserved))
Esempio n. 22
0
def _multi_line_source(lines: List[str], **kwargs) -> TokenStream:
    all_lines = '\n'.join([_src(line, **kwargs) for line in lines])
    return TokenStream(all_lines)
Esempio n. 23
0
 def test_missing_argument__parse_fragments_from_token(self):
     with self.assertRaises(SingleInstructionInvalidArgumentException):
         sut.parse_fragments_from_tokens(TokenStream(''))
Esempio n. 24
0
 def test_missing_argument__parse_sym_ref_or_string_sdv(self):
     parser = sut.SymbolReferenceOrStringParser(CONFIGURATION)
     with self.assertRaises(SingleInstructionInvalidArgumentException):
         parser.parse(TokenParser(TokenStream('')))
Esempio n. 25
0
def _single_line_source(s: str, **kwargs) -> TokenStream:
    return TokenStream(_src(s, **kwargs))
 def test_remaining_part_of_current_line_pass(self):
     # ARRANGE #
     token_stream = TokenStream('first line\nsecond line')
     assertion = sut.assert_token_stream(remaining_part_of_current_line=asrt.equals('first line'))
     # ACT & ASSERT #
     assertion.apply_without_message(self, token_stream)
 def test_remaining_source_after_head_fail(self):
     # ARRANGE #
     token_stream = TokenStream('fst_token snd_token')
     assertion = sut.assert_token_stream(remaining_source_after_head=asrt.equals('fst_token'))
     # ACT & ASSERT #
     assert_that_assertion_fails(assertion, token_stream)
 def test_remaining_source_after_head_pass(self):
     # ARRANGE #
     token_stream = TokenStream('fst_token snd_token')
     assertion = sut.assert_token_stream(remaining_source_after_head=asrt.equals('snd_token'))
     # ACT & ASSERT #
     assertion.apply_without_message(self, token_stream)
 def test_is_null_fail(self):
     # ARRANGE #
     token_stream = TokenStream('a_token')
     assertion = sut.assert_token_stream(is_null=asrt.is_true)
     # ACT & ASSERT #
     assert_that_assertion_fails(assertion, token_stream)
 def test_is_null_pass(self):
     # ARRANGE #
     token_stream = TokenStream('')
     assertion = sut.assert_token_stream(is_null=asrt.is_true)
     # ACT & ASSERT #
     assertion.apply_without_message(self, token_stream)