mbutterick
/
brag
1
0
Fork 0
Code Issues 3 Pull Requests 1 Projects Releases Wiki Activity

Use `convert-compile-time-error` in error tests

Browse Source
remotes/jackfirth/master
Jack Firth 3 years ago
parent 1a2df4295e
commit d7e5b10fe0
1 changed files with 65 additions and 68 deletions
Show Stats Download Patch File Download Diff File

99
parser-tools/private-lex/error-tests.rkt
Unescape Escape View File

@ -2,84 +2,81 @@
(module+ test (module+ test
(require (for-syntax racket/base) (require (for-syntax racket/base) ; keep: convert-compile-time-error is hiding usages
yaragg/parser-tools/lex yaragg/parser-tools/lex ; keep: convert-compile-time-error is hiding usages
rackunit) rackunit
syntax/macro-testing)
(define-syntax (catch-syn-error stx) (check-exn #rx"lex-abbrev" (λ () (convert-compile-time-error (define-lex-abbrev))))
(syntax-case stx () (check-exn #rx"lex-abbrev" (λ () (convert-compile-time-error (define-lex-abbrev a))))
[(_ arg) (check-exn #rx"lex-abbrev" (λ () (convert-compile-time-error (define-lex-abbrev (a b) v))))
(datum->syntax (check-exn #rx"lex-abbrev" (λ () (convert-compile-time-error (define-lex-abbrev 1 1))))
#'here (check-exn #rx"lex-abbrevs" (λ () (convert-compile-time-error (define-lex-abbrevs ()))))
(with-handlers ((exn:fail:syntax? exn-message))
(syntax-local-expand-expression #'arg)
"not-an-error"))]))
(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev))) (check-exn #rx"lex-trans" (λ () (convert-compile-time-error (define-lex-trans))))
(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev a)))
(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev (a b) v)))
(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev 1 1)))
(check-regexp-match #rx"lex-abbrevs" (catch-syn-error (define-lex-abbrevs ())))
(check-regexp-match #rx"lex-trans" (catch-syn-error (define-lex-trans))) (check-exn #rx"lexer" (λ () (convert-compile-time-error (lexer))))
(check-exn #rx"lexer" (λ () (convert-compile-time-error (lexer ("a" "b" "c")))))
(check-exn #rx"lexer" (λ () (convert-compile-time-error (lexer ()))))
(check-exn #rx"lexer" (λ () (convert-compile-time-error (lexer ("")))))
(check-regexp-match #rx"lexer" (catch-syn-error (lexer))) (check-exn #rx"regular-expression" (λ () (convert-compile-time-error (lexer (a 1)))))
(check-regexp-match #rx"lexer" (catch-syn-error (lexer ("a" "b" "c")))) (check-exn #rx"regular-expression" (λ () (convert-compile-time-error (lexer ((a) 1)))))
(check-regexp-match #rx"lexer" (catch-syn-error (lexer ()))) (check-exn #rx"regular-expression"
(check-regexp-match #rx"lexer" (catch-syn-error (lexer ("")))) (λ () (convert-compile-time-error (let ((a 1)) (lexer ((a) 1))))))
(check-regexp-match #rx"regular-expression" (catch-syn-error (lexer (a 1)))) (check-exn #rx"regular-expression"
(check-regexp-match #rx"regular-expression" (catch-syn-error (lexer ((a) 1)))) (λ () (convert-compile-time-error (let-syntax ((a 1)) (lexer ((a) 1))))))
(check-regexp-match #rx"regular-expression" (catch-syn-error (let ((a 1)) (lexer ((a) 1)))))
(check-regexp-match #rx"regular-expression" (check-exn #rx"define-lex-trans"
(catch-syn-error (let-syntax ((a 1)) (λ ()
(lexer ((a) 1))))) (convert-compile-time-error
(check-regexp-match #rx"define-lex-trans"
(catch-syn-error
(let () (let ()
(define-lex-trans a 1) (define-lex-trans a 1)
(let () (let ()
(lexer ((a) 1)))))) (lexer ((a) 1)))))))
;; Detecting mutual recursion cycle: ;; Detecting mutual recursion cycle:
(check-regexp-match #rx"regular-expression" (check-exn #rx"regular-expression"
(catch-syn-error (λ ()
(convert-compile-time-error
(let () (let ()
(define-lex-abbrev a b) (define-lex-abbrev a b)
(define-lex-abbrev b a) (define-lex-abbrev b a)
(let () (let ()
(lexer (a 1)))))) (lexer (a 1)))))))
(check-regexp-match #rx"regular-expression" (check-exn #rx"regular-expression"
(catch-syn-error (λ ()
(convert-compile-time-error
(let () (let ()
(define-lex-abbrev a (repetition 0 1 b)) (define-lex-abbrev a (repetition 0 1 b))
(define-lex-abbrev b (repetition 0 1 a)) (define-lex-abbrev b (repetition 0 1 a))
(let () (let ()
(lexer (a 1)))))) (lexer (a 1)))))))
;; Detecting cycle within same abbreviation: ;; Detecting cycle within same abbreviation:
(check-regexp-match #rx"regular-expression" (check-exn #rx"regular-expression"
(catch-syn-error (λ ()
(convert-compile-time-error
(let () (let ()
(define-lex-abbrev balanced (define-lex-abbrev balanced
(union (concatenation "(" balanced ")" balanced) (union (concatenation "(" balanced ")" balanced)
any-char)) any-char))
(lexer (lexer
[balanced (string-append lexeme (balanced input-port))] [balanced (string-append lexeme (balanced input-port))]
[(eof) ""])))) [(eof) ""])))))
(check-regexp-match #rx"regular-expression" (catch-syn-error (lexer (1 1)))) (check-exn #rx"regular-expression" (λ () (convert-compile-time-error (lexer (1 1)))))
(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition) 1)))) (check-exn #rx"repetition" (λ () (convert-compile-time-error (lexer ((repetition) 1)))))
(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition #\1 #\1 "3") 1)))) (check-exn #rx"repetition" (λ () (convert-compile-time-error (lexer ((repetition #\1 #\1 "3") 1)))))
(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition 1 #\1 "3") 1)))) (check-exn #rx"repetition" (λ () (convert-compile-time-error (lexer ((repetition 1 #\1 "3") 1)))))
(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition 1 0 "3") 1)))) (check-exn #rx"repetition" (λ () (convert-compile-time-error (lexer ((repetition 1 0 "3") 1)))))
(check-regexp-match #rx"complement" (catch-syn-error (lexer ((complement) 1)))) (check-exn #rx"complement" (λ () (convert-compile-time-error (lexer ((complement) 1)))))
(check-regexp-match #rx"char-range" (catch-syn-error (lexer ((char-range) 1)))) (check-exn #rx"char-range" (λ () (convert-compile-time-error (lexer ((char-range) 1)))))
(check-regexp-match #rx"char-range" (catch-syn-error (lexer ((char-range #\9 #\0) 1)))) (check-exn #rx"char-range" (λ () (convert-compile-time-error (lexer ((char-range #\9 #\0) 1)))))
(check-regexp-match #rx"char-complement" (catch-syn-error (lexer ((char-complement) 1)))) (check-exn #rx"char-complement" (λ () (convert-compile-time-error (lexer ((char-complement) 1)))))
(check-regexp-match #rx"char-complement" (check-exn #rx"char-complement"
(catch-syn-error (lexer ((char-complement (concatenation "1" "2")) 1))))) (λ ()
(convert-compile-time-error (lexer ((char-complement (concatenation "1" "2")) 1))))))

Write Preview
Loading…
Cancel
Save