rslua 0.3.0

Yet another Lua lexer and Lua parser for Lua 5.3
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294

--[[----------------------------------------------------------------------------

		MessagePack Tests

--]]----------------------------------------------------------------------------
local msgpack = require('msgpack')

-- do very quick encode / decode tests
do
	local bytes = assert(msgpack.encode(1, -5, math.pi, 'Test!', true, false, { a = 1, b = 2 }))
	local a, b, c, d, e, f, g = assert(msgpack.decode(bytes))
	assert(a == 1)
	assert(b == -5)
	assert(c == math.pi)
	assert(d == 'Test!')
	assert(e == true)
	assert(f == false)
	assert(type(g) == 'table')
	assert(g.a == 1)
	assert(g.b == 2)
end

-- test positive fixint
for i = 0, 0x7f do
	local bytes = assert(msgpack.encode(i))
	assert(#bytes == 1, 'invalid size for positive fixint')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == i, 'returned wrong positive fixint')
end

-- test negative fixint
for i = -32, -1, -1 do
	local bytes = assert(msgpack.encode(i))
	assert(#bytes == 1, 'invalid size for negative fixint')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == i, 'returned wrong negative fixint')
end

-- test nil
do
	local bytes = assert(msgpack.encode(nil))
	assert(#bytes == 1, 'invalid size for nil')
	assert(string.byte(bytes) == 0xc0, 'invalid code for nil')
	local decoded = msgpack.decode(bytes) -- no assert here because it's nil :)
	assert(decoded == nil)
end

-- test false
do
	local bytes = assert(msgpack.encode(false))
	assert(#bytes == 1, 'invalid size for false')
	assert(string.byte(bytes) == 0xc2, 'invalid code for false')
	local decoded = msgpack.decode(bytes) -- no assert here because it's false :)
	assert(decoded == false)
end

-- test true
do
	local bytes = assert(msgpack.encode(true))
	assert(#bytes == 1, 'invalid size for true')
	assert(string.byte(bytes) == 0xc3, 'invalid code for true')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == true)
end

-- test unsigned integer
local function test_uint8(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 2, 'invalid size for uint8')
	assert(string.byte(bytes) == 0xcc, 'invalid code for uint8')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_uint16(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 3, 'invalid size for uint16')
	assert(string.byte(bytes) == 0xcd, 'invalid code for uint16')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_uint32(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 5, 'invalid size for uint32')
	assert(string.byte(bytes) == 0xce, 'invalid code for uint32')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_uint64(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 9, 'invalid size for uint64')
	assert(string.byte(bytes) == 0xcf, 'invalid code for uint64')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

test_uint8(128)
test_uint8(255)
test_uint16(256)
test_uint16(65535)
test_uint32(65536)
test_uint32(4294967295)
test_uint64(4294967296)
test_uint64(4294967296 * 10)

-- test signed integer
local function test_int8(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 2, 'invalid size for int8')
	assert(string.byte(bytes) == 0xd0, 'invalid code for int8')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_int16(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 3, 'invalid size for int16')
	assert(string.byte(bytes) == 0xd1, 'invalid code for int16')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_int32(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 5, 'invalid size for int32')
	assert(string.byte(bytes) == 0xd2, 'invalid code for int32')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_int64(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 9, 'invalid size for int64')
	assert(string.byte(bytes) == 0xd3, 'invalid code for int64')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

test_int8(-33)
test_int8(-128)
test_int16(-129)
test_int16(-32768)
test_int32(-32769)
test_int32(-2147483648)
test_int64(-2147483649)
test_int64(-2147483649 * 10)

-- test floating points
local function test_float(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 5, 'invalid size for float')
	assert(string.byte(bytes) == 0xca, 'invalid code for float')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

local function test_double(value)
	local bytes = assert(msgpack.encode(value))
	assert(#bytes == 9, 'invalid size for double')
	assert(string.byte(bytes) == 0xcb, 'invalid code for double')
	local decoded = assert(msgpack.decode(bytes))
	assert(decoded == value)
end

test_float(1.0)
test_float(2.5)
test_double(math.pi)

-- test fixarray
for i = 0, 15 do
	local array = {}; for j = 1, i do array[j] = j end -- prepare test array
	local bytes = assert(msgpack.encode(array))
	assert(string.byte(bytes) == 0x90 + i)
	array = assert(msgpack.decode(bytes))
	for j = 1, i do assert(array[j] == j) end
end

-- test fixmap
for i = 1, 15 do -- map with size 0 will be encoded as an array, so we start at 1
	local array = {}; for j = 1, i do array['item_' .. j] = j end -- prepare test array
	local bytes = assert(msgpack.encode(array))
	assert(string.byte(bytes) == 0x80 + i)
	array = assert(msgpack.decode(bytes))
	for j = 1, i do assert(array['item_' .. j] == j) end
end

-- test array 16
do
	local array = {}; for i = 1, 1024 do array[i] = i end -- prepare test array
	local bytes = assert(msgpack.encode(array))
	assert(string.byte(bytes) == 0xdc)
	array = assert(msgpack.decode(bytes))
	for i = 1, 128 do assert(array[i], i) end
end

-- test array 32
do
	local array = {}; for i = 1, 1024 * 128 do array[i] = i end -- prepare test array
	local bytes = assert(msgpack.encode(array))
	assert(string.byte(bytes) == 0xdd)
	array = assert(msgpack.decode(bytes))
	for i = 1, 1024 * 128 do assert(array[i], i) end
end

-- test map 16
do
	local map = {}; for i = 1, 1024 do map['item_' .. i] = i end -- prepare test map
	local bytes = assert(msgpack.encode(map))
	assert(string.byte(bytes) == 0xde)
	map = assert(msgpack.decode(bytes))
	for i = 1, 128 do assert(map['item_' .. i], i) end
end

-- test map 32
do
	local map = {}; for i = 1, 1024 * 128 do map['item_' .. i] = i end -- prepare test map
	local bytes = assert(msgpack.encode(map))
	assert(string.byte(bytes) == 0xdf)
	map = assert(msgpack.decode(bytes))
	for i = 1, 1024 * 128 do assert(map['item_' .. i], i) end
end

-- test fixed strings
for i = 0, 31 do
	local str = string.rep('#', i)
	local bytes = assert(msgpack.encode(str))
	assert(string.byte(bytes) == (0xa0 + i))
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

-- test strings
local function test_str8(str)
	local bytes = assert(msgpack.encode(str))
	assert(#bytes == #str + 2, 'invalid size for the str8')
	assert(string.byte(bytes) == 0xd9, 'invalid code for str8')
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

local function test_str16(str)
	local bytes = assert(msgpack.encode(str))
	assert(#bytes == #str + 3, 'invalid size for the str16')
	assert(string.byte(bytes) == 0xda, 'invalid code for str16')
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

local function test_str32(str)
	local bytes = assert(msgpack.encode(str))
	assert(#bytes == #str + 5, 'invalid size for the str32')
	assert(string.byte(bytes) == 0xdb, 'invalid code for str32')
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

test_str8(string.rep('A', 32))
test_str8(string.rep('B', 255))
test_str16(string.rep('C', 256))
test_str16(string.rep('D', 65535))
test_str32(string.rep('C', 65536))

-- test binary
local function test_bin8(str)
	local bytes = assert(msgpack.encode(str))
	assert(#bytes == #str + 2, 'invalid size for the bin8')
	assert(string.byte(bytes) == 0xc4, 'invalid code for bin8')
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

local function test_bin16(str)
	local bytes = assert(msgpack.encode(str))
	assert(#bytes == #str + 3, 'invalid size for the bin16')
	assert(string.byte(bytes) == 0xc5, 'invalid code for bin16')
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

local function test_bin32(str)
	local bytes = assert(msgpack.encode(str))
	assert(#bytes == #str + 5, 'invalid size for the bin32')
	assert(string.byte(bytes) == 0xc6, 'invalid code for bin32')
	local decoded = assert(msgpack.decode(bytes))
	assert(str == decoded)
end

test_bin8(string.rep(string.char(255), 32))
test_bin8(string.rep(string.char(255), 255))
test_bin16(string.rep(string.char(255), 256))
test_bin16(string.rep(string.char(255), 65535))
test_bin32(string.rep(string.char(255), 65536))