| 1 |
"Test pyparse, coverage 96%." |
| 2 |
|
| 3 |
from idlelib import pyparse |
| 4 |
import unittest |
| 5 |
from collections import namedtuple |
| 6 |
|
| 7 |
|
| 8 |
class ParseMapTest(unittest.TestCase): |
| 9 |
|
| 10 |
def test_parsemap(self): |
| 11 |
keepwhite = {ord(c): ord(c) for c in ' \t\n\r'} |
| 12 |
mapping = pyparse.ParseMap(keepwhite) |
| 13 |
self.assertEqual(mapping[ord('\t')], ord('\t')) |
| 14 |
self.assertEqual(mapping[ord('a')], ord('x')) |
| 15 |
self.assertEqual(mapping[1000], ord('x')) |
| 16 |
|
| 17 |
def test_trans(self): |
| 18 |
# trans is the production instance of ParseMap, used in _study1 |
| 19 |
parser = pyparse.Parser(4, 4) |
| 20 |
self.assertEqual('\t a([{b}])b"c\'d\n'.translate(pyparse.trans), |
| 21 |
'xxx(((x)))x"x\'x\n') |
| 22 |
|
| 23 |
|
| 24 |
class PyParseTest(unittest.TestCase): |
| 25 |
|
| 26 |
@classmethod |
| 27 |
def setUpClass(cls): |
| 28 |
cls.parser = pyparse.Parser(indentwidth=4, tabwidth=4) |
| 29 |
|
| 30 |
@classmethod |
| 31 |
def tearDownClass(cls): |
| 32 |
del cls.parser |
| 33 |
|
| 34 |
def test_init(self): |
| 35 |
self.assertEqual(self.parser.indentwidth, 4) |
| 36 |
self.assertEqual(self.parser.tabwidth, 4) |
| 37 |
|
| 38 |
def test_set_code(self): |
| 39 |
eq = self.assertEqual |
| 40 |
p = self.parser |
| 41 |
setcode = p.set_code |
| 42 |
|
| 43 |
# Not empty and doesn't end with newline. |
| 44 |
with self.assertRaises(AssertionError): |
| 45 |
setcode('a') |
| 46 |
|
| 47 |
tests = ('', |
| 48 |
'a\n') |
| 49 |
|
| 50 |
for string in tests: |
| 51 |
with self.subTest(string=string): |
| 52 |
setcode(string) |
| 53 |
eq(p.code, string) |
| 54 |
eq(p.study_level, 0) |
| 55 |
|
| 56 |
def test_find_good_parse_start(self): |
| 57 |
eq = self.assertEqual |
| 58 |
p = self.parser |
| 59 |
setcode = p.set_code |
| 60 |
start = p.find_good_parse_start |
| 61 |
def char_in_string_false(index): return False |
| 62 |
|
| 63 |
# First line starts with 'def' and ends with ':', then 0 is the pos. |
| 64 |
setcode('def spam():\n') |
| 65 |
eq(start(char_in_string_false), 0) |
| 66 |
|
| 67 |
# First line begins with a keyword in the list and ends |
| 68 |
# with an open brace, then 0 is the pos. This is how |
| 69 |
# hyperparser calls this function as the newline is not added |
| 70 |
# in the editor, but rather on the call to setcode. |
| 71 |
setcode('class spam( ' + ' \n') |
| 72 |
eq(start(char_in_string_false), 0) |
| 73 |
|
| 74 |
# Split def across lines. |
| 75 |
setcode('"""This is a module docstring"""\n' |
| 76 |
'class C:\n' |
| 77 |
' def __init__(self, a,\n' |
| 78 |
' b=True):\n' |
| 79 |
' pass\n' |
| 80 |
) |
| 81 |
pos0, pos = 33, 42 # Start of 'class...', ' def' lines. |
| 82 |
|
| 83 |
# Passing no value or non-callable should fail (issue 32989). |
| 84 |
with self.assertRaises(TypeError): |
| 85 |
start() |
| 86 |
with self.assertRaises(TypeError): |
| 87 |
start(False) |
| 88 |
|
| 89 |
# Make text look like a string. This returns pos as the start |
| 90 |
# position, but it's set to None. |
| 91 |
self.assertIsNone(start(is_char_in_string=lambda index: True)) |
| 92 |
|
| 93 |
# Make all text look like it's not in a string. This means that it |
| 94 |
# found a good start position. |
| 95 |
eq(start(char_in_string_false), pos) |
| 96 |
|
| 97 |
# If the beginning of the def line is not in a string, then it |
| 98 |
# returns that as the index. |
| 99 |
eq(start(is_char_in_string=lambda index: index > pos), pos) |
| 100 |
# If the beginning of the def line is in a string, then it |
| 101 |
# looks for a previous index. |
| 102 |
eq(start(is_char_in_string=lambda index: index >= pos), pos0) |
| 103 |
# If everything before the 'def' is in a string, then returns None. |
| 104 |
# The non-continuation def line returns 44 (see below). |
| 105 |
eq(start(is_char_in_string=lambda index: index < pos), None) |
| 106 |
|
| 107 |
# Code without extra line break in def line - mostly returns the same |
| 108 |
# values. |
| 109 |
setcode('"""This is a module docstring"""\n' |
| 110 |
'class C:\n' |
| 111 |
' def __init__(self, a, b=True):\n' |
| 112 |
' pass\n' |
| 113 |
) # Does not affect class, def positions. |
| 114 |
eq(start(char_in_string_false), pos) |
| 115 |
eq(start(is_char_in_string=lambda index: index > pos), pos) |
| 116 |
eq(start(is_char_in_string=lambda index: index >= pos), pos0) |
| 117 |
# When the def line isn't split, this returns which doesn't match the |
| 118 |
# split line test. |
| 119 |
eq(start(is_char_in_string=lambda index: index < pos), pos) |
| 120 |
|
| 121 |
def test_set_lo(self): |
| 122 |
code = ( |
| 123 |
'"""This is a module docstring"""\n' |
| 124 |
'class C:\n' |
| 125 |
' def __init__(self, a,\n' |
| 126 |
' b=True):\n' |
| 127 |
' pass\n' |
| 128 |
) |
| 129 |
pos = 42 |
| 130 |
p = self.parser |
| 131 |
p.set_code(code) |
| 132 |
|
| 133 |
# Previous character is not a newline. |
| 134 |
with self.assertRaises(AssertionError): |
| 135 |
p.set_lo(5) |
| 136 |
|
| 137 |
# A value of 0 doesn't change self.code. |
| 138 |
p.set_lo(0) |
| 139 |
self.assertEqual(p.code, code) |
| 140 |
|
| 141 |
# An index that is preceded by a newline. |
| 142 |
p.set_lo(pos) |
| 143 |
self.assertEqual(p.code, code[pos:]) |
| 144 |
|
| 145 |
def test_study1(self): |
| 146 |
eq = self.assertEqual |
| 147 |
p = self.parser |
| 148 |
setcode = p.set_code |
| 149 |
study = p._study1 |
| 150 |
|
| 151 |
(NONE, BACKSLASH, FIRST, NEXT, BRACKET) = range(5) |
| 152 |
TestInfo = namedtuple('TestInfo', ['string', 'goodlines', |
| 153 |
'continuation']) |
| 154 |
tests = ( |
| 155 |
TestInfo('', [0], NONE), |
| 156 |
# Docstrings. |
| 157 |
TestInfo('"""This is a complete docstring."""\n', [0, 1], NONE), |
| 158 |
TestInfo("'''This is a complete docstring.'''\n", [0, 1], NONE), |
| 159 |
TestInfo('"""This is a continued docstring.\n', [0, 1], FIRST), |
| 160 |
TestInfo("'''This is a continued docstring.\n", [0, 1], FIRST), |
| 161 |
TestInfo('"""Closing quote does not match."\n', [0, 1], FIRST), |
| 162 |
TestInfo('"""Bracket in docstring [\n', [0, 1], FIRST), |
| 163 |
TestInfo("'''Incomplete two line docstring.\n\n", [0, 2], NEXT), |
| 164 |
# Single-quoted strings. |
| 165 |
TestInfo('"This is a complete string."\n', [0, 1], NONE), |
| 166 |
TestInfo('"This is an incomplete string.\n', [0, 1], NONE), |
| 167 |
TestInfo("'This is more incomplete.\n\n", [0, 1, 2], NONE), |
| 168 |
# Comment (backslash does not continue comments). |
| 169 |
TestInfo('# Comment\\\n', [0, 1], NONE), |
| 170 |
# Brackets. |
| 171 |
TestInfo('("""Complete string in bracket"""\n', [0, 1], BRACKET), |
| 172 |
TestInfo('("""Open string in bracket\n', [0, 1], FIRST), |
| 173 |
TestInfo('a = (1 + 2) - 5 *\\\n', [0, 1], BACKSLASH), # No bracket. |
| 174 |
TestInfo('\n def function1(self, a,\n b):\n', |
| 175 |
[0, 1, 3], NONE), |
| 176 |
TestInfo('\n def function1(self, a,\\\n', [0, 1, 2], BRACKET), |
| 177 |
TestInfo('\n def function1(self, a,\n', [0, 1, 2], BRACKET), |
| 178 |
TestInfo('())\n', [0, 1], NONE), # Extra closer. |
| 179 |
TestInfo(')(\n', [0, 1], BRACKET), # Extra closer. |
| 180 |
# For the mismatched example, it doesn't look like continuation. |
| 181 |
TestInfo('{)(]\n', [0, 1], NONE), # Mismatched. |
| 182 |
) |
| 183 |
|
| 184 |
for test in tests: |
| 185 |
with self.subTest(string=test.string): |
| 186 |
setcode(test.string) # resets study_level |
| 187 |
study() |
| 188 |
eq(p.study_level, 1) |
| 189 |
eq(p.goodlines, test.goodlines) |
| 190 |
eq(p.continuation, test.continuation) |
| 191 |
|
| 192 |
# Called again, just returns without reprocessing. |
| 193 |
self.assertIsNone(study()) |
| 194 |
|
| 195 |
def test_get_continuation_type(self): |
| 196 |
eq = self.assertEqual |
| 197 |
p = self.parser |
| 198 |
setcode = p.set_code |
| 199 |
gettype = p.get_continuation_type |
| 200 |
|
| 201 |
(NONE, BACKSLASH, FIRST, NEXT, BRACKET) = range(5) |
| 202 |
TestInfo = namedtuple('TestInfo', ['string', 'continuation']) |
| 203 |
tests = ( |
| 204 |
TestInfo('', NONE), |
| 205 |
TestInfo('"""This is a continuation docstring.\n', FIRST), |
| 206 |
TestInfo("'''This is a multiline-continued docstring.\n\n", NEXT), |
| 207 |
TestInfo('a = (1 + 2) - 5 *\\\n', BACKSLASH), |
| 208 |
TestInfo('\n def function1(self, a,\\\n', BRACKET) |
| 209 |
) |
| 210 |
|
| 211 |
for test in tests: |
| 212 |
with self.subTest(string=test.string): |
| 213 |
setcode(test.string) |
| 214 |
eq(gettype(), test.continuation) |
| 215 |
|
| 216 |
def test_study2(self): |
| 217 |
eq = self.assertEqual |
| 218 |
p = self.parser |
| 219 |
setcode = p.set_code |
| 220 |
study = p._study2 |
| 221 |
|
| 222 |
TestInfo = namedtuple('TestInfo', ['string', 'start', 'end', 'lastch', |
| 223 |
'openbracket', 'bracketing']) |
| 224 |
tests = ( |
| 225 |
TestInfo('', 0, 0, '', None, ((0, 0),)), |
| 226 |
TestInfo("'''This is a multiline continuation docstring.\n\n", |
| 227 |
0, 48, "'", None, ((0, 0), (0, 1), (48, 0))), |
| 228 |
TestInfo(' # Comment\\\n', |
| 229 |
0, 12, '', None, ((0, 0), (1, 1), (12, 0))), |
| 230 |
# A comment without a space is a special case |
| 231 |
TestInfo(' #Comment\\\n', |
| 232 |
0, 0, '', None, ((0, 0),)), |
| 233 |
# Backslash continuation. |
| 234 |
TestInfo('a = (1 + 2) - 5 *\\\n', |
| 235 |
0, 19, '*', None, ((0, 0), (4, 1), (11, 0))), |
| 236 |
# Bracket continuation with close. |
| 237 |
TestInfo('\n def function1(self, a,\n b):\n', |
| 238 |
1, 48, ':', None, ((1, 0), (17, 1), (46, 0))), |
| 239 |
# Bracket continuation with unneeded backslash. |
| 240 |
TestInfo('\n def function1(self, a,\\\n', |
| 241 |
1, 28, ',', 17, ((1, 0), (17, 1))), |
| 242 |
# Bracket continuation. |
| 243 |
TestInfo('\n def function1(self, a,\n', |
| 244 |
1, 27, ',', 17, ((1, 0), (17, 1))), |
| 245 |
# Bracket continuation with comment at end of line with text. |
| 246 |
TestInfo('\n def function1(self, a, # End of line comment.\n', |
| 247 |
1, 51, ',', 17, ((1, 0), (17, 1), (28, 2), (51, 1))), |
| 248 |
# Multi-line statement with comment line in between code lines. |
| 249 |
TestInfo(' a = ["first item",\n # Comment line\n "next item",\n', |
| 250 |
0, 55, ',', 6, ((0, 0), (6, 1), (7, 2), (19, 1), |
| 251 |
(23, 2), (38, 1), (42, 2), (53, 1))), |
| 252 |
TestInfo('())\n', |
| 253 |
0, 4, ')', None, ((0, 0), (0, 1), (2, 0), (3, 0))), |
| 254 |
TestInfo(')(\n', 0, 3, '(', 1, ((0, 0), (1, 0), (1, 1))), |
| 255 |
# Wrong closers still decrement stack level. |
| 256 |
TestInfo('{)(]\n', |
| 257 |
0, 5, ']', None, ((0, 0), (0, 1), (2, 0), (2, 1), (4, 0))), |
| 258 |
# Character after backslash. |
| 259 |
TestInfo(':\\a\n', 0, 4, '\\a', None, ((0, 0),)), |
| 260 |
TestInfo('\n', 0, 0, '', None, ((0, 0),)), |
| 261 |
) |
| 262 |
|
| 263 |
for test in tests: |
| 264 |
with self.subTest(string=test.string): |
| 265 |
setcode(test.string) |
| 266 |
study() |
| 267 |
eq(p.study_level, 2) |
| 268 |
eq(p.stmt_start, test.start) |
| 269 |
eq(p.stmt_end, test.end) |
| 270 |
eq(p.lastch, test.lastch) |
| 271 |
eq(p.lastopenbracketpos, test.openbracket) |
| 272 |
eq(p.stmt_bracketing, test.bracketing) |
| 273 |
|
| 274 |
# Called again, just returns without reprocessing. |
| 275 |
self.assertIsNone(study()) |
| 276 |
|
| 277 |
def test_get_num_lines_in_stmt(self): |
| 278 |
eq = self.assertEqual |
| 279 |
p = self.parser |
| 280 |
setcode = p.set_code |
| 281 |
getlines = p.get_num_lines_in_stmt |
| 282 |
|
| 283 |
TestInfo = namedtuple('TestInfo', ['string', 'lines']) |
| 284 |
tests = ( |
| 285 |
TestInfo('[x for x in a]\n', 1), # Closed on one line. |
| 286 |
TestInfo('[x\nfor x in a\n', 2), # Not closed. |
| 287 |
TestInfo('[x\\\nfor x in a\\\n', 2), # "", unneeded backslashes. |
| 288 |
TestInfo('[x\nfor x in a\n]\n', 3), # Closed on multi-line. |
| 289 |
TestInfo('\n"""Docstring comment L1"""\nL2\nL3\nL4\n', 1), |
| 290 |
TestInfo('\n"""Docstring comment L1\nL2"""\nL3\nL4\n', 1), |
| 291 |
TestInfo('\n"""Docstring comment L1\\\nL2\\\nL3\\\nL4\\\n', 4), |
| 292 |
TestInfo('\n\n"""Docstring comment L1\\\nL2\\\nL3\\\nL4\\\n"""\n', 5) |
| 293 |
) |
| 294 |
|
| 295 |
# Blank string doesn't have enough elements in goodlines. |
| 296 |
setcode('') |
| 297 |
with self.assertRaises(IndexError): |
| 298 |
getlines() |
| 299 |
|
| 300 |
for test in tests: |
| 301 |
with self.subTest(string=test.string): |
| 302 |
setcode(test.string) |
| 303 |
eq(getlines(), test.lines) |
| 304 |
|
| 305 |
def test_compute_bracket_indent(self): |
| 306 |
eq = self.assertEqual |
| 307 |
p = self.parser |
| 308 |
setcode = p.set_code |
| 309 |
indent = p.compute_bracket_indent |
| 310 |
|
| 311 |
TestInfo = namedtuple('TestInfo', ['string', 'spaces']) |
| 312 |
tests = ( |
| 313 |
TestInfo('def function1(self, a,\n', 14), |
| 314 |
# Characters after bracket. |
| 315 |
TestInfo('\n def function1(self, a,\n', 18), |
| 316 |
TestInfo('\n\tdef function1(self, a,\n', 18), |
| 317 |
# No characters after bracket. |
| 318 |
TestInfo('\n def function1(\n', 8), |
| 319 |
TestInfo('\n\tdef function1(\n', 8), |
| 320 |
TestInfo('\n def function1( \n', 8), # Ignore extra spaces. |
| 321 |
TestInfo('[\n"first item",\n # Comment line\n "next item",\n', 0), |
| 322 |
TestInfo('[\n "first item",\n # Comment line\n "next item",\n', 2), |
| 323 |
TestInfo('["first item",\n # Comment line\n "next item",\n', 1), |
| 324 |
TestInfo('(\n', 4), |
| 325 |
TestInfo('(a\n', 1), |
| 326 |
) |
| 327 |
|
| 328 |
# Must be C_BRACKET continuation type. |
| 329 |
setcode('def function1(self, a, b):\n') |
| 330 |
with self.assertRaises(AssertionError): |
| 331 |
indent() |
| 332 |
|
| 333 |
for test in tests: |
| 334 |
setcode(test.string) |
| 335 |
eq(indent(), test.spaces) |
| 336 |
|
| 337 |
def test_compute_backslash_indent(self): |
| 338 |
eq = self.assertEqual |
| 339 |
p = self.parser |
| 340 |
setcode = p.set_code |
| 341 |
indent = p.compute_backslash_indent |
| 342 |
|
| 343 |
# Must be C_BACKSLASH continuation type. |
| 344 |
errors = (('def function1(self, a, b\\\n'), # Bracket. |
| 345 |
(' """ (\\\n'), # Docstring. |
| 346 |
('a = #\\\n'), # Inline comment. |
| 347 |
) |
| 348 |
for string in errors: |
| 349 |
with self.subTest(string=string): |
| 350 |
setcode(string) |
| 351 |
with self.assertRaises(AssertionError): |
| 352 |
indent() |
| 353 |
|
| 354 |
TestInfo = namedtuple('TestInfo', ('string', 'spaces')) |
| 355 |
tests = (TestInfo('a = (1 + 2) - 5 *\\\n', 4), |
| 356 |
TestInfo('a = 1 + 2 - 5 *\\\n', 4), |
| 357 |
TestInfo(' a = 1 + 2 - 5 *\\\n', 8), |
| 358 |
TestInfo(' a = "spam"\\\n', 6), |
| 359 |
TestInfo(' a = \\\n"a"\\\n', 4), |
| 360 |
TestInfo(' a = #\\\n"a"\\\n', 5), |
| 361 |
TestInfo('a == \\\n', 2), |
| 362 |
TestInfo('a != \\\n', 2), |
| 363 |
# Difference between containing = and those not. |
| 364 |
TestInfo('\\\n', 2), |
| 365 |
TestInfo(' \\\n', 6), |
| 366 |
TestInfo('\t\\\n', 6), |
| 367 |
TestInfo('a\\\n', 3), |
| 368 |
TestInfo('{}\\\n', 4), |
| 369 |
TestInfo('(1 + 2) - 5 *\\\n', 3), |
| 370 |
) |
| 371 |
for test in tests: |
| 372 |
with self.subTest(string=test.string): |
| 373 |
setcode(test.string) |
| 374 |
eq(indent(), test.spaces) |
| 375 |
|
| 376 |
def test_get_base_indent_string(self): |
| 377 |
eq = self.assertEqual |
| 378 |
p = self.parser |
| 379 |
setcode = p.set_code |
| 380 |
baseindent = p.get_base_indent_string |
| 381 |
|
| 382 |
TestInfo = namedtuple('TestInfo', ['string', 'indent']) |
| 383 |
tests = (TestInfo('', ''), |
| 384 |
TestInfo('def a():\n', ''), |
| 385 |
TestInfo('\tdef a():\n', '\t'), |
| 386 |
TestInfo(' def a():\n', ' '), |
| 387 |
TestInfo(' def a(\n', ' '), |
| 388 |
TestInfo('\t\n def a(\n', ' '), |
| 389 |
TestInfo('\t\n # Comment.\n', ' '), |
| 390 |
) |
| 391 |
|
| 392 |
for test in tests: |
| 393 |
with self.subTest(string=test.string): |
| 394 |
setcode(test.string) |
| 395 |
eq(baseindent(), test.indent) |
| 396 |
|
| 397 |
def test_is_block_opener(self): |
| 398 |
yes = self.assertTrue |
| 399 |
no = self.assertFalse |
| 400 |
p = self.parser |
| 401 |
setcode = p.set_code |
| 402 |
opener = p.is_block_opener |
| 403 |
|
| 404 |
TestInfo = namedtuple('TestInfo', ['string', 'assert_']) |
| 405 |
tests = ( |
| 406 |
TestInfo('def a():\n', yes), |
| 407 |
TestInfo('\n def function1(self, a,\n b):\n', yes), |
| 408 |
TestInfo(':\n', yes), |
| 409 |
TestInfo('a:\n', yes), |
| 410 |
TestInfo('):\n', yes), |
| 411 |
TestInfo('(:\n', yes), |
| 412 |
TestInfo('":\n', no), |
| 413 |
TestInfo('\n def function1(self, a,\n', no), |
| 414 |
TestInfo('def function1(self, a):\n pass\n', no), |
| 415 |
TestInfo('# A comment:\n', no), |
| 416 |
TestInfo('"""A docstring:\n', no), |
| 417 |
TestInfo('"""A docstring:\n', no), |
| 418 |
) |
| 419 |
|
| 420 |
for test in tests: |
| 421 |
with self.subTest(string=test.string): |
| 422 |
setcode(test.string) |
| 423 |
test.assert_(opener()) |
| 424 |
|
| 425 |
def test_is_block_closer(self): |
| 426 |
yes = self.assertTrue |
| 427 |
no = self.assertFalse |
| 428 |
p = self.parser |
| 429 |
setcode = p.set_code |
| 430 |
closer = p.is_block_closer |
| 431 |
|
| 432 |
TestInfo = namedtuple('TestInfo', ['string', 'assert_']) |
| 433 |
tests = ( |
| 434 |
TestInfo('return\n', yes), |
| 435 |
TestInfo('\tbreak\n', yes), |
| 436 |
TestInfo(' continue\n', yes), |
| 437 |
TestInfo(' raise\n', yes), |
| 438 |
TestInfo('pass \n', yes), |
| 439 |
TestInfo('pass\t\n', yes), |
| 440 |
TestInfo('return #\n', yes), |
| 441 |
TestInfo('raised\n', no), |
| 442 |
TestInfo('returning\n', no), |
| 443 |
TestInfo('# return\n', no), |
| 444 |
TestInfo('"""break\n', no), |
| 445 |
TestInfo('"continue\n', no), |
| 446 |
TestInfo('def function1(self, a):\n pass\n', yes), |
| 447 |
) |
| 448 |
|
| 449 |
for test in tests: |
| 450 |
with self.subTest(string=test.string): |
| 451 |
setcode(test.string) |
| 452 |
test.assert_(closer()) |
| 453 |
|
| 454 |
def test_get_last_stmt_bracketing(self): |
| 455 |
eq = self.assertEqual |
| 456 |
p = self.parser |
| 457 |
setcode = p.set_code |
| 458 |
bracketing = p.get_last_stmt_bracketing |
| 459 |
|
| 460 |
TestInfo = namedtuple('TestInfo', ['string', 'bracket']) |
| 461 |
tests = ( |
| 462 |
TestInfo('', ((0, 0),)), |
| 463 |
TestInfo('a\n', ((0, 0),)), |
| 464 |
TestInfo('()()\n', ((0, 0), (0, 1), (2, 0), (2, 1), (4, 0))), |
| 465 |
TestInfo('(\n)()\n', ((0, 0), (0, 1), (3, 0), (3, 1), (5, 0))), |
| 466 |
TestInfo('()\n()\n', ((3, 0), (3, 1), (5, 0))), |
| 467 |
TestInfo('()(\n)\n', ((0, 0), (0, 1), (2, 0), (2, 1), (5, 0))), |
| 468 |
TestInfo('(())\n', ((0, 0), (0, 1), (1, 2), (3, 1), (4, 0))), |
| 469 |
TestInfo('(\n())\n', ((0, 0), (0, 1), (2, 2), (4, 1), (5, 0))), |
| 470 |
# Same as matched test. |
| 471 |
TestInfo('{)(]\n', ((0, 0), (0, 1), (2, 0), (2, 1), (4, 0))), |
| 472 |
TestInfo('(((())\n', |
| 473 |
((0, 0), (0, 1), (1, 2), (2, 3), (3, 4), (5, 3), (6, 2))), |
| 474 |
) |
| 475 |
|
| 476 |
for test in tests: |
| 477 |
with self.subTest(string=test.string): |
| 478 |
setcode(test.string) |
| 479 |
eq(bracketing(), test.bracket) |
| 480 |
|
| 481 |
|
| 482 |
if __name__ == '__main__': |
| 483 |
unittest.main(verbosity=2) |