test/test-format.sgl — sigil-format

1(import (sigil test)

2 (sigil format))

4;; ============================================================

5;; Tokenizer

6;; ============================================================

8(test-group "tokenize"

9 (test "simple expression tokens"

10 (let* ((result (tokenize "(+ 1 2)" "test.sgl"))

11 (chars (tokenize-result-chars result))

12 (tokens (tokenize-result-tokens result)))

13 ;; Should have lparen, symbol, whitespace, number, whitespace, number, rparen, eof

14 (assert-equal 'lparen (token-type (car tokens)))

15 (assert-equal "(" (token-value (car tokens) chars))))

17 (test "string token"

18 (let* ((result (tokenize "\"hello\"" "test.sgl"))

19 (chars (tokenize-result-chars result))

20 (tokens (tokenize-result-tokens result)))

21 (assert-equal 'string (token-type (car tokens)))

22 (assert-equal "\"hello\"" (token-value (car tokens) chars))))

24 (test "hash forms"

25 (let* ((result (tokenize "#t #f" "test.sgl"))

26 (tokens (tokenize-result-tokens result)))

27 (assert-equal 'hash-t (token-type (car tokens)))))

29 (test "comment token"

30 (let* ((result (tokenize "; a comment\n" "test.sgl"))

31 (tokens (tokenize-result-tokens result)))

32 (assert-equal 'comment (token-type (car tokens)))))

34 (test "line/column tracking"

35 (let* ((result (tokenize "(define x 1)" "test.sgl"))

36 (tokens (tokenize-result-tokens result)))

37 (assert-equal 1 (token-line (car tokens)))

38 (assert-equal 1 (token-column (car tokens)))))

40 (test "char literal with double-quote delimiter"

41 (let* ((result (tokenize "#\\\"" "test.sgl"))

42 (chars (tokenize-result-chars result))

43 (tokens (tokenize-result-tokens result)))

44 (assert-equal 'char (token-type (car tokens)))

45 (assert-equal "#\\\"" (token-value (car tokens) chars))))

47 (test "char literal with open-paren delimiter"

48 (let* ((result (tokenize "#\\(" "test.sgl"))

49 (chars (tokenize-result-chars result))

50 (tokens (tokenize-result-tokens result)))

51 (assert-equal 'char (token-type (car tokens)))

52 (assert-equal "#\\(" (token-value (car tokens) chars))))

54 (test "char literal with close-paren delimiter"

55 (let* ((result (tokenize "#\\)" "test.sgl"))

56 (chars (tokenize-result-chars result))

57 (tokens (tokenize-result-tokens result)))

58 (assert-equal 'char (token-type (car tokens)))

59 (assert-equal "#\\)" (token-value (car tokens) chars))))

61 (test "char literal with semicolon delimiter"

62 (let* ((result (tokenize "#\\;" "test.sgl"))

63 (chars (tokenize-result-chars result))

64 (tokens (tokenize-result-tokens result)))

65 (assert-equal 'char (token-type (car tokens)))

66 (assert-equal "#\\;" (token-value (car tokens) chars)))))

68;; ============================================================

69;; format-string

70;; ============================================================

72(test-group "format-string balanced code"

73 (test "already-balanced code returned with success"

74 (let ((result (format-string "(define x 1)" "test.sgl")))

75 (assert-true (format-result-success result))

76 (assert-equal '() (format-result-inferences result))))

78 (test "balanced multi-line code"

79 (let ((result (format-string "(define (foo x)\n (+ x 1))" "test.sgl")))

80 (assert-true (format-result-success result)))))

82(test-group "format-string missing parens"

83 (test "unclosed define gets closing paren inferred"

84 (let ((result (format-string "(define (foo\n (+ 1 2)" "test.sgl")))

85 (assert-true (format-result-success result))

86 (assert-true (> (length (format-result-inferences result)) 0))))

88 (test "paren-inference has correct fields"

89 (let* ((result (format-string "(define (foo\n (+ 1 2)" "test.sgl"))

90 (infs (format-result-inferences result)))

91 (when (> (length infs) 0)

92 (let ((inf (car infs)))

93 (assert-true (paren-inference? inf))

94 (assert-true (number? (paren-inference-line inf)))

95 (assert-true (string? (paren-inference-reason inf))))))))

97(test-group "format-string with char literals"

98 (test "no false inferences from delimiter char literals"

99 (let ((result (format-string "(define (foo x)\n (if (eq? x #\\\")\n #\\(\n #\\)))" "test.sgl")))

100 (assert-true (format-result-success result))

101 (assert-equal '() (format-result-inferences result)))))

102

103(test-group "format-string errors"

104 (test "mismatched brackets produce errors"

105 (let ((result (format-string "(define x]" "test.sgl")))

106 (assert-false (format-result-success result))

107 (assert-true (> (length (format-result-errors result)) 0)))))

108

109;; ============================================================

110;; Result accessors

111;; ============================================================

112

113(test-group "UTF-8 preservation"

114 (test "formatter preserves multi-byte UTF-8 characters"

115 (let ((result (format-string "(define x \"\x2192; \x2713; \x2501;\")" "test.sgl")))

116 (assert-true (format-result-success result))

117 (assert-equal "(define x \"\x2192; \x2713; \x2501;\")"

118 (format-result-output result)))))

119

120(test-group "format result accessors"

121 (test "format-result-file"

122 (let ((result (format-string "(+ 1 2)" "myfile.sgl")))

123 (assert-equal "myfile.sgl" (format-result-file result))))

124

125 (test "format-result-output contains formatted code"

126 (let ((result (format-string "(+ 1 2)" "test.sgl")))

127 (assert-true (string? (format-result-output result)))))

128

129 (test "format-result-warnings is a list"

130 (let ((result (format-string "(+ 1 2)" "test.sgl")))

131 (assert-true (list? (format-result-warnings result))))))

132

133(run-tests)