1 """This module tests SyntaxErrors.

     2 

     3 Here's an example of the sort of thing that is tested.

     4 

     5 >>> def f(x):

     6 ...     global x

     7 Traceback (most recent call last):

     8 SyntaxError: name 'x' is local and global

     9 

    10 The tests are all raise SyntaxErrors.  They were created by checking

    11 each C call that raises SyntaxError.  There are several modules that

    12 raise these exceptions-- ast.c, compile.c, future.c, pythonrun.c, and

    13 symtable.c.

    14 

    15 The parser itself outlaws a lot of invalid syntax.  None of these

    16 errors are tested here at the moment.  We should add some tests; since

    17 there are infinitely many programs with invalid syntax, we would need

    18 to be judicious in selecting some.

    19 

    20 The compiler generates a synthetic module name for code executed by

    21 doctest.  Since all the code comes from the same module, a suffix like

    22 [1] is appended to the module name, As a consequence, changing the

    23 order of tests in this module means renumbering all the errors after

    24 it.  (Maybe we should enable the ellipsis option for these tests.)

    25 

    26 In ast.c, syntax errors are raised by calling ast_error().

    27 

    28 Errors from set_context():

    29 

    30 TODO(jhylton): "assignment to None" is inconsistent with other messages

    31 

    32 >>> obj.None = 1

    33 Traceback (most recent call last):

    34 SyntaxError: assignment to None (<doctest test.test_syntax[1]>, line 1)

    35 

    36 >>> None = 1

    37 Traceback (most recent call last):

    38 SyntaxError: assignment to None (<doctest test.test_syntax[2]>, line 1)

    39 

    40 It's a syntax error to assign to the empty tuple.  Why isn't it an

    41 error to assign to the empty list?  It will always raise some error at

    42 runtime.

    43 

    44 >>> () = 1

    45 Traceback (most recent call last):

    46 SyntaxError: can't assign to () (<doctest test.test_syntax[3]>, line 1)

    47 

    48 >>> f() = 1

    49 Traceback (most recent call last):

    50 SyntaxError: can't assign to function call (<doctest test.test_syntax[4]>, line 1)

    51 

    52 >>> del f()

    53 Traceback (most recent call last):

    54 SyntaxError: can't delete function call (<doctest test.test_syntax[5]>, line 1)

    55 

    56 >>> a + 1 = 2

    57 Traceback (most recent call last):

    58 SyntaxError: can't assign to operator (<doctest test.test_syntax[6]>, line 1)

    59 

    60 >>> (x for x in x) = 1

    61 Traceback (most recent call last):

    62 SyntaxError: can't assign to generator expression (<doctest test.test_syntax[7]>, line 1)

    63 

    64 >>> 1 = 1

    65 Traceback (most recent call last):

    66 SyntaxError: can't assign to literal (<doctest test.test_syntax[8]>, line 1)

    67 

    68 >>> "abc" = 1

    69 Traceback (most recent call last):

    70 SyntaxError: can't assign to literal (<doctest test.test_syntax[9]>, line 1)

    71 

    72 >>> `1` = 1

    73 Traceback (most recent call last):

    74 SyntaxError: can't assign to repr (<doctest test.test_syntax[10]>, line 1)

    75 

    76 If the left-hand side of an assignment is a list or tuple, an illegal

    77 expression inside that contain should still cause a syntax error.

    78 This test just checks a couple of cases rather than enumerating all of

    79 them.

    80 

    81 >>> (a, "b", c) = (1, 2, 3)

    82 Traceback (most recent call last):

    83 SyntaxError: can't assign to literal (<doctest test.test_syntax[11]>, line 1)

    84 

    85 >>> [a, b, c + 1] = [1, 2, 3]

    86 Traceback (most recent call last):

    87 SyntaxError: can't assign to operator (<doctest test.test_syntax[12]>, line 1)

    88 

    89 >>> a if 1 else b = 1

    90 Traceback (most recent call last):

    91 SyntaxError: can't assign to conditional expression (<doctest test.test_syntax[13]>, line 1)

    92 

    93 From compiler_complex_args():

    94 

    95 >>> def f(None=1):

    96 ...     pass

    97 Traceback (most recent call last):

    98 SyntaxError: assignment to None (<doctest test.test_syntax[14]>, line 1)

    99 

   100 

   101 From ast_for_arguments():

   102 

   103 >>> def f(x, y=1, z):

   104 ...     pass

   105 Traceback (most recent call last):

   106 SyntaxError: non-default argument follows default argument (<doctest test.test_syntax[15]>, line 1)

   107 

   108 >>> def f(x, None):

   109 ...     pass

   110 Traceback (most recent call last):

   111 SyntaxError: assignment to None (<doctest test.test_syntax[16]>, line 1)

   112 

   113 >>> def f(*None):

   114 ...     pass

   115 Traceback (most recent call last):

   116 SyntaxError: assignment to None (<doctest test.test_syntax[17]>, line 1)

   117 

   118 >>> def f(**None):

   119 ...     pass

   120 Traceback (most recent call last):

   121 SyntaxError: assignment to None (<doctest test.test_syntax[18]>, line 1)

   122 

   123 

   124 From ast_for_funcdef():

   125 

   126 >>> def None(x):

   127 ...     pass

   128 Traceback (most recent call last):

   129 SyntaxError: assignment to None (<doctest test.test_syntax[19]>, line 1)

   130 

   131 

   132 From ast_for_call():

   133 

   134 >>> def f(it, *varargs):

   135 ...     return list(it)

   136 >>> L = range(10)

   137 >>> f(x for x in L)

   138 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   139 >>> f(x for x in L, 1)

   140 Traceback (most recent call last):

   141 SyntaxError: Generator expression must be parenthesized if not sole argument (<doctest test.test_syntax[23]>, line 1)

   142 >>> f((x for x in L), 1)

   143 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

   144 

   145 >>> f(i0,  i1,  i2,  i3,  i4,  i5,  i6,  i7,  i8,  i9,  i10,  i11,

   146 ...   i12,  i13,  i14,  i15,  i16,  i17,  i18,  i19,  i20,  i21,  i22,

   147 ...   i23,  i24,  i25,  i26,  i27,  i28,  i29,  i30,  i31,  i32,  i33,

   148 ...   i34,  i35,  i36,  i37,  i38,  i39,  i40,  i41,  i42,  i43,  i44,

   149 ...   i45,  i46,  i47,  i48,  i49,  i50,  i51,  i52,  i53,  i54,  i55,

   150 ...   i56,  i57,  i58,  i59,  i60,  i61,  i62,  i63,  i64,  i65,  i66,

   151 ...   i67,  i68,  i69,  i70,  i71,  i72,  i73,  i74,  i75,  i76,  i77,

   152 ...   i78,  i79,  i80,  i81,  i82,  i83,  i84,  i85,  i86,  i87,  i88,

   153 ...   i89,  i90,  i91,  i92,  i93,  i94,  i95,  i96,  i97,  i98,  i99,

   154 ...   i100,  i101,  i102,  i103,  i104,  i105,  i106,  i107,  i108,

   155 ...   i109,  i110,  i111,  i112,  i113,  i114,  i115,  i116,  i117,

   156 ...   i118,  i119,  i120,  i121,  i122,  i123,  i124,  i125,  i126,

   157 ...   i127,  i128,  i129,  i130,  i131,  i132,  i133,  i134,  i135,

   158 ...   i136,  i137,  i138,  i139,  i140,  i141,  i142,  i143,  i144,

   159 ...   i145,  i146,  i147,  i148,  i149,  i150,  i151,  i152,  i153,

   160 ...   i154,  i155,  i156,  i157,  i158,  i159,  i160,  i161,  i162,

   161 ...   i163,  i164,  i165,  i166,  i167,  i168,  i169,  i170,  i171,

   162 ...   i172,  i173,  i174,  i175,  i176,  i177,  i178,  i179,  i180,

   163 ...   i181,  i182,  i183,  i184,  i185,  i186,  i187,  i188,  i189,

   164 ...   i190,  i191,  i192,  i193,  i194,  i195,  i196,  i197,  i198,

   165 ...   i199,  i200,  i201,  i202,  i203,  i204,  i205,  i206,  i207,

   166 ...   i208,  i209,  i210,  i211,  i212,  i213,  i214,  i215,  i216,

   167 ...   i217,  i218,  i219,  i220,  i221,  i222,  i223,  i224,  i225,

   168 ...   i226,  i227,  i228,  i229,  i230,  i231,  i232,  i233,  i234,

   169 ...   i235,  i236,  i237,  i238,  i239,  i240,  i241,  i242,  i243,

   170 ...   i244,  i245,  i246,  i247,  i248,  i249,  i250,  i251,  i252,

   171 ...   i253,  i254,  i255)

   172 Traceback (most recent call last):

   173 SyntaxError: more than 255 arguments (<doctest test.test_syntax[25]>, line 1)

   174 

   175 The actual error cases counts positional arguments, keyword arguments,

   176 and generator expression arguments separately.  This test combines the

   177 three.

   178 

   179 >>> f(i0,  i1,  i2,  i3,  i4,  i5,  i6,  i7,  i8,  i9,  i10,  i11,

   180 ...   i12,  i13,  i14,  i15,  i16,  i17,  i18,  i19,  i20,  i21,  i22,

   181 ...   i23,  i24,  i25,  i26,  i27,  i28,  i29,  i30,  i31,  i32,  i33,

   182 ...   i34,  i35,  i36,  i37,  i38,  i39,  i40,  i41,  i42,  i43,  i44,

   183 ...   i45,  i46,  i47,  i48,  i49,  i50,  i51,  i52,  i53,  i54,  i55,

   184 ...   i56,  i57,  i58,  i59,  i60,  i61,  i62,  i63,  i64,  i65,  i66,

   185 ...   i67,  i68,  i69,  i70,  i71,  i72,  i73,  i74,  i75,  i76,  i77,

   186 ...   i78,  i79,  i80,  i81,  i82,  i83,  i84,  i85,  i86,  i87,  i88,

   187 ...   i89,  i90,  i91,  i92,  i93,  i94,  i95,  i96,  i97,  i98,  i99,

   188 ...   i100,  i101,  i102,  i103,  i104,  i105,  i106,  i107,  i108,

   189 ...   i109,  i110,  i111,  i112,  i113,  i114,  i115,  i116,  i117,

   190 ...   i118,  i119,  i120,  i121,  i122,  i123,  i124,  i125,  i126,

   191 ...   i127,  i128,  i129,  i130,  i131,  i132,  i133,  i134,  i135,

   192 ...   i136,  i137,  i138,  i139,  i140,  i141,  i142,  i143,  i144,

   193 ...   i145,  i146,  i147,  i148,  i149,  i150,  i151,  i152,  i153,

   194 ...   i154,  i155,  i156,  i157,  i158,  i159,  i160,  i161,  i162,

   195 ...   i163,  i164,  i165,  i166,  i167,  i168,  i169,  i170,  i171,

   196 ...   i172,  i173,  i174,  i175,  i176,  i177,  i178,  i179,  i180,

   197 ...   i181,  i182,  i183,  i184,  i185,  i186,  i187,  i188,  i189,

   198 ...   i190,  i191,  i192,  i193,  i194,  i195,  i196,  i197,  i198,

   199 ...   i199,  i200,  i201,  i202,  i203,  i204,  i205,  i206,  i207,

   200 ...   i208,  i209,  i210,  i211,  i212,  i213,  i214,  i215,  i216,

   201 ...   i217,  i218,  i219,  i220,  i221,  i222,  i223,  i224,  i225,

   202 ...   i226,  i227,  i228,  i229,  i230,  i231,  i232,  i233,  i234,

   203 ...   i235, i236,  i237,  i238,  i239,  i240,  i241,  i242,  i243,

   204 ...   (x for x in i244),  i245,  i246,  i247,  i248,  i249,  i250,  i251,

   205 ...    i252=1, i253=1,  i254=1,  i255=1)

   206 Traceback (most recent call last):

   207 SyntaxError: more than 255 arguments (<doctest test.test_syntax[26]>, line 1)

   208 

   209 >>> f(lambda x: x[0] = 3)

   210 Traceback (most recent call last):

   211 SyntaxError: lambda cannot contain assignment (<doctest test.test_syntax[27]>, line 1)

   212 

   213 The grammar accepts any test (basically, any expression) in the

   214 keyword slot of a call site.  Test a few different options.

   215 

   216 >>> f(x()=2)

   217 Traceback (most recent call last):

   218 SyntaxError: keyword can't be an expression (<doctest test.test_syntax[28]>, line 1)

   219 >>> f(a or b=1)

   220 Traceback (most recent call last):

   221 SyntaxError: keyword can't be an expression (<doctest test.test_syntax[29]>, line 1)

   222 >>> f(x.y=1)

   223 Traceback (most recent call last):

   224 SyntaxError: keyword can't be an expression (<doctest test.test_syntax[30]>, line 1)

   225 

   226 

   227 From ast_for_expr_stmt():

   228 

   229 >>> (x for x in x) += 1

   230 Traceback (most recent call last):

   231 SyntaxError: augmented assignment to generator expression not possible (<doctest test.test_syntax[31]>, line 1)

   232 >>> None += 1

   233 Traceback (most recent call last):

   234 SyntaxError: assignment to None (<doctest test.test_syntax[32]>, line 1)

   235 >>> f() += 1

   236 Traceback (most recent call last):

   237 SyntaxError: illegal expression for augmented assignment (<doctest test.test_syntax[33]>, line 1)

   238 

   239 

   240 Test continue in finally in weird combinations.

   241 

   242 continue in for loop under finally shouuld be ok.

   243 

   244     >>> def test():

   245     ...     try:

   246     ...         pass

   247     ...     finally:

   248     ...         for abc in range(10):

   249     ...             continue

   250     ...     print abc

   251     >>> test()

   252     9

   253 

   254 Start simple, a continue in a finally should not be allowed.

   255 

   256     >>> def test():

   257     ...    for abc in range(10):

   258     ...        try:

   259     ...            pass

   260     ...        finally:

   261     ...            continue

   262     ...

   263     Traceback (most recent call last):

   264       ...

   265     SyntaxError: 'continue' not supported inside 'finally' clause (<doctest test.test_syntax[36]>, line 6)

   266 

   267 This is essentially a continue in a finally which should not be allowed.

   268 

   269     >>> def test():

   270     ...    for abc in range(10):

   271     ...        try:

   272     ...            pass

   273     ...        finally:

   274     ...            try:

   275     ...                continue

   276     ...            except:

   277     ...                pass

   278     Traceback (most recent call last):

   279       ...

   280     SyntaxError: 'continue' not supported inside 'finally' clause (<doctest test.test_syntax[37]>, line 7)

   281 

   282     >>> def foo():

   283     ...   try:

   284     ...     pass

   285     ...   finally:

   286     ...     continue

   287     Traceback (most recent call last):

   288       ...

   289     SyntaxError: 'continue' not supported inside 'finally' clause (<doctest test.test_syntax[38]>, line 5)

   290 

   291     >>> def foo():

   292     ...   for a in ():

   293     ...     try: pass

   294     ...     finally: continue

   295     Traceback (most recent call last):

   296       ...

   297     SyntaxError: 'continue' not supported inside 'finally' clause (<doctest test.test_syntax[39]>, line 4)

   298 

   299     >>> def foo():

   300     ...  for a in ():

   301     ...   try: pass

   302     ...   finally:

   303     ...    try:

   304     ...     continue

   305     ...    finally: pass

   306     Traceback (most recent call last):

   307       ...

   308     SyntaxError: 'continue' not supported inside 'finally' clause (<doctest test.test_syntax[40]>, line 6)

   309 

   310     >>> def foo():

   311     ...  for a in ():

   312     ...   try: pass

   313     ...   finally:

   314     ...    try:

   315     ...     pass

   316     ...    except:

   317     ...     continue

   318     Traceback (most recent call last):

   319       ...

   320     SyntaxError: 'continue' not supported inside 'finally' clause (<doctest test.test_syntax[41]>, line 8)

   321 

   322 There is one test for a break that is not in a loop.  The compiler

   323 uses a single data structure to keep track of try-finally and loops,

   324 so we need to be sure that a break is actually inside a loop.  If it

   325 isn't, there should be a syntax error.

   326 

   327    >>> try:

   328    ...     print 1

   329    ...     break

   330    ...     print 2

   331    ... finally:

   332    ...     print 3

   333    Traceback (most recent call last):

   334      ...

   335    SyntaxError: 'break' outside loop (<doctest test.test_syntax[42]>, line 3)

   336 

   337 This should probably raise a better error than a SystemError (or none at all).

   338 In 2.5 there was a missing exception and an assert was triggered in a debug

   339 build.  The number of blocks must be greater than CO_MAXBLOCKS.  SF #1565514

   340 

   341    >>> while 1:

   342    ...  while 2:

   343    ...   while 3:

   344    ...    while 4:

   345    ...     while 5:

   346    ...      while 6:

   347    ...       while 8:

   348    ...        while 9:

   349    ...         while 10:

   350    ...          while 11:

   351    ...           while 12:

   352    ...            while 13:

   353    ...             while 14:

   354    ...              while 15:

   355    ...               while 16:

   356    ...                while 17:

   357    ...                 while 18:

   358    ...                  while 19:

   359    ...                   while 20:

   360    ...                    while 21:

   361    ...                     while 22:

   362    ...                      break

   363    Traceback (most recent call last):

   364      ...

   365    SystemError: too many statically nested blocks

   366 

   367 This tests assignment-context; there was a bug in Python 2.5 where compiling

   368 a complex 'if' (one with 'elif') would fail to notice an invalid suite,

   369 leading to spurious errors.

   370 

   371    >>> if 1:

   372    ...   x() = 1

   373    ... elif 1:

   374    ...   pass

   375    Traceback (most recent call last):

   376      ...

   377    SyntaxError: can't assign to function call (<doctest test.test_syntax[44]>, line 2)

   378 

   379    >>> if 1:

   380    ...   pass

   381    ... elif 1:

   382    ...   x() = 1

   383    Traceback (most recent call last):

   384      ...

   385    SyntaxError: can't assign to function call (<doctest test.test_syntax[45]>, line 4)

   386 

   387    >>> if 1:

   388    ...   x() = 1

   389    ... elif 1:

   390    ...   pass

   391    ... else:

   392    ...   pass

   393    Traceback (most recent call last):

   394      ...

   395    SyntaxError: can't assign to function call (<doctest test.test_syntax[46]>, line 2)

   396 

   397    >>> if 1:

   398    ...   pass

   399    ... elif 1:

   400    ...   x() = 1

   401    ... else:

   402    ...   pass

   403    Traceback (most recent call last):

   404      ...

   405    SyntaxError: can't assign to function call (<doctest test.test_syntax[47]>, line 4)

   406 

   407    >>> if 1:

   408    ...   pass

   409    ... elif 1:

   410    ...   pass

   411    ... else:

   412    ...   x() = 1

   413    Traceback (most recent call last):

   414      ...

   415    SyntaxError: can't assign to function call (<doctest test.test_syntax[48]>, line 6)

   416 

   417 """

   418 

   419 import re

   420 import unittest

   421 import warnings

   422 

   423 from test import test_support

   424 

   425 class SyntaxTestCase(unittest.TestCase):

   426 

   427     def _check_error(self, code, errtext,

   428                      filename="<testcase>", mode="exec", subclass=None):

   429         """Check that compiling code raises SyntaxError with errtext.

   430 

   431         errtest is a regular expression that must be present in the

   432         test of the exception raised.  If subclass is specified it

   433         is the expected subclass of SyntaxError (e.g. IndentationError).

   434         """

   435         try:

   436             compile(code, filename, mode)

   437         except SyntaxError, err:

   438             if subclass and not isinstance(err, subclass):

   439                 self.fail("SyntaxError is not a %s" % subclass.__name__)

   440             mo = re.search(errtext, str(err))

   441             if mo is None:

   442                 self.fail("SyntaxError did not contain '%r'" % (errtext,))

   443         else:

   444             self.fail("compile() did not raise SyntaxError")

   445 

   446     def test_assign_call(self):

   447         self._check_error("f() = 1", "assign")

   448 

   449     def test_assign_del(self):

   450         self._check_error("del f()", "delete")

   451 

   452     def test_global_err_then_warn(self):

   453         # Bug tickler:  The SyntaxError raised for one global statement

   454         # shouldn't be clobbered by a SyntaxWarning issued for a later one.

   455         source = re.sub('(?m)^ *:', '', """\

   456             :def error(a):

   457             :    global a  # SyntaxError

   458             :def warning():

   459             :    b = 1

   460             :    global b  # SyntaxWarning

   461             :""")

   462         warnings.filterwarnings(action='ignore', category=SyntaxWarning)

   463         self._check_error(source, "global")

   464         warnings.filters.pop(0)

   465 

   466     def test_break_outside_loop(self):

   467         self._check_error("break", "outside loop")

   468 

   469     def test_delete_deref(self):

   470         source = re.sub('(?m)^ *:', '', """\

   471             :def foo(x):

   472             :  def bar():

   473             :    print x

   474             :  del x

   475             :""")

   476         self._check_error(source, "nested scope")

   477 

   478     def test_unexpected_indent(self):

   479         self._check_error("foo()\n bar()\n", "unexpected indent",

   480                           subclass=IndentationError)

   481 

   482     def test_no_indent(self):

   483         self._check_error("if 1:\nfoo()", "expected an indented block",

   484                           subclass=IndentationError)

   485 

   486     def test_bad_outdent(self):

   487         self._check_error("if 1:\n  foo()\n bar()",

   488                           "unindent does not match .* level",

   489                           subclass=IndentationError)

   490 

   491     def test_kwargs_last(self):

   492         self._check_error("int(base=10, '2')", "non-keyword arg")

   493 

   494 def test_main():

   495     test_support.run_unittest(SyntaxTestCase)

   496     from test import test_syntax

   497     test_support.run_doctest(test_syntax, verbosity=True)

   498 

   499 if __name__ == "__main__":

   500     test_main()