/collects/tests/macro-debugger/tests/syntax-errors.rkt

http://github.com/gmarceau/PLT · Racket · 320 lines · 312 code · 5 blank · 3 comment · 13 complexity · 2703ef52a1d3387c7ef6b349d4f31afe MD5 · raw file 

    

  1. #lang scheme/base
    2. 

  2. (require "../gentest-framework.rkt")
    3. 

  3. (provide proto:errors)
    4. 

  4. 

  5. (define-tests proto:errors "Bad syntax"
    6. 

  6.   [#:suite
    7. 

  7.    "Atomic expressions"
    8. 

  8.    (testKE (#%top a b c)
    9. 

  9.            #:error-step)
    10. 

  10.    (testKE (#%top . 5)
    11. 

  11.            #:error-step)
    12. 

  12.    (testKE (quote)
    13. 

  13.            #:error-step)
    14. 

  14.    (testKE (quote a b)
    15. 

  15.            #:error-step)
    16. 

  16.    (testKE (#%require . x)
    17. 

  17.            #:error-step)
    18. 

  18.    (testKE (#%require 5)
    19. 

  19.            #:error-step)
    20. 

  20.    (testKE (#%require (prefix mzlib/list))
    21. 

  21.            #:error-step)
    22. 

  22.    (testKE (#%require (prefix 5 mzlib/list))
    23. 

  23.            #:error-step)]
    24. 

  24.   [#:suite
    25. 

  25.    "Definitions"
    26. 

  26.    (testKE (define-values x 'a)
    27. 

  27.            #:error-step)
    28. 

  28.    (testKE (define-values (x))
    29. 

  29.            #:error-step)
    30. 

  30.    (testKE (define-values (x) 'a 'b)
    31. 

  31.            #:error-step)
    32. 

  32.    (testKE (define-values (x) . 1)
    33. 

  33.            #:error-step)
    34. 

  34.    (testKE (define-values (x x) 1)
    35. 

  35.            #:error-step)
    36. 

  36.    (testKE (define-syntaxes x 1)
    37. 

  37.            #:error-step)
    38. 

  38.    (testKE (define-syntaxes (x))
    39. 

  39.            #:error-step)
    40. 

  40.    (testKE (define-syntaxes (x) 1 2)
    41. 

  41.            #:error-step)
    42. 

  42.    (testKE (define-syntaxes (x) . 3)
    43. 

  43.            #:error-step)
    44. 

  44.    (testKE (define-syntaxes (x x) 1)
    45. 

  45.            #:error-step)]
    46. 

  46.   
    47. 

  47.   ;; "Simple expressions"
    48. 

  48.   [#:suite
    49. 

  49.    "if misapplied"
    50. 

  50.    (testKE (if)
    51. 

  51.            #:error-step)
    52. 

  52.    (testKE (if 1)
    53. 

  53.            #:error-step)
    54. 

  54.    (testKE (if 'a 'b)
    55. 

  55.            #:error-step)
    56. 

  56.    (testKE (if 1 2 3 4)
    57. 

  57.            #:error-step)
    58. 

  58.    (testKE (if . x)
    59. 

  59.            #:error-step)
    60. 

  60.    (testKE (if 1 . x)
    61. 

  61.            #:error-step)
    62. 

  62.    (testKE (if 1 2 . x)
    63. 

  63.            #:error-step)
    64. 

  64.    (testKE (if 1 2 3 . x)
    65. 

  65.            #:error-step)]
    66. 

  66.   [#:suite
    67. 

  67.    "wcm misapplied"
    68. 

  68.    (testKE (with-continuation-mark)
    69. 

  69.            #:error-step)
    70. 

  70.    (testKE (with-continuation-mark 1)
    71. 

  71.            #:error-step)
    72. 

  72.    (testKE (with-continuation-mark 1 2 3 4)
    73. 

  73.            #:error-step)
    74. 

  74.    (testKE (with-continuation-mark . x)
    75. 

  75.            #:error-step)
    76. 

  76.    (testKE (with-continuation-mark 1 . x)
    77. 

  77.            #:error-step)
    78. 

  78.    (testKE (with-continuation-mark 1 2 . x)
    79. 

  79.            #:error-step)
    80. 

  80.    (testKE (with-continuation-mark 1 2 3 . x)
    81. 

  81.            #:error-step)]
    82. 

  82.   [#:suite
    83. 

  83.    "set! misapplied"
    84. 

  84.    (testKE (set!)
    85. 

  85.            #:error-step)
    86. 

  86.    (testKE (set! x)
    87. 

  87.            #:error-step)
    88. 

  88.    (testKE (set! x . 3)
    89. 

  89.            #:error-step)
    90. 

  90.    (testKE (set! x 1 2)
    91. 

  91.            #:error-step)
    92. 

  92.    (testKE (set! 1)
    93. 

  93.            #:error-step)
    94. 

  94.    (testKE (set! 1 2)
    95. 

  95.            #:error-step)]
    96. 

  96.   
    97. 

  97.   ;; "Sequence-containing expressions"
    98. 

  98.   [#:suite
    99. 

  99.    "begin misapplied"
    100. 

  100.    (testKE (#%expression (begin))
    101. 

  101.            #:error-step)
    102. 

  102.    (testKE (begin . 1)
    103. 

  103.            #:error-step)
    104. 

  104.    (testKE (begin 'a . 2)
    105. 

  105.            #:error-step)]
    106. 

  106.   [#:suite
    107. 

  107.    "begin0 misapplied"
    108. 

  108.    (testKE (begin0)
    109. 

  109.            #:error-step)
    110. 

  110.    (testKE (begin0 . 1)
    111. 

  111.            #:error-step)
    112. 

  112.    (testKE (begin0 'a . 2)
    113. 

  113.            #:error-step)
    114. 

  114.    (testKE (begin0 'a 'b . 3)
    115. 

  115.            #:error-step)]
    116. 

  116.   [#:suite 
    117. 

  117.    "#%app (implicit) misapplied"
    118. 

  118.    (testKE (+ . 1)
    119. 

  119.            [#:steps (tag-app (#%app + . 1))
    120. 

  120.                     error])
    121. 

  121.    (testKE (+ 1 . 2)
    122. 

  122.            [#:steps (tag-app (#%app + 1 . 2))
    123. 

  123.                     error])
    124. 

  124.    (testKE (+ 1 2 . 3)
    125. 

  125.            [#:steps (tag-app (#%app + 1 2 . 3))
    126. 

  126.                     error])]
    127. 

  127.   [#:suite
    128. 

  128.    "#%app (explicit) misapplied"
    129. 

  129.    (testKE (#%app . +)
    130. 

  130.            #:error-step)
    131. 

  131.    (testKE (#%app + . 1)
    132. 

  132.            #:error-step)
    133. 

  133.    (testKE (#%app + 1 . 2)
    134. 

  134.            #:error-step)
    135. 

  135.    (testKE (#%app + 1 2 . 3)
    136. 

  136.            #:error-step)]
    137. 

  137.   
    138. 

  138.   ;; "Binding forms"
    139. 

  139.   [#:suite
    140. 

  140.    "lambda misapplied"
    141. 

  141.    (testKE (lambda)
    142. 

  142.            #:error-step)
    143. 

  143.    (testKE (lambda args)
    144. 

  144.            #:error-step)
    145. 

  145.    (testKE (lambda #(a b) 1)
    146. 

  146.            #:error-step)
    147. 

  147.    (testKE (lambda args . 1)
    148. 

  148.            #:error-step)
    149. 

  149.    (testKE (lambda 1 2)
    150. 

  150.            #:error-step)
    151. 

  151.    (testKE (lambda (1) 2)
    152. 

  152.            #:error-step)
    153. 

  153.    (testKE (lambda (x . 1) 2)
    154. 

  154.            #:error-step)
    155. 

  155.    (testKE (lambda (x x) 1)
    156. 

  156.            #:error-step)
    157. 

  157.    (testKE (lambda (x y x) 1)
    158. 

  158.            #:error-step)]
    159. 

  159.   [#:suite 
    160. 

  160.    "letrec-values misapplied"
    161. 

  161.    (testKE (letrec-values)
    162. 

  162.            #:error-step)
    163. 

  163.    (testKE (letrec-values x)
    164. 

  164.            #:error-step)
    165. 

  165.    (testKE (letrec-values x 1)
    166. 

  166.            #:error-step)
    167. 

  167.    (testKE (letrec-values (x) 2)
    168. 

  168.            #:error-step)
    169. 

  169.    (testKE (letrec-values (x 1) 2)
    170. 

  170.            #:error-step)
    171. 

  171.    (testKE (letrec-values ([x 1]) 2)
    172. 

  172.            #:error-step)
    173. 

  173.    (testKE (letrec-values ([(x . y) 1]) 2)
    174. 

  174.            #:error-step)
    175. 

  175.    (testKE (letrec-values ([(x) 1 2]) 2)
    176. 

  176.            #:error-step)
    177. 

  177.    (testKE (letrec-values ([(x) 1] x) 2)
    178. 

  178.            #:error-step)
    179. 

  179.    (testKE (letrec-values ([(x) 1] [y 2]) 3)
    180. 

  180.            #:error-step)
    181. 

  181.    (testKE (letrec-values ([(x x) 1]) 2)
    182. 

  182.            #:error-step)
    183. 

  183.    (testKE (letrec-values ([(x) 1] [(x) 2]) 3)
    184. 

  184.            #:error-step)]
    185. 

  185. 

  186.   [#:suite
    187. 

  187.    "Internal definitions"
    188. 

  188.    [#:suite
    189. 

  189.     "Basic internal definitions"
    190. 

  190.     (testKE (lambda () . 1) ;; FIXME
    191. 

  191.             #:error-step)
    192. 

  192.     (testKE (lambda () (begin))
    193. 

  193.             [#:steps (rename-lambda (lambda () (begin)))
    194. 

  194.                      (splice-block (lambda ()))
    195. 

  195.                      error])
    196. 

  196.     (testKE (lambda () (define-values (x) 1))
    197. 

  197.             [#:rename+error-step rename-lambda])
    198. 

  198.     (testKE (lambda () (define-values (x) 1) . 2)
    199. 

  199.             [#:rename+error-step rename-lambda])
    200. 

  200.     (testKE (lambda () (begin (define-values (x) 1) . 2))
    201. 

  201.             [#:rename+error-step rename-lambda])
    202. 

  202.     (testKE (lambda () (begin (define-values (x) 1) . 2) 3)
    203. 

  203.             [#:rename+error-step rename-lambda])
    204. 

  204.     (testKE (lambda ()
    205. 

  205.               (define-values (x) 1)
    206. 

  206.               (define-values (x) 2)
    207. 

  207.               3)
    208. 

  208.             [#:rename+error-step rename-lambda])]
    209. 

  209.    [#:suite
    210. 

  210.     "#%stratified-body"
    211. 

  211.     (testKE (#%stratified-body
    212. 

  212.              (define-values (x) 'a)
    213. 

  213.              'b
    214. 

  214.              (define-values (y) 'c)
    215. 

  215.              'd)
    216. 

  216.             [#:steps (block->letrec (#%stratified-body
    217. 

  217.                                      (letrec-values ([(x) 'a])
    218. 

  218.                                        (#%stratified-body
    219. 

  219.                                         'b
    220. 

  220.                                         (define-values (y) 'c)
    221. 

  221.                                         'd))))
    222. 

  222.                      (rename-letrec-values (#%stratified-body
    223. 

  223.                                             (letrec-values ([(x) 'a])
    224. 

  224.                                               (#%stratified-body
    225. 

  225.                                                'b
    226. 

  226.                                                (define-values (y) 'c)
    227. 

  227.                                                'd))))
    228. 

  228.                      error])
    229. 

  229.     (testKE (#%stratified-body (define-values (x) 'a))
    230. 

  230.             [#:steps error])]
    231. 

  231.    [#:suite
    232. 

  232.     "bad internal begin"
    233. 

  233.     (testKE (lambda () (begin . 1))
    234. 

  234.             [#:rename+error-step rename-lambda])
    235. 

  235.     (testKE (lambda () (begin 1 . 2))
    236. 

  236.             [#:rename+error-step rename-lambda])
    237. 

  237.     (testKE (lambda () (define-values (x) 1) (begin . 2))
    238. 

  238.             [#:rename+error-step rename-lambda])
    239. 

  239.     (testKE (lambda () (define-values (x) 1) (begin 1 . 2))
    240. 

  240.             [#:rename+error-step rename-lambda])
    241. 

  241.     (testKE (lambda () (define-values (x) 1) (begin . 2) 3)
    242. 

  242.             [#:rename+error-step rename-lambda])]
    243. 

  243.    [#:suite
    244. 

  244.     "bad definition forms"
    245. 

  245.     (testKE (lambda () (define-values))
    246. 

  246.             [#:rename+error-step rename-lambda])
    247. 

  247.     (testKE (lambda () (define-values x))
    248. 

  248.             [#:rename+error-step rename-lambda])
    249. 

  249.     (testKE (lambda () (define-values x 1))
    250. 

  250.             [#:rename+error-step rename-lambda])
    251. 

  251.     (testKE (lambda () (define-values (x . y) 1))
    252. 

  252.             [#:rename+error-step rename-lambda])
    253. 

  253.     (testKE (lambda () (define-values (x) . 1))
    254. 

  254.             [#:rename+error-step rename-lambda])
    255. 

  255.     (testKE (lambda () (define-values (x) 1 2))
    256. 

  256.             [#:rename+error-step rename-lambda])
    257. 

  257.     (testKE (lambda () (define-values (x x) 1))
    258. 

  258.             [#:rename+error-step rename-lambda])]]
    259. 

  259.   [#:suite
    260. 

  260.    "Errors in primitive contexts"
    261. 

  261.    [#:suite 
    262. 

  262.     "Definitions"
    263. 

  263.     (testKE (define-syntaxes (x) (lambda))
    264. 

  264.             #:error-step)
    265. 

  265.     (testKE (define-values (x) (wrong))
    266. 

  266.             #:error-step)]
    267. 

  267.    [#:suite
    268. 

  268.     "Simple expressions"
    269. 

  269.     (testKE (if (wrong) 'b 'c)
    270. 

  270.             #:error-step)
    271. 

  271.     (testKE (if 'a (wrong) 'c)
    272. 

  272.             #:error-step)
    273. 

  273.     (testKE (if 'a 'b (wrong))
    274. 

  274.             #:error-step)
    275. 

  275.     (testKE (if (wrong) 'b)
    276. 

  276.             #:error-step)
    277. 

  277.     (testKE (if 'a (wrong))
    278. 

  278.             #:error-step)
    279. 

  279.     (testKE (with-continuation-mark (wrong) 'b 'c)
    280. 

  280.             #:error-step)
    281. 

  281.     (testKE (with-continuation-mark 'a (wrong) 'c)
    282. 

  282.             #:error-step)
    283. 

  283.     (testKE (with-continuation-mark 'a 'b (wrong))
    284. 

  284.             #:error-step)
    285. 

  285.     (testKE (set! x (wrong))
    286. 

  286.             #:error-step)]
    287. 

  287.    [#:suite
    288. 

  288.     "Sequence-containing expressions"
    289. 

  289.     (testKE (begin (wrong))
    290. 

  290.             #:error-step)
    291. 

  291.     (testKE (begin 'a (wrong))
    292. 

  292.             #:error-step)
    293. 

  293.     (testKE (begin0 (wrong))
    294. 

  294.             #:error-step)
    295. 

  295.     (testKE (begin0 'a (wrong))
    296. 

  296.             #:error-step)
    297. 

  297.     (testKE (#%app (wrong))
    298. 

  298.             #:error-step)
    299. 

  299.     (testKE (#%app + (wrong))
    300. 

  300.             #:error-step)]
    301. 

  301.    [#:suite
    302. 

  302.     "Binding forms"
    303. 

  303.     (testKE (lambda (x) (begin0 (wrong)))
    304. 

  304.             [#:rename+error-step rename-lambda])
    305. 

  305.     (testKE (letrec-values ([(x) (wrong)]) 1)
    306. 

  306.             [#:rename+error-step rename-letrec-values])
    307. 

  307.     (testKE (letrec-values ([(x) 'a]) (begin0 (wrong)))
    308. 

  308.             [#:rename+error-step rename-letrec-values])]
    309. 

  309.    [#:suite
    310. 

  310.     "Internal definitions"
    311. 

  311.     (testKE (lambda () (wrong))
    312. 

  312.             [#:rename+error-step rename-lambda])
    313. 

  313.     (testKE (lambda () (define-values () (wrong)) 1)
    314. 

  314.             [#:steps 
    315. 

  315.              (rename-lambda (lambda () (define-values () (wrong)) 1))
    316. 

  316.              (block->letrec (lambda () (letrec-values ([() (wrong)]) 1)))
    317. 

  317.              (rename-letrec-values (lambda () (letrec-values ([() (wrong)]) 1)))
    318. 

  318.              error])
    319. 

  319.     (testKE (lambda () (define-values (x) 1) (wrong))
    320. 

  320.             [#:rename+error-step rename-lambda])]])
    321.