Merge branch 'lute-test-all' of https://github.com/luau-lang/lute into lute-test-specific

Author: annieetang

.github/workflows/ci.yml

@@ -39,11 +39,18 @@ jobs:
           options: ${{ matrix.options }}
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Remove .luaurc file
-        run: rm .luaurc
-
-      - name: Run Luau Tests
-        run: find tests -name "*.test.luau" | xargs -I {} ${{ steps.build_lute.outputs.exe_path }} run {}
+      - name: Use CI .luaurc file
+        run: rm .luaurc && mv .luaurc.ci .luaurc
+
+      - name: Run Luau Tests (POSIX)
+        if: runner.os != 'Windows'
+        shell: bash
+        run: ${{ steps.build_lute.outputs.exe_path }} test
+
+      - name: Run Luau Tests (Windows)
+        if: runner.os == 'Windows'
+        shell: cmd
+        run: ${{ steps.build_lute.outputs.exe_path }} test
 
   run-lute-cxx-unittests:
     runs-on: ${{ matrix.os }}

.luaurc.ci

@@ -0,0 +1,6 @@
+{
+    "languageMode": "strict",
+    "aliases": {
+        "batteries": "./batteries",
+    }
+}

batteries/base64.luau

@@ -1,10 +1,9 @@
---!native
 --!optimize 2
 --!strict
 
 local BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-local BASE64_ENCODING_LUT = table.create(4096)
-local BASE64_DECODING_LUT = table.create(255, 0)
+local BASE64_ENCODING_LUT = table.create(4096) :: { number }
+local BASE64_DECODING_LUT = buffer.create(256)
 
 do
 	for i = 0, 4095 do
@@ -14,11 +13,14 @@ do
 			bit32.bor(string.byte(BASE64_ALPHABET, hi), bit32.lshift(string.byte(BASE64_ALPHABET, lo), 8))
 	end
 
+	-- prefill lookup table with invalid base64 value (0xFF)
+	buffer.fill(BASE64_DECODING_LUT, 0, 0xFF)
 	for i = 1, #BASE64_ALPHABET do
-		BASE64_DECODING_LUT[string.byte(BASE64_ALPHABET, i)] = i - 1
+		buffer.writeu8(BASE64_DECODING_LUT, string.byte(BASE64_ALPHABET, i), i - 1)
 	end
 end
 
+@native
 local function encode(input_buffer: buffer): buffer
 	assert(typeof(input_buffer) == "buffer", "Expected input to be a buffer")
 
@@ -71,6 +73,7 @@ local function encode(input_buffer: buffer): buffer
 	return output
 end
 
+@native
 local function decode(input_buffer: buffer): buffer
 	assert(typeof(input_buffer) == "buffer", "Expected input to be a buffer")
 
@@ -80,49 +83,56 @@ local function decode(input_buffer: buffer): buffer
 		return buffer.create(0)
 	end
 
-	local padding_size = 0
-	if input_length >= 2 and buffer.readu16(input_buffer, input_length - 2) == 0x3D3D then
-		padding_size = 2
-	elseif input_length >= 1 and buffer.readu8(input_buffer, input_length - 1) == 0x3D then
-		padding_size = 1
+	-- strip padding (rfc-4648 section 3.3: the excess pad characters MAY also be ignored)
+	while input_length > 0 and buffer.readu8(input_buffer, input_length - 1) == 0x3D do
+		input_length -= 1
+	end
+
+	-- rfc-4648 section 3.3 forbids padding that isn't preceded by at least one Base64 digit
+	if input_length == 0 then
+		error("Invalid base64 input", 2)
 	end
 
 	-- get correct output size
-	local output_length = ((input_length / 4) * 3) - padding_size
+	local output_length = (3 * input_length) // 4
 	local output = buffer.create(output_length)
-	local chunks = input_length // 4
-
-	for chunk_idx = 1, chunks do
-		local index = (chunk_idx - 1) * 4
-		local out_index = (chunk_idx - 1) * 3
-
-		local value1 = BASE64_DECODING_LUT[buffer.readu8(input_buffer, index)]
-		local value2 = BASE64_DECODING_LUT[buffer.readu8(input_buffer, index + 1)]
-		local value3 = BASE64_DECODING_LUT[buffer.readu8(input_buffer, index + 2)]
-		local value4 = BASE64_DECODING_LUT[buffer.readu8(input_buffer, index + 3)]
-
-		local chunk = bit32.bor(bit32.lshift(value1, 18), bit32.lshift(value2, 12), bit32.lshift(value3, 6), value4)
-
-		local character1 = bit32.rshift(chunk, 16)
-		local character2 = bit32.band(bit32.rshift(chunk, 8), 0b11111111)
-		local character3 = bit32.band(chunk, 0b11111111)
 
-		-- always write the first byte
-		if out_index < output_length then
-			buffer.writeu8(output, out_index, character1)
-		end
-
-		-- write second byte if have space (+padding)
-		if out_index + 1 < output_length then
-			buffer.writeu8(output, out_index + 1, character2)
+	local read_offset = 0
+	local write_offset = 0
+	-- loop invariant: at least 4 bytes to write
+	while write_offset + 4 <= output_length do
+		local b4 = buffer.readu8(BASE64_DECODING_LUT, buffer.readu8(input_buffer, read_offset + 3))
+		local b3 = buffer.readu8(BASE64_DECODING_LUT, buffer.readu8(input_buffer, read_offset + 2))
+		local b2 = buffer.readu8(BASE64_DECODING_LUT, buffer.readu8(input_buffer, read_offset + 1))
+		local b1 = buffer.readu8(BASE64_DECODING_LUT, buffer.readu8(input_buffer, read_offset))
+		if bit32.bor(b1, b2, b3, b4) >= 64 then
+			error("Invalid base64 input", 2)
 		end
+		read_offset += 4
+		-- u32 BE: [B1, B2, B3, 0] = b1<<26|b2<<20|b3<<14|b4<<8, trailing 0 will be overwritten next iteration
+		buffer.writeu32(output, write_offset, bit32.byteswap(b1 * 0x4000000 + b2 * 0x100000 + b3 * 0x4000 + b4 * 0x100))
+		write_offset += 3
+	end
 
-		-- Write third byte if we have space (+padding)
-		if out_index + 2 < output_length then
-			buffer.writeu8(output, out_index + 2, character3)
+	local u24be, nbits = 0, 0
+	while read_offset < input_length do
+		local b = buffer.readu8(BASE64_DECODING_LUT, buffer.readu8(input_buffer, read_offset))
+		read_offset += 1
+		if b >= 64 then
+			error("Invalid base64 input", 2)
 		end
+		u24be = u24be * 0x40 + b
+		nbits += 6
+	end
+	while nbits >= 8 do
+		buffer.writeu8(output, write_offset, bit32.rshift(u24be, nbits - 8))
+		nbits -= 8
+		write_offset += 1
+	end
+	-- 2 or 4 leftover bits must be zero
+	if nbits == 6 or (nbits == 2 and bit32.btest(u24be, 0x03)) or (nbits == 4 and bit32.btest(u24be, 0x0F)) then
+		error("Invalid base64 input", 2)
 	end
-
 	return output
 end