Skip to content

Commit

Permalink
Merge pull request dabeaz#262 from hugovk/assert_-to-assertTrue
Browse files Browse the repository at this point in the history 
Replace removed assert_ with assertTrue
  • Loading branch information
@dabeaz
dabeaz authored Dec 30, 2021
2 parents a00c1c9 + ceb74fd commit 1413aa2
Show file tree
Hide file tree
Showing 2 changed files with 74 additions and 74 deletions.
76 changes: 38 additions & 38 deletions test/testlex.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -97,68 +97,68 @@ def tearDown(self):
def test_lex_doc1(self):
self.assertRaises(SyntaxError,run_import,"lex_doc1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_doc1.py:18: No regular expression defined for rule 't_NUMBER'\n"))
def test_lex_dup1(self):
self.assertRaises(SyntaxError,run_import,"lex_dup1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_dup1.py:20: Rule t_NUMBER redefined. Previously defined on line 18\n" ))

def test_lex_dup2(self):
self.assertRaises(SyntaxError,run_import,"lex_dup2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_dup2.py:22: Rule t_NUMBER redefined. Previously defined on line 18\n" ))

def test_lex_dup3(self):
self.assertRaises(SyntaxError,run_import,"lex_dup3")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_dup3.py:20: Rule t_NUMBER redefined. Previously defined on line 18\n" ))

def test_lex_empty(self):
self.assertRaises(SyntaxError,run_import,"lex_empty")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"No rules of the form t_rulename are defined\n"
"No rules defined for state 'INITIAL'\n"))

def test_lex_error1(self):
run_import("lex_error1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"No t_error rule is defined\n"))

def test_lex_error2(self):
self.assertRaises(SyntaxError,run_import,"lex_error2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Rule 't_error' must be defined as a function\n")
)

def test_lex_error3(self):
self.assertRaises(SyntaxError,run_import,"lex_error3")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_error3.py:20: Rule 't_error' requires an argument\n"))

def test_lex_error4(self):
self.assertRaises(SyntaxError,run_import,"lex_error4")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_error4.py:20: Rule 't_error' has too many arguments\n"))

def test_lex_ignore(self):
self.assertRaises(SyntaxError,run_import,"lex_ignore")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_ignore.py:20: Rule 't_ignore' must be defined as a string\n"))

def test_lex_ignore2(self):
run_import("lex_ignore2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"t_ignore contains a literal backslash '\\'\n"))


Expand All @@ -169,20 +169,20 @@ def test_lex_re1(self):
msg = "Invalid regular expression for rule 't_NUMBER'. unbalanced parenthesis\n"
else:
msg = "Invalid regular expression for rule 't_NUMBER'. missing ), unterminated subpattern at position 0"
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
msg,
contains=True))

def test_lex_re2(self):
self.assertRaises(SyntaxError,run_import,"lex_re2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Regular expression for rule 't_PLUS' matches empty string\n"))

def test_lex_re3(self):
self.assertRaises(SyntaxError,run_import,"lex_re3")
result = sys.stderr.getvalue()
# self.assert_(check_expected(result,
# self.assertTrue(check_expected(result,
# "Invalid regular expression for rule 't_POUND'. unbalanced parenthesis\n"
# "Make sure '#' in rule 't_POUND' is escaped with '\\#'\n"))

Expand All @@ -192,78 +192,78 @@ def test_lex_re3(self):
else:
msg = ("Invalid regular expression for rule 't_POUND'. missing ), unterminated subpattern at position 0\n"
"ERROR: Make sure '#' in rule 't_POUND' is escaped with '\#'")
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
msg,
contains=True), result)

def test_lex_rule1(self):
self.assertRaises(SyntaxError,run_import,"lex_rule1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"t_NUMBER not defined as a function or string\n"))

def test_lex_rule2(self):
self.assertRaises(SyntaxError,run_import,"lex_rule2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_rule2.py:18: Rule 't_NUMBER' requires an argument\n"))

def test_lex_rule3(self):
self.assertRaises(SyntaxError,run_import,"lex_rule3")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"lex_rule3.py:18: Rule 't_NUMBER' has too many arguments\n"))


def test_lex_state1(self):
self.assertRaises(SyntaxError,run_import,"lex_state1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"states must be defined as a tuple or list\n"))

def test_lex_state2(self):
self.assertRaises(SyntaxError,run_import,"lex_state2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Invalid state specifier 'comment'. Must be a tuple (statename,'exclusive|inclusive')\n"
"Invalid state specifier 'example'. Must be a tuple (statename,'exclusive|inclusive')\n"))

def test_lex_state3(self):
self.assertRaises(SyntaxError,run_import,"lex_state3")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"State name 1 must be a string\n"
"No rules defined for state 'example'\n"))

def test_lex_state4(self):
self.assertRaises(SyntaxError,run_import,"lex_state4")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"State type for state 'comment' must be 'inclusive' or 'exclusive'\n"))


def test_lex_state5(self):
self.assertRaises(SyntaxError,run_import,"lex_state5")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"State 'comment' already defined\n"))

def test_lex_state_noerror(self):
run_import("lex_state_noerror")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"No error rule is defined for exclusive state 'comment'\n"))

def test_lex_state_norule(self):
self.assertRaises(SyntaxError,run_import,"lex_state_norule")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"No rules defined for state 'example'\n"))

def test_lex_token1(self):
self.assertRaises(SyntaxError,run_import,"lex_token1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"No token list is defined\n"
"Rule 't_NUMBER' defined for an unspecified token NUMBER\n"
"Rule 't_PLUS' defined for an unspecified token PLUS\n"
Expand All @@ -273,7 +273,7 @@ def test_lex_token1(self):
def test_lex_token2(self):
self.assertRaises(SyntaxError,run_import,"lex_token2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"tokens must be a list or tuple\n"
"Rule 't_NUMBER' defined for an unspecified token NUMBER\n"
"Rule 't_PLUS' defined for an unspecified token PLUS\n"
Expand All @@ -283,34 +283,34 @@ def test_lex_token2(self):
def test_lex_token3(self):
self.assertRaises(SyntaxError,run_import,"lex_token3")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Rule 't_MINUS' defined for an unspecified token MINUS\n"))


def test_lex_token4(self):
self.assertRaises(SyntaxError,run_import,"lex_token4")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Bad token name '-'\n"))


def test_lex_token_dup(self):
run_import("lex_token_dup")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Token 'MINUS' multiply defined\n"))


def test_lex_literal1(self):
self.assertRaises(SyntaxError,run_import,"lex_literal1")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Invalid literal '**'. Must be a single character\n"))

def test_lex_literal2(self):
self.assertRaises(SyntaxError,run_import,"lex_literal2")
result = sys.stderr.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"Invalid literals specification. literals must be a sequence of characters\n"))

import os
Expand All @@ -333,31 +333,31 @@ def tearDown(self):
def test_lex_module(self):
run_import("lex_module")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"(NUMBER,3,1,0)\n"
"(PLUS,'+',1,1)\n"
"(NUMBER,4,1,2)\n"))

def test_lex_object(self):
run_import("lex_object")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"(NUMBER,3,1,0)\n"
"(PLUS,'+',1,1)\n"
"(NUMBER,4,1,2)\n"))

def test_lex_closure(self):
run_import("lex_closure")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"(NUMBER,3,1,0)\n"
"(PLUS,'+',1,1)\n"
"(NUMBER,4,1,2)\n"))

def test_lex_many_tokens(self):
run_import("lex_many_tokens")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"(TOK34,'TOK34:',1,0)\n"
"(TOK143,'TOK143:',1,7)\n"
"(TOK269,'TOK269:',1,15)\n"
Expand All @@ -379,15 +379,15 @@ def tearDown(self):
def test_lex_hedit(self):
run_import("lex_hedit")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"(H_EDIT_DESCRIPTOR,'abc',1,0)\n"
"(H_EDIT_DESCRIPTOR,'abcdefghij',1,6)\n"
"(H_EDIT_DESCRIPTOR,'xy',1,20)\n"))

def test_lex_state_try(self):
run_import("lex_state_try")
result = sys.stdout.getvalue()
self.assert_(check_expected(result,
self.assertTrue(check_expected(result,
"(NUMBER,'3',1,0)\n"
"(PLUS,'+',1,2)\n"
"(NUMBER,'4',1,4)\n"
Expand Down
Loading

0 comments on commit 1413aa2

Please sign in to comment.