diff --git a/tests/parse/templates.py b/tests/parse/templates.py index 832d849..9835b42 100644 --- a/tests/parse/templates.py +++ b/tests/parse/templates.py @@ -5,6 +5,7 @@ from hypothesis.strategies import composite, integers from src.parse import ParseErrorException, SyntaxStream +from tests.parse.test_parse import draw_parse_context from tests.test_syntax import draw_syntax_random @@ -39,7 +40,7 @@ return lambda func: do -# Test that something parsers incorrectly +# Test that something parses incorrectly def template_parse_invalid(parser): def do(test_data): (tokens, error, context) = test_data @@ -50,4 +51,9 @@ except ParseErrorException as e: assert e == error - return lambda func: given(composite(func)())(do) + def wrapper(draw, func): + context = draw(draw_parse_context()) + (tokens, error) = draw(composite(func)(context)) + return (tokens, error, context) + + return lambda func: given(composite(wrapper)(func))(do) diff --git a/tests/parse/test_bool.py b/tests/parse/test_bool.py index dd5d4ca..d34dec7 100644 --- a/tests/parse/test_bool.py +++ b/tests/parse/test_bool.py @@ -7,7 +7,6 @@ from src.parse import ParseContext, ParseError, ParseErrorException, ParseTask, Parser from src.syntax import Syntax, SyntaxType from tests.parse.templates import template_parse_valid, template_parse_invalid -from tests.parse.test_parse import draw_parse_context from tests.test_syntax import draw_token_bool, draw_syntax_random @@ -36,8 +35,7 @@ # - Error if the token is not a SyntaxType.TOKEN # - Error if the token is not True or False @template_parse_invalid(Parser().parse_bool) -def test_parse_bool_invalid_incorrect(draw): - parent_context = draw(draw_parse_context()) +def test_parse_bool_invalid_incorrect(draw, parent_context): token = draw(draw_syntax_random()) assume(not (token.type == SyntaxType.TOKEN and token.value in ["True", "False"])) context = ParseContext(ParseTask.PARSE_BOOL, token, parent_context) @@ -45,15 +43,14 @@ error = ParseErrorException(ParseError.NOT_BOOL, token, None, context) else: error = ParseErrorException(ParseError.NOT_TOKEN, token, None, context) - return ([token], error, parent_context) + return ([token], error) # Generate no boolean # We expect the following behaviour: # - Error if there isn't a token @template_parse_invalid(Parser().parse_bool) -def test_parse_bool_invalid_empty(draw): - parent_context = draw(draw_parse_context()) +def test_parse_bool_invalid_empty(draw, parent_context): context = ParseContext(ParseTask.PARSE_BOOL, None, parent_context) error = ParseErrorException(ParseError.NO_TOKEN, None, None, context) - return ([], error, parent_context) + return ([], error) diff --git a/tests/parse/test_clear_notes.py b/tests/parse/test_clear_notes.py index 14707d8..0785412 100644 --- a/tests/parse/test_clear_notes.py +++ b/tests/parse/test_clear_notes.py @@ -13,7 +13,6 @@ ) from src.syntax import SyntaxStream from tests.parse.templates import template_parse_invalid -from tests.parse.test_parse import draw_parse_context from tests.test_syntax import draw_token_by_value, draw_syntax_token @@ -81,17 +80,16 @@ # - When StartNote is encountered skip_note is called to skip the note # - Any error skip_note gives is propagated through clear_notes @template_parse_invalid(dummy_skipper_invalid().clear_notes) -def test_parse_clear_notes_startnote_propagation(draw): +def test_parse_clear_notes_startnote_propagation(draw, parent_context): tokens = draw(lists(draw_clear_notes_value_token())) # Ensure we have a StartNote somewhere start = draw(draw_token_by_value("StartNote")) new_tokens = tokens + [start] - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.CLEAR_NOTES, new_tokens[0], parent_context) for token in new_tokens: if token.value == "StartNote": error = ParseErrorException(ParseError.TEST_ERROR, token, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) raise AssertionError("Unable to find StartNote?") @@ -99,15 +97,14 @@ # We expect the following behaviour: # - When EndNote is encountered a FOUND_ENDNOTE error is raised @template_parse_invalid(dummy_skipper_valid().clear_notes) -def test_parse_clear_notes_invalid_endnote(draw): +def test_parse_clear_notes_invalid_endnote(draw, parent_context): tokens = draw(lists(draw_clear_notes_value_token())) # Ensure we have an EndNote somewhere start = draw(draw_token_by_value("EndNote")) new_tokens = tokens + [start] - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.CLEAR_NOTES, new_tokens[0], parent_context) for token in new_tokens: if token.value == "EndNote": error = ParseErrorException(ParseError.FOUND_ENDNOTE, token, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) raise AssertionError("Unable to find EndNote?") diff --git a/tests/parse/test_note.py b/tests/parse/test_note.py index cb888d4..6986d88 100644 --- a/tests/parse/test_note.py +++ b/tests/parse/test_note.py @@ -20,7 +20,6 @@ template_parse_invalid, template_parse_valid, ) -from tests.parse.test_parse import draw_parse_context from tests.test_syntax import ( draw_token_by_value, draw_syntax_random, @@ -60,9 +59,8 @@ # - Error if StartNote is not a SyntaxType.TOKEN # - Error if StartNote's token value is not "StartNote" @template_parse_invalid(NoteSkipper().skip_note) -def test_parse_note_invalid_incorrect(draw): +def test_parse_note_invalid_incorrect(draw, parent_context): (tokens, _) = draw(draw_syntax_note_valid()) - parent_context = draw(draw_parse_context()) token = draw(draw_syntax_random()) assume(not (token.type == SyntaxType.TOKEN and token.value == "StartNote")) new_tokens = [token] + tokens[1:0] @@ -71,41 +69,38 @@ error = ParseErrorException(ParseError.WRONG_TOKEN, token, "StartNote", context) else: error = ParseErrorException(ParseError.NOT_TOKEN, token, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) # Generate no note # We expect the following behaviour: # - Error if there is no StartNote node at all @template_parse_invalid(NoteSkipper().skip_note) -def test_parse_note_invalid_empty(draw): - parent_context = draw(draw_parse_context()) +def test_parse_note_invalid_empty(draw, parent_context): context = ParseContext(ParseTask.PARSE_NOTE, None, parent_context) error = ParseErrorException(ParseError.NO_TOKEN, None, None, context) - return ([], error, parent_context) + return ([], error) # Generate note with a StartNote token in it # We expect the following behaviour: # - Error if a StartNote token is in the note content @template_parse_invalid(NoteSkipper().skip_note) -def test_parse_note_invalid_extrastartnote(draw): +def test_parse_note_invalid_extrastartnote(draw, parent_context): (tokens, _) = draw(draw_syntax_note_valid()) start = draw(draw_token_by_value("StartNote")) new_tokens = insert_random(draw, tokens, start) - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.PARSE_NOTE, new_tokens[0], parent_context) error = ParseErrorException(ParseError.FOUND_STARTNOTE, start, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) # Generate note without EndNote # We expect the following behaviour: # - Error if there is no EndNote node at all @template_parse_invalid(NoteSkipper().skip_note) -def test_parse_note_invalid_noendnote(draw): +def test_parse_note_invalid_noendnote(draw, parent_context): (tokens, _) = draw(draw_syntax_note_valid()) - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.PARSE_NOTE, tokens[0], parent_context) error = ParseErrorException(ParseError.NO_TOKEN, None, None, context) - return (tokens[0:-1], error, parent_context) + return (tokens[0:-1], error) diff --git a/tests/parse/test_text.py b/tests/parse/test_text.py index 3c23728..26d843b 100644 --- a/tests/parse/test_text.py +++ b/tests/parse/test_text.py @@ -20,7 +20,6 @@ template_parse_invalid, template_parse_valid, ) -from tests.parse.test_parse import draw_parse_context from tests.test_syntax import ( draw_token_by_value, draw_syntax_random, @@ -68,9 +67,8 @@ # - Error if StartText is not a SyntaxType.TOKEN # - Error if StartText's token value is not "StartText" @template_parse_invalid(Parser().parse_text) -def test_parse_text_invalid_incorrect(draw): +def test_parse_text_invalid_incorrect(draw, parent_context): (tokens, _) = draw(draw_syntax_text_valid()) - parent_context = draw(draw_parse_context()) token = draw(draw_syntax_random()) assume(not (token.type == SyntaxType.TOKEN and token.value == "StartText")) new_tokens = [token] + tokens[1:0] @@ -79,57 +77,53 @@ error = ParseErrorException(ParseError.WRONG_TOKEN, token, "StartText", context) else: error = ParseErrorException(ParseError.NOT_TOKEN, token, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) # Generate no text # We expect the following behaviour: # - Error if there is no StartText node at all @template_parse_invalid(Parser().parse_text) -def test_parse_text_invalid_empty(draw): +def test_parse_text_invalid_empty(draw, parent_context): (tokens, _) = draw(draw_syntax_text_valid()) - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.PARSE_TEXT, None, parent_context) error = ParseErrorException(ParseError.NO_TOKEN, None, None, context) - return ([], error, parent_context) + return ([], error) # Generate text with invalid content tokens # We expect the following behaviour: # - Error if a content token is not a SyntaxType.TOKEN @template_parse_invalid(Parser().parse_text) -def test_parse_syntax_text_invalid_invalidcontent(draw): +def test_parse_text_invalid_invalidcontent(draw, parent_context): (tokens, _) = draw(draw_syntax_text_valid()) token = draw(draw_syntax_random()) assume(token.type != SyntaxType.TOKEN) new_tokens = insert_random(draw, tokens, token) - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.PARSE_TEXT, new_tokens[0], parent_context) error = ParseErrorException(ParseError.NOT_TOKEN, token, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) # Generate text with a StartText token in it # We expect the following behaviour: # - Error if a StartText token is in the text content @template_parse_invalid(Parser().parse_text) -def test_parse_text_invalid_extrastarttext(draw): +def test_parse_text_invalid_extrastarttext(draw, parent_context): (tokens, _) = draw(draw_syntax_text_valid()) start = draw(draw_token_by_value("StartText")) new_tokens = insert_random(draw, tokens, start) - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.PARSE_TEXT, new_tokens[0], parent_context) error = ParseErrorException(ParseError.FOUND_STARTTEXT, start, None, context) - return (new_tokens, error, parent_context) + return (new_tokens, error) # Generate text without EndText # We expect the following behaviour: # - Error if there is no EndText node at all @template_parse_invalid(Parser().parse_text) -def test_parse_text_invalid_noendtext(draw): +def test_parse_text_invalid_noendtext(draw, parent_context): (tokens, _) = draw(draw_syntax_text_valid()) - parent_context = draw(draw_parse_context()) context = ParseContext(ParseTask.PARSE_TEXT, tokens[0], parent_context) error = ParseErrorException(ParseError.NO_TOKEN, None, None, context) - return (tokens[0:-1], error, parent_context) + return (tokens[0:-1], error)