From 8afd13cb16b33f3a0afb5f0d5667390a31d8eaac Mon Sep 17 00:00:00 2001 From: Kodi Arfer Date: Mon, 17 Apr 2017 15:49:02 -0700 Subject: [PATCH] Use test functions instead of unittest.TestCase --- tests/compilers/test_compiler.py | 143 ++++++++++++++----------------- 1 file changed, 66 insertions(+), 77 deletions(-) diff --git a/tests/compilers/test_compiler.py b/tests/compilers/test_compiler.py index 3f1b397..a6253b4 100644 --- a/tests/compilers/test_compiler.py +++ b/tests/compilers/test_compiler.py @@ -20,96 +20,85 @@ # DEALINGS IN THE SOFTWARE. import ast -import sys from hy import compiler from hy.models import HyExpression, HyList, HySymbol, HyInteger from hy._compat import PY3 -if sys.version_info[0] <= 2 and sys.version_info[1] <= 6: - import unittest2 as unittest -else: - import unittest + +def test_builds_with_dash(): + assert callable(compiler.builds("foobar")) + assert callable(compiler.builds("foo_bar")) + assert callable(compiler.builds("-")) + try: + compiler.builds("foobar-with-dash-") + except TypeError as e: + assert "*post* translated strings" in str(e) + else: + assert False -class CompilerTest(unittest.TestCase): - - def test_builds_with_dash(self): - self.assert_(callable(compiler.builds("foobar"))) - self.assert_(callable(compiler.builds("foo_bar"))) - self.assert_(callable(compiler.builds("-"))) - self.assertRaisesRegexp(TypeError, - r"\*post\* translated strings", - compiler.builds, "foobar-with-dash-") +def make_expression(*args): + h = HyExpression(args) + h.start_line = 1 + h.end_line = 1 + h.start_column = 1 + h.end_column = 1 + return h.replace(h) -class HyASTCompilerTest(unittest.TestCase): +def test_compiler_bare_names(): + """ + Check that the compiler doesn't drop bare names from code branches + """ + e = make_expression(HySymbol("do"), + HySymbol("a"), + HySymbol("b"), + HySymbol("c")) + ret = compiler.HyASTCompiler('test').compile(e) - @staticmethod - def _make_expression(*args): - h = HyExpression(args) - h.start_line = 1 - h.end_line = 1 - h.start_column = 1 - h.end_column = 1 - return h.replace(h) + # We expect two statements and a final expr. - def setUp(self): - self.c = compiler.HyASTCompiler('test') + assert len(ret.stmts) == 2 + for stmt, symbol in zip(ret.stmts, "ab"): + assert isinstance(stmt, ast.Expr) + assert isinstance(stmt.value, ast.Name) + assert stmt.value.id == symbol - def test_compiler_bare_names(self): - """ - Check that the compiler doesn't drop bare names from code branches - """ - ret = self.c.compile(self._make_expression(HySymbol("do"), - HySymbol("a"), - HySymbol("b"), - HySymbol("c"))) + assert isinstance(ret.expr, ast.Name) + assert ret.expr.id == "c" - # We expect two statements and a final expr. - self.assertEqual(len(ret.stmts), 2) - stmt = ret.stmts[0] - self.assertIsInstance(stmt, ast.Expr) - self.assertIsInstance(stmt.value, ast.Name) - self.assertEqual(stmt.value.id, "a") - stmt = ret.stmts[1] - self.assertIsInstance(stmt, ast.Expr) - self.assertIsInstance(stmt.value, ast.Name) - self.assertEqual(stmt.value.id, "b") - expr = ret.expr - self.assertIsInstance(expr, ast.Name) - self.assertEqual(expr.id, "c") - def test_compiler_yield_return(self): - """ - Check that the compiler correctly generates return statements for - a generator function. In Python versions prior to 3.3, the return - statement in a generator can't take a value, so the final expression - should not generate a return statement. From 3.3 onwards a return - value should be generated. - """ - ret = self.c.compile_function_def( - self._make_expression(HySymbol("fn"), - HyList(), - HyExpression([HySymbol("yield"), - HyInteger(2)]), - HyExpression([HySymbol("+"), - HyInteger(1), - HyInteger(1)]))) +def test_compiler_yield_return(): + """ + Check that the compiler correctly generates return statements for + a generator function. In Python versions prior to 3.3, the return + statement in a generator can't take a value, so the final expression + should not generate a return statement. From 3.3 onwards a return + value should be generated. + """ + e = make_expression(HySymbol("fn"), + HyList(), + HyExpression([HySymbol("yield"), + HyInteger(2)]), + HyExpression([HySymbol("+"), + HyInteger(1), + HyInteger(1)])) + ret = compiler.HyASTCompiler('test').compile_function_def(e) - self.assertEqual(len(ret.stmts), 1) - stmt = ret.stmts[0] - self.assertIsInstance(stmt, ast.FunctionDef) - body = stmt.body - self.assertEquals(len(body), 2) - self.assertIsInstance(body[0], ast.Expr) - self.assertIsInstance(body[0].value, ast.Yield) + assert len(ret.stmts) == 1 + stmt, = ret.stmts + assert isinstance(stmt, ast.FunctionDef) + body = stmt.body + assert len(body) == 2 + assert isinstance(body[0], ast.Expr) + assert isinstance(body[0].value, ast.Yield) - if PY3: - # From 3.3+, the final statement becomes a return value - self.assertIsInstance(body[1], ast.Return) - self.assertIsInstance(body[1].value, ast.BinOp) - else: - # In earlier versions, the expression is not returned - self.assertIsInstance(body[1], ast.Expr) - self.assertIsInstance(body[1].value, ast.BinOp) + if PY3: + # From 3.3+, the final statement becomes a return value + assert isinstance(body[1], ast.Return) + assert isinstance(body[1].value, ast.BinOp) + else: + # In earlier versions, the expression is not returned + assert isinstance(body[1], ast.Expr) + assert isinstance(body[1].value, ast.BinOp)