PageRenderTime 50ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/tests/reader-tests.py

http://github.com/halgari/clojure-py
Python | 629 lines | 534 code | 15 blank | 80 comment | 19 complexity | 52cb0c4f9e0582877ec84066c0758c29 MD5 | raw file
    

  1. #!/usr/bin/python -t
    2. 

  2. # -*- coding: utf-8 -*-
    3. 

  3. 

  4. """reader-tests.py
    5. 

    6. 

  6. Friday, March 16 2012
    7. 

  7. """
    8. 

    9. 

  9. import re
    10. 

  10. import string
    11. 

  11. import unittest
    12. 

  12. 

  13. from random import choice
    14. 

  14. from fractions import Fraction
    15. 

  15. from clojure.lang.lispreader import read, readDelimitedList
    16. 

  16. from clojure.lang.symbol import Symbol
    17. 

  17. from clojure.lang.ipersistentlist import IPersistentList
    18. 

  18. from clojure.lang.persistentlist import PersistentList
    19. 

  19. from clojure.lang.persistentlist import EmptyList
    20. 

  20. from clojure.lang.persistentvector import PersistentVector
    21. 

  21. from clojure.lang.persistenthashmap import PersistentHashMap
    22. 

  22. from clojure.lang.persistenthashset import PersistentHashSet
    23. 

  23. from clojure.lang.fileseq import StringReader
    24. 

  24. from clojure.lang.cljexceptions import ReaderException
    25. 

  25. from clojure.lang.pytypes import *
    26. 

  26. 

  27. 

  28. # reader returns this unique *value* if it's out of characters
    29. 

  29. EOF = object()
    30. 

  30. # A unique *type* to return at the EOF.
    31. 

  31. # For use in testReturnedType_PASS().
    32. 

  32. class Sentinal(object): pass
    33. 

  33. sentinal = Sentinal()
    34. 

  34. sentinalType = type(sentinal)
    35. 

  35. 

  36. class TestReader(unittest.TestCase):
    37. 

  37.     # literal integers
    38. 

  38.     def testIntegerReader_PASS(self):
    39. 

  39.         # base 8
    40. 

  40.         for k, v in base8IntegerMap_PASS.items():
    41. 

  41.             r = StringReader(k)
    42. 

  42.             self.assertEqual(read(r, False, EOF, False), v)
    43. 

  43.         # base 10
    44. 

  44.         for k, v in base10IntegerMap_PASS.items():
    45. 

  45.             r = StringReader(k)
    46. 

  46.             self.assertEqual(read(r, False, EOF, False), v)
    47. 

  47.         # base 16
    48. 

  48.         for k, v in base16IntegerMap_PASS.items():
    49. 

  49.             r = StringReader(k)
    50. 

  50.             self.assertEqual(read(r, False, EOF, False), v)
    51. 

  51.         # base N
    52. 

  52.         for k, v in baseNIntegerMap_PASS.items():
    53. 

  53.             r = StringReader(k)
    54. 

  54.             self.assertEqual(read(r, False, EOF, False), v)
    55. 

  55.     def testIntegerReader_FAIL(self):
    56. 

  56.         for t in integer_FAIL:
    57. 

  57.             r = StringReader(t)
    58. 

  58.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    59. 

  59.     # literal floating point
    60. 

  60.     def testFloatingPointReader_PASS(self):
    61. 

  61.         for k, v in floatingPointMap_PASS.items():
    62. 

  62.             r = StringReader(k)
    63. 

  63.             self.assertEqual(read(r, False, EOF, False), v)
    64. 

  64.     def testFloatingPointReader_FAIL(self):
    65. 

  65.         for t in floatingPoint_FAIL:
    66. 

  66.             r = StringReader(t)
    67. 

  67.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    68. 

  68.     # literal ratios 
    69. 

  69.     def testRationalReader_PASS(self):
    70. 

  70.         for k, v in rationalMap_PASS.items():
    71. 

  71.             r = StringReader(k)
    72. 

  72.             self.assertEqual(read(r, False, EOF, False), v)
    73. 

  73.     def testRationalReader_FAIL(self):
    74. 

  74.         for t in rational_FAIL:
    75. 

  75.             r = StringReader(t)
    76. 

  76.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    77. 

  77.     # literal characters
    78. 

  78.     def testCharacterReader_PASS(self):
    79. 

  79.         for k, v in literalCharacterMap_PASS.items():
    80. 

  80.             r = StringReader(k)
    81. 

  81.             self.assertEqual(read(r, False, EOF, False), v)
    82. 

  82.     def testCharacterReader_FAIL(self):
    83. 

  83.         for s in literalCharacter_FAIL:
    84. 

  84.             r = StringReader(s)
    85. 

  85.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    86. 

  86.     # literal strings
    87. 

  87.     def testStringReader_PASS(self):
    88. 

  88.         for k, v in literalStringMap_PASS.items():
    89. 

  89.             r = StringReader('"' + k + '"')
    90. 

  90.             self.assertEqual(read(r, False, EOF, False), v)
    91. 

  91.     def testStringReader_FAIL(self):
    92. 

  92.         # special case, missing trailing "
    93. 

  93.         r = StringReader('"foo')
    94. 

  94.         self.assertRaises(ReaderException, read, r, False, EOF, False)
    95. 

  95.         for s in literalString_FAIL:
    96. 

  96.             r = StringReader('"' + s + '"')
    97. 

  97.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    98. 

  98.     # literal regex pattern strings
    99. 

  99.     def testRegexPattern_PASS(self):
    100. 

  100.         for k, v in regexPatternMap_PASS.items():
    101. 

  101.             r = StringReader(k)
    102. 

  102.             self.assertEqual(read(r, False, EOF, False).pattern, v.pattern)
    103. 

  103.     def testRegexPattern_FAIL(self):
    104. 

  104.         for s in regexPattern_FAIL:
    105. 

  105.             r = StringReader(s)
    106. 

  106.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    107. 

  107.     # literal raw regex pattern strings
    108. 

  108.     def testRawRegexPattern_PASS(self):
    109. 

  109.         for k, v in rawRegexPatternMap_PASS.items():
    110. 

  110.             r = StringReader(k)
    111. 

  111.             self.assertEqual(read(r, False, EOF, False).pattern, v.pattern)
    112. 

  112.     def testRawRegexPattern_FAIL(self):
    113. 

  113.         for s in rawRegexPattern_FAIL:
    114. 

  114.             r = StringReader(s)
    115. 

  115.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    116. 

  116.     # delimited lists
    117. 

  117.     def testDelimitedLists_PASS(self):
    118. 

  118.         # length test
    119. 

  119.         for k, v in delimitedListLength_PASS.items():
    120. 

  120.             r = StringReader(k)
    121. 

  121.             delim = k[-1]
    122. 

  122.             self.assertEqual(readDelimitedList(delim, r, False), v)
    123. 

  123.     # returned type tests
    124. 

  124.     def testReturnedType_PASS(self):
    125. 

  125.         for k, v in returnedType_PASS.items():
    126. 

  126.             r = StringReader(k)
    127. 

  127.             self.assertEqual(type(read(r, False, sentinal, False)), v)
    128. 

  128.     # raise on EOF
    129. 

  129.     def testEOFRaisesReaderException(self):
    130. 

  130.         r = StringReader("")
    131. 

  131.         self.assertRaises(ReaderException, read, r, True, # <- True
    132. 

  132.                           EOF, False)
    133. 

  133.     # miscellaneous failures
    134. 

  134.     def testMiscellaneous_FAIL(self):
    135. 

  135.         for s in miscellaneous_FAIL:
    136. 

  136.             r = StringReader(s)
    137. 

  137.             self.assertRaises(ReaderException, read, r, False, EOF, False)
    138. 

  138.             
    139. 

  139. 

  140. # ======================================================================
    141. 

  141. # Literal Integer Cases
    142. 

  142. # ======================================================================
    143. 

  143. 

  144. base8IntegerMap_PASS = {
    145. 

  145.     "00": 0, "-00": 0, "+00": 0,
    146. 

  146.     "012345670": 2739128, "-012345670": -2739128, "+012345670": 2739128,
    147. 

  147.     "06235436235462365452777171623500712635712365712236" :
    148. 

  148.         140667142011619517350321483099394425046406302L,
    149. 

  149.     "-06235436235462365452777171623500712635712365712236" :
    150. 

  150.         -140667142011619517350321483099394425046406302L,
    151. 

  151.     "+06235436235462365452777171623500712635712365712236" :
    152. 

  152.         140667142011619517350321483099394425046406302L,
    153. 

  153.     }
    154. 

  154. 

  155. base10IntegerMap_PASS = {
    156. 

  156.     "0" : 0, "-0" : 0, "+0" : 0,
    157. 

  157.     "1" : 1, "-1" : -1, "+1" : 1,
    158. 

  158.     "1234567890" : 1234567890,
    159. 

  159.     "-1234567890" : -1234567890,
    160. 

  160.     "+1234567890" : 1234567890,
    161. 

  161.     "20399572305720357120320399572305720357203" :
    162. 

  162.         20399572305720357120320399572305720357203L,
    163. 

  163.     "-20399572305720357120320399572305720357203" :
    164. 

  164.         -20399572305720357120320399572305720357203L,
    165. 

  165.     "+20399572305720357120320399572305720357203" :
    166. 

  166.         20399572305720357120320399572305720357203L,
    167. 

  167.     }
    168. 

  168. 

  169. base16IntegerMap_PASS = {
    170. 

  170.     "0x0" : 0, "-0x0" : 0, "+0x0" : 0,
    171. 

  171.     "0X0" : 0, "-0X0" : 0, "+0X0" : 0,
    172. 

  172.     "0x1234567890abcdefABCDEF" :
    173. 

  173.         22007822917795467892608495L,
    174. 

  174.     "-0X1234567890abcdefABCDEF" :
    175. 

  175.         -22007822917795467892608495L,
    176. 

  176.     "+0x1234567890abcdefABCDEF" :
    177. 

  177.         +22007822917795467892608495L,
    178. 

  178.     }
    179. 

  179. 

  180. def gen_baseNIntegerMap_PASS():
    181. 

  181.     """Return a dict as a string to test the base-N syntax (2r101010)
    182. 

    183. 

  183.     This map is eval'd below.
    184. 

    185. 

  185.     Each entry is of the form:
    186. 

  186.         "2r10" : 2
    187. 

  187. 

  188.     To see wtf is going on...
    189. 

  189.     >>> pprint(eval(gen_baseNIntegerMap_PASS()))"""
    190. 

  190.     # don't change the order of these
    191. 

  191.     digits = "1023456789aBcDeFgHiJkLmNoPqRsTuVwXyZ"
    192. 

  192.     entries = []
    193. 

  193.     for radix in range(2, 37):
    194. 

  194.         strDigits = digits[:radix]
    195. 

  195.         res1 = int(strDigits, radix)
    196. 

  196.         res2 = int('-' + strDigits, radix)
    197. 

  197.         entry = '"%s":%d, "%s":%d, "%s":%d' \
    198. 

  198.             % ("%d%s%s" % (radix, choice('rR'), strDigits), res1,
    199. 

  199.                "-%d%s%s" % (radix, choice('rR'), strDigits), res2,
    200. 

  200.                "+%d%s%s" % (radix, choice('rR'), strDigits), res1)
    201. 

  201.         entries.append(entry)
    202. 

  202.     return "{%s}" % ",".join(entries)
    203. 

  203. 

  204. baseNIntegerMap_PASS = eval(gen_baseNIntegerMap_PASS())
    205. 

  205. 

  206. integer_FAIL = [
    207. 

  207.     # no f suffix
    208. 

  208.     "3333f", "-3333f", "+3333f",
    209. 

  209.     # Clojure M not a suffix (yet)
    210. 

  210.     "3333M", "-3333M", "+3333M",
    211. 

  211.     # 8 not an octal digit
    212. 

  212.     "08", "-08", "+08",
    213. 

  213.     # g not a hex digit
    214. 

  214.     "0xfgaa00", "-0xfgaa00", "+0xfgaa00",
    215. 

  215.     # z not a base 32 number
    216. 

  216.     "32rzzz", "-32rzzz", "+32rzzz",
    217. 

  217.     # radix out of range [2, 36]
    218. 

  218.      "1r0", "-1r0", "+1r0", "37r0", "-37r0", "+37r0",
    219. 

  219.     ]
    220. 

  220. 

  221. # ======================================================================
    222. 

  222. # Literal Floating Point Cases
    223. 

  223. # ======================================================================
    224. 

  224. 

  225. floatingPointMap_PASS = {
    226. 

  226.     # no decimal, exponent
    227. 

  227.     "0e0" : 0.0, "-0e0" : 0.0, "+0e0" : 0.0,
    228. 

  228.     "0e-0" : 0.0, "-0e-0" : 0.0, "+0e-0" : 0.0,
    229. 

  229.     "0E-0" : 0.0, "-0E-0" : 0.0, "+0E-0" : 0.0,
    230. 

  230.     "0e+0" : 0.0, "-0e+0" : 0.0, "+0e+0" : 0.0,
    231. 

  231.     "0E+0" : 0.0, "-0E+0" : 0.0, "+0E+0" : 0.0,
    232. 

  232.     # with decimal, no digit after decimal, exponent
    233. 

  233.     "0." : 0.0, "-0." : 0.0, "+0." : 0.0,
    234. 

  234.     "0.e0" : 0.0, "-0.e0" : 0.0, "+0.e0" : 0.0,
    235. 

  235.     "0.E0" : 0.0, "-0.E0" : 0.0, "+0.E0" : 0.0,
    236. 

  236.     "0.e-0" : 0.0, "-0.e-0" : 0.0, "+0.e-0" : 0.0,
    237. 

  237.     "0.E-0" : 0.0, "-0.E-0" : 0.0, "+0.E-0" : 0.0,
    238. 

  238.     "0.e+0" : 0.0, "-0.e+0" : 0.0, "+0.e+0" : 0.0,
    239. 

  239.     "0.E+0" : 0.0, "-0.E+0" : 0.0, "+0.E+0" : 0.0,
    240. 

  240.     # with decimal, digit after decimal, exponent
    241. 

  241.     "0.0" : 0.0, "-0.0" : 0.0, "+0.0" : 0.0,
    242. 

  242.     "0.0e0" : 0.0, "-0.0e0" : 0.0, "+0.0e0" : 0.0,
    243. 

  243.     "0.0E0" : 0.0, "-0.0E0" : 0.0, "+0.0E0" : 0.0,
    244. 

  244.     "0.0e-0" : 0.0, "-0.0e-0" : 0.0, "+0.0e-0" : 0.0,
    245. 

  245.     "0.0E-0" : 0.0, "-0.0E-0" : 0.0, "+0.0E-0" : 0.0,
    246. 

  246.     "0.0e+0" : 0.0, "-0.0e+0" : 0.0, "+0.0e+0" : 0.0,
    247. 

  247.     "0.0E+0" : 0.0, "-0.0E+0" : 0.0, "+0.0E+0" : 0.0,
    248. 

  248.     }
    249. 

  249. 

  250. floatingPoint_FAIL = [
    251. 

  251.     # no suffix
    252. 

  252.     "3.3f", "-3.3f", "+3.3f",
    253. 

  253.     # s, f, d, l, etc. not an exponent specifier
    254. 

  254.     "23.0s-4", "-23.0f-4", "+23.0d-4",
    255. 

  255.     # double decimal
    256. 

  256.     "3..", "-3..", "+3..",
    257. 

  257.     ]
    258. 

  258. 

  259. # ======================================================================
    260. 

  260. # Literal Rational Cases
    261. 

  261. # ======================================================================
    262. 

  262. 

  263. rationalMap_PASS = {
    264. 

  264.     "22/7" : Fraction(22, 7),
    265. 

  265.     "-22/7" : Fraction(-22, 7),
    266. 

  266.     "+22/7" : Fraction(22, 7),
    267. 

  267.     "0/1" : Fraction(0, 1),
    268. 

  268.     "-0/1" : Fraction(0, 1),
    269. 

  269.     "+0/1" : Fraction(0, 1),
    270. 

  270.     # regex was fubar, didn't allow zeros after the first digit
    271. 

  271.     "100/203" : Fraction(100, 203),
    272. 

  272.     "-100/203" : Fraction(-100, 203),
    273. 

  273.     "+100/203" : Fraction(100, 203),
    274. 

  274.     }
    275. 

  275. 

  276. rational_FAIL = [
    277. 

  277.     # These actually pass in Clojure, but are interpreted as base 10 integers,
    278. 

  278.     # not base 8.
    279. 

  279.     "033/029", "-033/029", "+033/029", 
    280. 

  280.     ]
    281. 

  281. 

  282. # ======================================================================
    283. 

  283. # Literal Character Cases
    284. 

  284. # ======================================================================
    285. 

  285. 

  286. literalCharacterMap_PASS = {
    287. 

  287.     # basic
    288. 

  288.     "\\x" : "x",
    289. 

  289.     "\\ " : " ",
    290. 

  290.     "\\X" : "X",
    291. 

  291.     # newline after the \
    292. 

  292.     """\\
    293. 

  293. """ : "\n",
    294. 

  294.     # named characters
    295. 

  295.     "\\space" : " ",
    296. 

  296.     "\\newline" : "\n",
    297. 

  297.     "\\return" : "\r",
    298. 

  298.     "\\backspace" : "\b",
    299. 

  299.     "\\formfeed" : "\f",
    300. 

  300.     "\\tab" : "\t",
    301. 

  301.     # octal
    302. 

  302.     "\\o0" : "\x00",
    303. 

  303.     "\\o41" : "!",
    304. 

  304.     "\\o377" : u"\u00ff",
    305. 

  305.     # hex
    306. 

  306.     "\\u03bb" : u"\u03bb",
    307. 

  307.     # BZZZZT!
    308. 

  308.     # Because this file is encoded as UTF-8, and the reader is expecting ASCII,
    309. 

  309.     # it will crap out every time. 
    310. 

  310.     # "\\?" : character(u"\u03bb"),
    311. 

  311.     }
    312. 

  312. 

  313. literalCharacter_FAIL = [
    314. 

  314.     # According to a random web page:
    315. 

  315.     # The only reason the range D800:DFFF is invalid is because of UTF-16's
    316. 

  316.     # inability to encode it.
    317. 

  317.     "\ud800", "\udfff",
    318. 

  318.     # missing char at eof
    319. 

  319.     "\\",
    320. 

  320.     # not enough digits after \u (\u is the character u)
    321. 

  321.     "\u1", "\u22", "\u333",
    322. 

  322.     # too many digits after \u
    323. 

  323.     "\u03bbb",
    324. 

  324.     # too many digits after \o
    325. 

  325.     "\o0333",
    326. 

  326.     # octal value > 0377
    327. 

  327.     "\o400"
    328. 

  328.     ]
    329. 

  329. 

  330. # ======================================================================
    331. 

  331. # Literal String Cases
    332. 

  332. # These are tests that conform to Clojure. Some Python string syntax is
    333. 

  333. # not permitted:
    334. 

  334. # \U, \N{foo}, \x, \v, \a
    335. 

  335. # ======================================================================
    336. 

  336.             
    337. 

  337. literalStringMap_PASS = {
    338. 

  338.     # basic
    339. 

  339.     "": "",
    340. 

  340.     "x": "x",
    341. 

  341.     "foo": "foo",
    342. 

  342.     "0123456789": "0123456789",
    343. 

  343.     "~!@#$%^&*()_+-=[]{}';:/?>.<,": "~!@#$%^&*()_+-=[]{}';:/?>.<,",
    344. 

  344.     "qwertyuiopasdfghjklzxcvbnm": "qwertyuiopasdfghjklzxcvbnm",
    345. 

  345.     "QWERTYUIOPASDFGHJKLZXCVBNM": "QWERTYUIOPASDFGHJKLZXCVBNM",
    346. 

  346.     # escape           |  |<------ trailing escaped escape
    347. 

  347.     '\\"\\n\\t\\f\\b\\r\\\\': '"\n\t\f\b\r\\',
    348. 

  348.     # 4 hex digit
    349. 

  349.     "\u03bb": u"\u03bb",
    350. 

  350.     "\u03bb@": u"\u03bb@",
    351. 

  351.     "@\u03bb": u"@\u03bb",
    352. 

  352.     # octal
    353. 

  353.     "\\0": "\x00",
    354. 

  354.     "\\0@": "\x00@",
    355. 

  355.     "@\\0": "@\x00",
    356. 

  356.     "\\41": "!",
    357. 

  357.     "\\41@": "!@",
    358. 

  358.     "@\\41": "@!",
    359. 

  359.     "\\176": "~",
    360. 

  360.     "\\176@": "~@",
    361. 

  361.     "@\\176": "@~",
    362. 

  362.     }
    363. 

  363. 

  364. literalString_FAIL = [
    365. 

  365.     # invalid escape characters
    366. 

  366.     "\\x", "\\a", "\\v", "@\\x", "@\\a", "@\\v", "\\x@", "\\a@", "\\v@",
    367. 

  367.     "\\o041"
    368. 

  368.     # not enough digits after \u
    369. 

  369.     "\\u", "\\u3", "\\u33", "\\u333",
    370. 

  370.     "@\\u", "@\\u3", "@\\u33", "@\\u333",
    371. 

  371.     "\\u@", "\\u3@", "\\u33@", "\\u333@",
    372. 

  372.     # octal value > 0377
    373. 

  373.     "\\400", "@\\400", "\\400@",
    374. 

  374.     ]
    375. 

  375. 

  376. # ======================================================================
    377. 

  377. # Regular Expression Pattern
    378. 

  378. #
    379. 

  379. # Each key is the string sent to lispreader. The escapes have to be
    380. 

  380. # handled in such a way as to allow the reader to do escape
    381. 

  381. # interpretation. If Python would treat the escape special, it needs
    382. 

  382. # an additional \ before sending it to the reader.
    383. 

  383. # ======================================================================
    384. 

  384. 

  385. regexPatternMap_PASS = {
    386. 

  386.     # all using #"", not raw #r""
    387. 

  387.     '#""' : re.compile(""),
    388. 

  388.     '#"."' : re.compile("."),
    389. 

  389.     '#"^."' : re.compile("^."),
    390. 

  390.     '#".$"' : re.compile(".$"),
    391. 

  391.     '#".*"' : re.compile(".*"),
    392. 

  392.     '#".+"' : re.compile(".+"),
    393. 

  393.     '#".?"' : re.compile(".?"),
    394. 

  394.     '#".*?"' : re.compile(".*?"),
    395. 

  395.     '#".+?"' : re.compile(".+?"),
    396. 

  396.     '#".??"' : re.compile(".??"),
    397. 

  397.     '#".{3}"' : re.compile(".{3}"),
    398. 

  398.     '#".{3,}"' : re.compile(".{3,}"),
    399. 

  399.     '#".{,3}"' : re.compile(".{,3}"),
    400. 

  400.     '#".{3,3}"' : re.compile(".{3,3}"),
    401. 

  401.     '#".{3,3}"' : re.compile(".{3,3}"),
    402. 

  402.     '#".{3,3}?"' : re.compile(".{3,3}?"),
    403. 

  403.     # None of these \ are special. Python will send them to the reader as is.
    404. 

  404.     # \ . \ ^ \ $, etc.
    405. 

  405.     '#"\.\^\$\*\+\?\{\}\[\]"' : re.compile("\.\^\$\*\+\?\{\}\[\]"),
    406. 

  406.     '#"[a-z]"' : re.compile("[a-z]"),
    407. 

  407.     '#"[]]"' : re.compile("[]]"),
    408. 

  408.     '#"[-]"' : re.compile("[-]"),
    409. 

  409.     # Nor are these
    410. 

  410.     '#"[\-\]\[]"' : re.compile(r"[\-\]\[]"),
    411. 

  411.     # or these
    412. 

  412.     '#"[\w\S]"' : re.compile("[\w\S]"),
    413. 

  413.     '#"[^5]"' : re.compile("[^5]"),
    414. 

  414.     # or the |
    415. 

  415.     '#"A|B[|]\|"' : re.compile("A|B[|]\|"),
    416. 

  416.     # or ( )
    417. 

  417.     '#"([()]\(\))"' : re.compile("([()]\(\))"),
    418. 

  418.     '#"(?iLmsux)"' : re.compile("(?iLmsux)"),
    419. 

  419.     '#"(?iLmsux)"' : re.compile("(?iLmsux)"),
    420. 

  420.     '#"(:?)"' : re.compile("(:?)"),
    421. 

  421.     '#"(?P<foo>)"' : re.compile("(?P<foo>)"),
    422. 

  422.     '#"(?P<foo>)(?P=foo)"' : re.compile("(?P<foo>)(?P=foo)"),
    423. 

  423.     '#"(?# comment )"' : re.compile("(?# comment )"),
    424. 

  424.     '#"(?=foo)"' : re.compile("(?=foo)"),
    425. 

  425.     '#"(?!foo)"' : re.compile("(?!foo)"),
    426. 

  426.     '#"(?<=foo)bar"' : re.compile("(?<=foo)bar"),
    427. 

  427.     '#"(?<!foo)bar"' : re.compile("(?<!foo)bar"),
    428. 

  428.     '#"(?P<foo>)(?(foo)yes|no)"' : re.compile("(?P<foo>)(?(foo)yes|no)"),
    429. 

  429.     #       |  |<---- Python will send two \'s to the lisp reader, not four
    430. 

  430.     '#"(.+) \\\\1"' : re.compile("(.+) \\1"),
    431. 

  431.     '#"(.+) \\\\1"' : re.compile(r"(.+) \1"),
    432. 

  432.     # send one \ each, so the octal sequences are interpreted in lispreader
    433. 

  433.     # >>> u"\377" == "\377"   # funky warning on the Python repl
    434. 

  434.     '#"\\377\\021"' : re.compile(u"\377\021"),
    435. 

  435.     # Again, send one \ each. Python would interpret \1 as the char 0x01
    436. 

  436.     # *before* sending it to lispreader.
    437. 

  437.     '#"[\\1\\2\\3\\4\\5\\6\\7\\10]"' : re.compile("[\1\2\3\4\5\6\7\10]"),
    438. 

  438.     # Python does not interpret \A, but it does \b
    439. 

  439.     # The dict value here is a raw string so the char sequence will be:
    440. 

  440.     # \ A \ \ b \ B, etc.
    441. 

  441.     '#"\A\\\\b\B\d\D\s\S\w\W\Z"' : re.compile(r"\A\b\B\d\D\s\S\w\W\Z"),
    442. 

  442.     # dict val is a raw string, and Python interprets all these chars
    443. 

  443.     '#"\\\\a\\\\b\\\\f\\\\n\\\\r\\\\t\\\\v"' : re.compile(r"\a\b\f\n\r\t\v"),
    444. 

  444.     # I want Python to interpret here. lispreader will simply return
    445. 

  445.     # 0x07, 0x08 etc. (no escape interpretation)
    446. 

  446.     '#"\a\b\f\n\r\t\v"' : re.compile("\a\b\f\n\r\t\v"),
    447. 

  447.     # Send \ and letter separately. lispreader will see \ n and
    448. 

  448.     # return 0x0a (reader interpretation)
    449. 

  449.     '#"\\a\\b\\f\\n\\r\\t\\v"' : re.compile("\a\b\f\n\r\t\v"),
    450. 

  450.     # \N, \u, and \U are only special in a unicode string (in Python)
    451. 

  451.     '#"\N{DIGIT ZERO}{5, 10}"' : re.compile(u"\N{DIGIT ZERO}{5, 10}"),
    452. 

  452.     '#"\u03bb{1,3}"' : re.compile(u"\u03bb{1,3}"),
    453. 

  453.     '#"\U000003bb{1,3}"' : re.compile(u"\U000003bb{1,3}"),
    454. 

  454.     # but \x is always special, hence the \\
    455. 

  455.     '#"\\xff\\x7f"' : re.compile(u"\xff\x7f"),
    456. 

  456.     
    457. 

  457. '''#"(?x)
    458. 

  458.      # foo
    459. 

  459.      [a-z]
    460. 

  460.      # bar
    461. 

  461.      [0-9a-zA-Z_]+
    462. 

  462.      "''' : re.compile("""(?x)
    463. 

  463.      # foo
    464. 

  464.      [a-z]
    465. 

  465.      # bar
    466. 

  466.      [0-9a-zA-Z_]+
    467. 

  467.      """),
    468. 

  468.     }
    469. 

  469. 

  470. regexPattern_FAIL = [
    471. 

  471.     # # unmatched paren, bracket, (can't make it catch a missing } O_o)
    472. 

  472.     '#"([()]\(\)"', '#"["',
    473. 

  473.     # foo not defined
    474. 

  474.     '#"(?(foo)yes|no)"',
    475. 

  475.     # bogus escape 
    476. 

  476.     '#"[\\8]"',
    477. 

  477.     # need 4 hex digits
    478. 

  478.     '#"\u"', '#"\u1"', '#"\u12"', '#"\u123"',
    479. 

  479.     # need 8 hex digits
    480. 

  480.     '#"\U"', '#"\U1"', '#"\U12"', '#"\U123"', '#"\U1234"', '#"\U12345"',
    481. 

  481.     '#"\U123456"', '#"\U1234567"',
    482. 

  482.     # need 2 hex digits
    483. 

  483.     '#"\\x"', '#"\\x1"',
    484. 

  484.     # missing }, missing ",  can't escape }
    485. 

  485.     '#"\N{foo"', '#"\N{foo', '#"\N{foo\\}}"',
    486. 

  486.     # unknown name
    487. 

  487.     '#"\N{KLINGON LETTER NG}"',
    488. 

  488.     # empty {}
    489. 

  489.     '#"\N{}"', '#"\N{   }"',
    490. 

  490.     ]
    491. 

  491. 

  492. rawRegexPatternMap_PASS = {
    493. 

  493.     '#r""' : re.compile(r""),
    494. 

  494.     '#r"\\."' : re.compile(r"\."),
    495. 

  495.     '#r"\\."' : re.compile(r"\."),
    496. 

  496.     '#r"\\n"' : re.compile(r"\n"),
    497. 

  497.     '#r"\.\^\$\*\+\?\{\}\[\]"' : re.compile(r"\.\^\$\*\+\?\{\}\[\]"),
    498. 

  498.     '#r"[\-\]\[]"' : re.compile(r"[\-\]\[]"),
    499. 

  499.     '#r"[\w\S]"' : re.compile(r"[\w\S]"),
    500. 

  500.     '#r"A|B[|]\|"' : re.compile(r"A|B[|]\|"),
    501. 

  501.     '#r"([()]\(\))"' : re.compile(r"([()]\(\))"),
    502. 

  502.     '#r"(.+) \\1"' : re.compile(r"(.+) \1"),
    503. 

  503.     '#r"\\377\\021"' : re.compile(ur"\377\021"),
    504. 

  504.     '#r"[\\1\\2\\3\\4\\5\\6\\7\\10]"' : re.compile(r"[\1\2\3\4\5\6\7\10]"),
    505. 

  505.     '#r"\A\\b\B\d\D\s\S\w\W\Z"' : re.compile(r"\A\b\B\d\D\s\S\w\W\Z"),
    506. 

  506.     '#r"\\a\\b\\f\\n\\r\\t\\v"' : re.compile(r"\a\b\f\n\r\t\v"),
    507. 

  507.     '#r"\a\b\f\n\r\t\v"' : re.compile("\a\b\f\n\r\t\v"),
    508. 

  508.     '#r"\N{DIGIT ZERO}{5, 10}"' : re.compile(ur"\N{DIGIT ZERO}{5, 10}"),
    509. 

  509.     '#r"\u03bb{1,3}"' : re.compile(ur"\u03bb{1,3}"),
    510. 

  510.     '#r"\\\u03bb{1,3}"' : re.compile(ur"\\u03bb{1,3}"),
    511. 

  511.     '#r"\\\\\u03bb{1,3}"' : re.compile(ur"\\\u03bb{1,3}"),
    512. 

  512.     '#r"\\\\\\\u03bb{1,3}"' : re.compile(ur"\\\\u03bb{1,3}"),
    513. 

  513.     '#r"\U000003bb{1,3}"' : re.compile(ur"\U000003bb{1,3}"),
    514. 

  514.     '#r"\\xff\\x7f"' : re.compile(ur"\xff\x7f"),
    515. 

  515.     '#r"\\0"' : re.compile(ur"\0"),
    516. 

  516.     '#r"\\01"' : re.compile(ur"\01"),
    517. 

  517.     '#r"\\012"' : re.compile(ur"\012"),
    518. 

  518.     '''#r"\\
    519. 

  519. "''' : re.compile(r"""\
    520. 

  520. """),
    521. 

  521.     }
    522. 

  522. 

  523. rawRegexPattern_FAIL = [
    524. 

  524.     # craps out the regex compiler
    525. 

  525.     '#r"\\x"',
    526. 

  526.     # can't end with an odd number of \
    527. 

  527.     '#r"\\"',                   # #r"\"    ; in clojure-py
    528. 

  528.     '#r"\\\\\\"',               # #r"\\\"  ; in clojure-py
    529. 

  529.     # missing trailing "
    530. 

  530.     '#r"foo',
    531. 

  531.     # need 4 hex digits
    532. 

  532.     '#r"\u"', '#r"\u1"', '#r"\u12"', '#r"\u123"',
    533. 

  533.     # need 8 hex digits
    534. 

  534.     '#r"\U"', '#r"\U1"', '#r"\U12"', '#r"\U123"', '#r"\U1234"', '#r"\U12345"',
    535. 

  535.     '#r"\U123456"', '#r"\U1234567"',
    536. 

  536.     ]
    537. 

  537. 

  538. # ======================================================================
    539. 

  539. # Literal Delimited Lists
    540. 

  540. # ======================================================================
    541. 

  541. 

  542. # The keys define the clojure syntax of any object that would result in a call
    543. 

  543. # to lispreader.readDelimitedList() (minus the leading macro character(s)).
    544. 

  544. # Some objects like map and set have the same terminating character `}'. So
    545. 

  545. # there is only one entry for both.
    546. 

  546. #
    547. 

  547. # The value is a the expected contents of the Python list returned from
    548. 

  548. # readDelimitedList(). Integers are used because I don't care what type the
    549. 

  549. # items are. There are separate tests for that.
    550. 

  550. delimitedListLength_PASS = {
    551. 

  551.     "]" : [],
    552. 

  552.     "}" : [],
    553. 

  553.     ")" : [],
    554. 

  554.     "0]" : [0],
    555. 

  555.     "0)" : [0],
    556. 

  556.     "0}" : [0],
    557. 

  557.     "0 0]" : [0, 0],
    558. 

  558.     "0 0)" : [0, 0],
    559. 

  559.     "0 0}" : [0, 0],
    560. 

  560.     }
    561. 

    562. 

  562. # ======================================================================
    563. 

  563. # Returned Type
    564. 

  564. # ======================================================================
    565. 

  565. returnedType_PASS = {
    566. 

  566.     "" : sentinalType,
    567. 

  567.     "," : sentinalType,
    568. 

  568.     " " : sentinalType,
    569. 

  569.     """
    570. 

  570. """ : sentinalType,
    571. 

  571.     "\r" : sentinalType,
    572. 

  572.     "\n" : sentinalType,
    573. 

  573.     "\r\n" : sentinalType,
    574. 

  574.     "\n\r" : sentinalType,
    575. 

  575.     "\t" : sentinalType,
    576. 

  576.     "\b" : sentinalType,
    577. 

  577.     "\f" : sentinalType,
    578. 

  578.     ", \n\r\n\t\n\b\r\f" : sentinalType,
    579. 

  579.     "\v" : Symbol,              # O_o
    580. 

  580.     # "\?" : pyUnicodeType,
    581. 

  581.     "\\x" : pyStrType,      # TODO: always return unicode, never str
    582. 

  582.     "%foo" : Symbol,            # not in an anonymous function #()
    583. 

  583.     "[]" : PersistentVector,
    584. 

  584.     "()" : EmptyList,
    585. 

  585.     "{}" : PersistentHashMap,
    586. 

  586.     '"foo"' : pyStrType,        # TODO: always return unicode, never str
    587. 

  587.     # "???" : Symbol,
    588. 

  588.     '#"foo"' : pyRegexType,
    589. 

  589.     '#r"foo"' : pyRegexType,
    590. 

  590.     "#()" : PersistentList,
    591. 

  591.     "#{}" : PersistentHashSet,
    592. 

  592.     "'foo" : PersistentList,
    593. 

  593.     "~foo" : PersistentList,
    594. 

  594.     "~@(foo)" : PersistentList,
    595. 

  595.     "#^:foo()" : EmptyList,
    596. 

  596.     "^:foo()" : EmptyList,
    597. 

  597.     "; comment" : sentinalType,
    598. 

  598.     "#_ foo" : sentinalType,
    599. 

  599.     "0" : pyIntType,
    600. 

  600.     "0x0" : pyIntType,
    601. 

  601.     "041" : pyIntType,
    602. 

  602.     "2r10" : pyIntType,
    603. 

  603.     "2.2" : pyFloatType,
    604. 

  604.     "2e-3" : pyFloatType,
    605. 

  605.     "1/2" : Fraction,
    606. 

  606.     "foo" : Symbol,
    607. 

  607.     ".3" : Symbol,
    608. 

  608.     "+.3" : Symbol,
    609. 

  609.     "-.3" : Symbol,
    610. 

  610.     "true" : pyBoolType,
    611. 

  611.     "True" : Symbol,
    612. 

  612.     "false" : pyBoolType,
    613. 

  613.     "False" : Symbol,
    614. 

  614.     "nil" : pyNoneType,
    615. 

  615.     "None" : Symbol,
    616. 

  616.     }
    617. 

    618. 

  618. # ======================================================================
    619. 

  619. # Miscellaneous Failures
    620. 

  620. # Any type of random failures should go here
    621. 

  621. # ======================================================================
    622. 

    623. 

  623. miscellaneous_FAIL = [
    624. 

  624.     # always raises
    625. 

  625.     "#<unreadable object>",
    626. 

  626.     # deref not implemented (yet)
    627. 

  627.     # reader eval not implemented (yet)
    628. 

  628.     "#=foo",
    629. 

  629.     ]
    630. 

    631.