diff options
author | Roberto Ierusalimschy <roberto@inf.puc-rio.br> | 2018-12-17 14:46:37 -0200 |
---|---|---|
committer | Roberto Ierusalimschy <roberto@inf.puc-rio.br> | 2018-12-17 14:46:37 -0200 |
commit | 063d4e4543088e7a21965bda8ee5a0f952a9029e (patch) | |
tree | 6c3f2f8e98c26f071a94a32f9f2754396a66a9de /testes/literals.lua | |
parent | e354c6355e7f48e087678ec49e340ca0696725b1 (diff) | |
download | lua-5.3.5.tar.gz lua-5.3.5.tar.bz2 lua-5.3.5.zip |
Lua 5.3.5 ported to gitv5.3.5
This is the first commit for the branch Lua 5.3. All source files
were copied from the official distribution of 5.3.5 in the Lua site.
The test files are the same of 5.3.4. The manual came from the
previous RCS repository, revision 1.167.1.2.
Diffstat (limited to 'testes/literals.lua')
-rw-r--r-- | testes/literals.lua | 302 |
1 files changed, 302 insertions, 0 deletions
diff --git a/testes/literals.lua b/testes/literals.lua new file mode 100644 index 00000000..3922b3f5 --- /dev/null +++ b/testes/literals.lua | |||
@@ -0,0 +1,302 @@ | |||
1 | -- $Id: literals.lua,v 1.36 2016/11/07 13:11:28 roberto Exp $ | ||
2 | -- See Copyright Notice in file all.lua | ||
3 | |||
4 | print('testing scanner') | ||
5 | |||
6 | local debug = require "debug" | ||
7 | |||
8 | |||
9 | local function dostring (x) return assert(load(x), "")() end | ||
10 | |||
11 | dostring("x \v\f = \t\r 'a\0a' \v\f\f") | ||
12 | assert(x == 'a\0a' and string.len(x) == 3) | ||
13 | |||
14 | -- escape sequences | ||
15 | assert('\n\"\'\\' == [[ | ||
16 | |||
17 | "'\]]) | ||
18 | |||
19 | assert(string.find("\a\b\f\n\r\t\v", "^%c%c%c%c%c%c%c$")) | ||
20 | |||
21 | -- assume ASCII just for tests: | ||
22 | assert("\09912" == 'c12') | ||
23 | assert("\99ab" == 'cab') | ||
24 | assert("\099" == '\99') | ||
25 | assert("\099\n" == 'c\10') | ||
26 | assert('\0\0\0alo' == '\0' .. '\0\0' .. 'alo') | ||
27 | |||
28 | assert(010 .. 020 .. -030 == "1020-30") | ||
29 | |||
30 | -- hexadecimal escapes | ||
31 | assert("\x00\x05\x10\x1f\x3C\xfF\xe8" == "\0\5\16\31\60\255\232") | ||
32 | |||
33 | local function lexstring (x, y, n) | ||
34 | local f = assert(load('return ' .. x .. | ||
35 | ', require"debug".getinfo(1).currentline', '')) | ||
36 | local s, l = f() | ||
37 | assert(s == y and l == n) | ||
38 | end | ||
39 | |||
40 | lexstring("'abc\\z \n efg'", "abcefg", 2) | ||
41 | lexstring("'abc\\z \n\n\n'", "abc", 4) | ||
42 | lexstring("'\\z \n\t\f\v\n'", "", 3) | ||
43 | lexstring("[[\nalo\nalo\n\n]]", "alo\nalo\n\n", 5) | ||
44 | lexstring("[[\nalo\ralo\n\n]]", "alo\nalo\n\n", 5) | ||
45 | lexstring("[[\nalo\ralo\r\n]]", "alo\nalo\n", 4) | ||
46 | lexstring("[[\ralo\n\ralo\r\n]]", "alo\nalo\n", 4) | ||
47 | lexstring("[[alo]\n]alo]]", "alo]\n]alo", 2) | ||
48 | |||
49 | assert("abc\z | ||
50 | def\z | ||
51 | ghi\z | ||
52 | " == 'abcdefghi') | ||
53 | |||
54 | |||
55 | -- UTF-8 sequences | ||
56 | assert("\u{0}\u{00000000}\x00\0" == string.char(0, 0, 0, 0)) | ||
57 | |||
58 | -- limits for 1-byte sequences | ||
59 | assert("\u{0}\u{7F}" == "\x00\z\x7F") | ||
60 | |||
61 | -- limits for 2-byte sequences | ||
62 | assert("\u{80}\u{7FF}" == "\xC2\x80\z\xDF\xBF") | ||
63 | |||
64 | -- limits for 3-byte sequences | ||
65 | assert("\u{800}\u{FFFF}" == "\xE0\xA0\x80\z\xEF\xBF\xBF") | ||
66 | |||
67 | -- limits for 4-byte sequences | ||
68 | assert("\u{10000}\u{10FFFF}" == "\xF0\x90\x80\x80\z\xF4\x8F\xBF\xBF") | ||
69 | |||
70 | |||
71 | -- Error in escape sequences | ||
72 | local function lexerror (s, err) | ||
73 | local st, msg = load('return ' .. s, '') | ||
74 | if err ~= '<eof>' then err = err .. "'" end | ||
75 | assert(not st and string.find(msg, "near .-" .. err)) | ||
76 | end | ||
77 | |||
78 | lexerror([["abc\x"]], [[\x"]]) | ||
79 | lexerror([["abc\x]], [[\x]]) | ||
80 | lexerror([["\x]], [[\x]]) | ||
81 | lexerror([["\x5"]], [[\x5"]]) | ||
82 | lexerror([["\x5]], [[\x5]]) | ||
83 | lexerror([["\xr"]], [[\xr]]) | ||
84 | lexerror([["\xr]], [[\xr]]) | ||
85 | lexerror([["\x.]], [[\x.]]) | ||
86 | lexerror([["\x8%"]], [[\x8%%]]) | ||
87 | lexerror([["\xAG]], [[\xAG]]) | ||
88 | lexerror([["\g"]], [[\g]]) | ||
89 | lexerror([["\g]], [[\g]]) | ||
90 | lexerror([["\."]], [[\%.]]) | ||
91 | |||
92 | lexerror([["\999"]], [[\999"]]) | ||
93 | lexerror([["xyz\300"]], [[\300"]]) | ||
94 | lexerror([[" \256"]], [[\256"]]) | ||
95 | |||
96 | -- errors in UTF-8 sequences | ||
97 | lexerror([["abc\u{110000}"]], [[abc\u{110000]]) -- too large | ||
98 | lexerror([["abc\u11r"]], [[abc\u1]]) -- missing '{' | ||
99 | lexerror([["abc\u"]], [[abc\u"]]) -- missing '{' | ||
100 | lexerror([["abc\u{11r"]], [[abc\u{11r]]) -- missing '}' | ||
101 | lexerror([["abc\u{11"]], [[abc\u{11"]]) -- missing '}' | ||
102 | lexerror([["abc\u{11]], [[abc\u{11]]) -- missing '}' | ||
103 | lexerror([["abc\u{r"]], [[abc\u{r]]) -- no digits | ||
104 | |||
105 | -- unfinished strings | ||
106 | lexerror("[=[alo]]", "<eof>") | ||
107 | lexerror("[=[alo]=", "<eof>") | ||
108 | lexerror("[=[alo]", "<eof>") | ||
109 | lexerror("'alo", "<eof>") | ||
110 | lexerror("'alo \\z \n\n", "<eof>") | ||
111 | lexerror("'alo \\z", "<eof>") | ||
112 | lexerror([['alo \98]], "<eof>") | ||
113 | |||
114 | -- valid characters in variable names | ||
115 | for i = 0, 255 do | ||
116 | local s = string.char(i) | ||
117 | assert(not string.find(s, "[a-zA-Z_]") == not load(s .. "=1", "")) | ||
118 | assert(not string.find(s, "[a-zA-Z_0-9]") == | ||
119 | not load("a" .. s .. "1 = 1", "")) | ||
120 | end | ||
121 | |||
122 | |||
123 | -- long variable names | ||
124 | |||
125 | var1 = string.rep('a', 15000) .. '1' | ||
126 | var2 = string.rep('a', 15000) .. '2' | ||
127 | prog = string.format([[ | ||
128 | %s = 5 | ||
129 | %s = %s + 1 | ||
130 | return function () return %s - %s end | ||
131 | ]], var1, var2, var1, var1, var2) | ||
132 | local f = dostring(prog) | ||
133 | assert(_G[var1] == 5 and _G[var2] == 6 and f() == -1) | ||
134 | var1, var2, f = nil | ||
135 | print('+') | ||
136 | |||
137 | -- escapes -- | ||
138 | assert("\n\t" == [[ | ||
139 | |||
140 | ]]) | ||
141 | assert([[ | ||
142 | |||
143 | $debug]] == "\n $debug") | ||
144 | assert([[ [ ]] ~= [[ ] ]]) | ||
145 | -- long strings -- | ||
146 | b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789" | ||
147 | assert(string.len(b) == 960) | ||
148 | prog = [=[ | ||
149 | print('+') | ||
150 | |||
151 | a1 = [["this is a 'string' with several 'quotes'"]] | ||
152 | a2 = "'quotes'" | ||
153 | |||
154 | assert(string.find(a1, a2) == 34) | ||
155 | print('+') | ||
156 | |||
157 | a1 = [==[temp = [[an arbitrary value]]; ]==] | ||
158 | assert(load(a1))() | ||
159 | assert(temp == 'an arbitrary value') | ||
160 | -- long strings -- | ||
161 | b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789" | ||
162 | assert(string.len(b) == 960) | ||
163 | print('+') | ||
164 | |||
165 | a = [[00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
166 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
167 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
168 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
169 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
170 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
171 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
172 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
173 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
174 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
175 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
176 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
177 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
178 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
179 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
180 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
181 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
182 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
183 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
184 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
185 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
186 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
187 | 00123456789012345678901234567890123456789123456789012345678901234567890123456789 | ||
188 | ]] | ||
189 | assert(string.len(a) == 1863) | ||
190 | assert(string.sub(a, 1, 40) == string.sub(b, 1, 40)) | ||
191 | x = 1 | ||
192 | ]=] | ||
193 | |||
194 | print('+') | ||
195 | x = nil | ||
196 | dostring(prog) | ||
197 | assert(x) | ||
198 | |||
199 | prog = nil | ||
200 | a = nil | ||
201 | b = nil | ||
202 | |||
203 | |||
204 | -- testing line ends | ||
205 | prog = [[ | ||
206 | a = 1 -- a comment | ||
207 | b = 2 | ||
208 | |||
209 | |||
210 | x = [=[ | ||
211 | hi | ||
212 | ]=] | ||
213 | y = "\ | ||
214 | hello\r\n\ | ||
215 | " | ||
216 | return require"debug".getinfo(1).currentline | ||
217 | ]] | ||
218 | |||
219 | for _, n in pairs{"\n", "\r", "\n\r", "\r\n"} do | ||
220 | local prog, nn = string.gsub(prog, "\n", n) | ||
221 | assert(dostring(prog) == nn) | ||
222 | assert(_G.x == "hi\n" and _G.y == "\nhello\r\n\n") | ||
223 | end | ||
224 | |||
225 | |||
226 | -- testing comments and strings with long brackets | ||
227 | a = [==[]=]==] | ||
228 | assert(a == "]=") | ||
229 | |||
230 | a = [==[[===[[=[]]=][====[]]===]===]==] | ||
231 | assert(a == "[===[[=[]]=][====[]]===]===") | ||
232 | |||
233 | a = [====[[===[[=[]]=][====[]]===]===]====] | ||
234 | assert(a == "[===[[=[]]=][====[]]===]===") | ||
235 | |||
236 | a = [=[]]]]]]]]]=] | ||
237 | assert(a == "]]]]]]]]") | ||
238 | |||
239 | |||
240 | --[===[ | ||
241 | x y z [==[ blu foo | ||
242 | ]== | ||
243 | ] | ||
244 | ]=]==] | ||
245 | error error]=]===] | ||
246 | |||
247 | -- generate all strings of four of these chars | ||
248 | local x = {"=", "[", "]", "\n"} | ||
249 | local len = 4 | ||
250 | local function gen (c, n) | ||
251 | if n==0 then coroutine.yield(c) | ||
252 | else | ||
253 | for _, a in pairs(x) do | ||
254 | gen(c..a, n-1) | ||
255 | end | ||
256 | end | ||
257 | end | ||
258 | |||
259 | for s in coroutine.wrap(function () gen("", len) end) do | ||
260 | assert(s == load("return [====[\n"..s.."]====]", "")()) | ||
261 | end | ||
262 | |||
263 | |||
264 | -- testing decimal point locale | ||
265 | if os.setlocale("pt_BR") or os.setlocale("ptb") then | ||
266 | assert(tonumber("3,4") == 3.4 and tonumber"3.4" == 3.4) | ||
267 | assert(tonumber(" -.4 ") == -0.4) | ||
268 | assert(tonumber(" +0x.41 ") == 0X0.41) | ||
269 | assert(not load("a = (3,4)")) | ||
270 | assert(assert(load("return 3.4"))() == 3.4) | ||
271 | assert(assert(load("return .4,3"))() == .4) | ||
272 | assert(assert(load("return 4."))() == 4.) | ||
273 | assert(assert(load("return 4.+.5"))() == 4.5) | ||
274 | |||
275 | assert(" 0x.1 " + " 0x,1" + "-0X.1\t" == 0x0.1) | ||
276 | |||
277 | assert(tonumber"inf" == nil and tonumber"NAN" == nil) | ||
278 | |||
279 | assert(assert(load(string.format("return %q", 4.51)))() == 4.51) | ||
280 | |||
281 | local a,b = load("return 4.5.") | ||
282 | assert(string.find(b, "'4%.5%.'")) | ||
283 | |||
284 | assert(os.setlocale("C")) | ||
285 | else | ||
286 | (Message or print)( | ||
287 | '\n >>> pt_BR locale not available: skipping decimal point tests <<<\n') | ||
288 | end | ||
289 | |||
290 | |||
291 | -- testing %q x line ends | ||
292 | local s = "a string with \r and \n and \r\n and \n\r" | ||
293 | local c = string.format("return %q", s) | ||
294 | assert(assert(load(c))() == s) | ||
295 | |||
296 | -- testing errors | ||
297 | assert(not load"a = 'non-ending string") | ||
298 | assert(not load"a = 'non-ending string\n'") | ||
299 | assert(not load"a = '\\345'") | ||
300 | assert(not load"a = [=x]") | ||
301 | |||
302 | print('OK') | ||