sync variable-length-quantity (#563)

Author: keiravillekode

exercises/practice/variable-length-quantity/.meta/example.lua

@@ -8,7 +8,7 @@ local function decode(bytes)
       table.insert(values, n)
       n = 0
     end
-    assert((i ~= #bytes) or (byte & 0x80 == 0), 'incomplete byte sequence')
+    assert((i ~= #bytes) or (byte & 0x80 == 0), 'incomplete sequence')
   end
   return values
 end

exercises/practice/variable-length-quantity/.meta/spec_generator.lua

@@ -0,0 +1,31 @@
+local map = function(t, f)
+  local mapped = {}
+  for i, v in ipairs(t) do
+    mapped[i] = f(v)
+  end
+  return mapped
+end
+
+local function render_integers(integers)
+  return table.concat(map(integers, function(integer)
+    return string.format("0x%x", integer)
+  end), ', ')
+end
+
+return {
+  module_name = 'vlq',
+
+  generate_test = function(case)
+    if case.expected.error then
+      local template = [[
+        assert.has_error(function()
+          vlq.%s({ %s })
+        end)]]
+      return template:format(case.property, render_integers(case.input.integers))
+    else
+      local template = [[
+        assert.are.same({ %s }, vlq.%s({ %s }))]]
+      return template:format(render_integers(case.expected), case.property, render_integers(case.input.integers))
+    end
+  end
+}

exercises/practice/variable-length-quantity/.meta/tests.toml

@@ -1,81 +1,103 @@
-# This is an auto-generated file. Regular comments will be removed when this
-# file is regenerated. Regenerating will not touch any manually added keys,
-# so comments can be added in a "comment" key.
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
 
 [35c9db2e-f781-4c52-b73b-8e76427defd0]
-description = "zero"
+description = "Encode a series of integers, producing a series of bytes. -> zero"
 
 [be44d299-a151-4604-a10e-d4b867f41540]
-description = "arbitrary single byte"
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary single byte"
+
+[890bc344-cb80-45af-b316-6806a6971e81]
+description = "Encode a series of integers, producing a series of bytes. -> asymmetric single byte"
 
 [ea399615-d274-4af6-bbef-a1c23c9e1346]
-description = "largest single byte"
+description = "Encode a series of integers, producing a series of bytes. -> largest single byte"
 
 [77b07086-bd3f-4882-8476-8dcafee79b1c]
-description = "smallest double byte"
+description = "Encode a series of integers, producing a series of bytes. -> smallest double byte"
 
 [63955a49-2690-4e22-a556-0040648d6b2d]
-description = "arbitrary double byte"
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary double byte"
+
+[4977d113-251b-4d10-a3ad-2f5a7756bb58]
+description = "Encode a series of integers, producing a series of bytes. -> asymmetric double byte"
 
 [29da7031-0067-43d3-83a7-4f14b29ed97a]
-description = "largest double byte"
+description = "Encode a series of integers, producing a series of bytes. -> largest double byte"
 
 [3345d2e3-79a9-4999-869e-d4856e3a8e01]
-description = "smallest triple byte"
+description = "Encode a series of integers, producing a series of bytes. -> smallest triple byte"
 
 [5df0bc2d-2a57-4300-a653-a75ee4bd0bee]
-description = "arbitrary triple byte"
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary triple byte"
+
+[6731045f-1e00-4192-b5ae-98b22e17e9f7]
+description = "Encode a series of integers, producing a series of bytes. -> asymmetric triple byte"
 
 [f51d8539-312d-4db1-945c-250222c6aa22]
-description = "largest triple byte"
+description = "Encode a series of integers, producing a series of bytes. -> largest triple byte"
 
 [da78228b-544f-47b7-8bfe-d16b35bbe570]
-description = "smallest quadruple byte"
+description = "Encode a series of integers, producing a series of bytes. -> smallest quadruple byte"
 
 [11ed3469-a933-46f1-996f-2231e05d7bb6]
-description = "arbitrary quadruple byte"
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary quadruple byte"
+
+[b45ef770-cbba-48c2-bd3c-c6362679516e]
+description = "Encode a series of integers, producing a series of bytes. -> asymmetric quadruple byte"
 
 [d5f3f3c3-e0f1-4e7f-aad0-18a44f223d1c]
-description = "largest quadruple byte"
+description = "Encode a series of integers, producing a series of bytes. -> largest quadruple byte"
 
 [91a18b33-24e7-4bfb-bbca-eca78ff4fc47]
-description = "smallest quintuple byte"
+description = "Encode a series of integers, producing a series of bytes. -> smallest quintuple byte"
 
 [5f34ff12-2952-4669-95fe-2d11b693d331]
-description = "arbitrary quintuple byte"
+description = "Encode a series of integers, producing a series of bytes. -> arbitrary quintuple byte"
+
+[9be46731-7cd5-415c-b960-48061cbc1154]
+description = "Encode a series of integers, producing a series of bytes. -> asymmetric quintuple byte"
 
 [7489694b-88c3-4078-9864-6fe802411009]
-description = "maximum 32-bit integer input"
+description = "Encode a series of integers, producing a series of bytes. -> maximum 32-bit integer input"
 
 [f9b91821-cada-4a73-9421-3c81d6ff3661]
-description = "two single-byte values"
+description = "Encode a series of integers, producing a series of bytes. -> two single-byte values"
 
 [68694449-25d2-4974-ba75-fa7bb36db212]
-description = "two multi-byte values"
+description = "Encode a series of integers, producing a series of bytes. -> two multi-byte values"
 
 [51a06b5c-de1b-4487-9a50-9db1b8930d85]
-description = "many multi-byte values"
+description = "Encode a series of integers, producing a series of bytes. -> many multi-byte values"
 
 [baa73993-4514-4915-bac0-f7f585e0e59a]
-description = "one byte"
+description = "Decode a series of bytes, producing a series of integers. -> one byte"
 
 [72e94369-29f9-46f2-8c95-6c5b7a595aee]
-description = "two bytes"
+description = "Decode a series of bytes, producing a series of integers. -> two bytes"
 
 [df5a44c4-56f7-464e-a997-1db5f63ce691]
-description = "three bytes"
+description = "Decode a series of bytes, producing a series of integers. -> three bytes"
 
 [1bb58684-f2dc-450a-8406-1f3452aa1947]
-description = "four bytes"
+description = "Decode a series of bytes, producing a series of integers. -> four bytes"
 
 [cecd5233-49f1-4dd1-a41a-9840a40f09cd]
-description = "maximum 32-bit integer"
+description = "Decode a series of bytes, producing a series of integers. -> maximum 32-bit integer"
 
 [e7d74ba3-8b8e-4bcb-858d-d08302e15695]
-description = "incomplete sequence causes error"
+description = "Decode a series of bytes, producing a series of integers. -> incomplete sequence causes error"
 
 [aa378291-9043-4724-bc53-aca1b4a3fcb6]
-description = "incomplete sequence causes error, even if value is zero"
+description = "Decode a series of bytes, producing a series of integers. -> incomplete sequence causes error, even if value is zero"
 
 [a91e6f5a-c64a-48e3-8a75-ce1a81e0ebee]
-description = "multiple values"
+description = "Decode a series of bytes, producing a series of integers. -> multiple values"

exercises/practice/variable-length-quantity/variable-length-quantity_spec.lua

@@ -1,75 +1,137 @@
-local vlq = require 'variable-length-quantity'
+local vlq = require('variable-length-quantity')
 
--- LuaFormatter off
 describe('variable-length-quantity', function()
-  it('should decode single bytes', function()
-    assert.are.same({ 0x00 }, vlq.decode({ 0x00 }))
-    assert.are.same({ 0x40 }, vlq.decode({ 0x40 }))
-    assert.are.same({ 0x7f }, vlq.decode({ 0x7f }))
-  end)
+  describe('encode a series of integers, producing a series of bytes.', function()
+    it('zero', function()
+      assert.are.same({ 0x0 }, vlq.encode({ 0x0 }))
+    end)
 
-  it('should decode double bytes', function()
-    assert.are.same({ 0x80 }, vlq.decode({ 0x81, 0x00 }))
-    assert.are.same({ 0x2000 }, vlq.decode({ 0xc0, 0x00 }))
-    assert.are.same({ 0x3fff }, vlq.decode({ 0xff, 0x7f }))
-  end)
+    it('arbitrary single byte', function()
+      assert.are.same({ 0x40 }, vlq.encode({ 0x40 }))
+    end)
 
-  it('should decode triple bytes', function()
-    assert.are.same({ 0x4000 }, vlq.decode({ 0x81, 0x80, 0x00 }))
-    assert.are.same({ 0x100000 }, vlq.decode({ 0xc0, 0x80, 0x00 }))
-    assert.are.same({ 0x1fffff }, vlq.decode({ 0xff, 0xff, 0x7f }))
-  end)
+    it('asymmetric single byte', function()
+      assert.are.same({ 0x53 }, vlq.encode({ 0x53 }))
+    end)
 
-  it('should decode quadruple bytes', function()
-    assert.are.same({ 0x200000 }, vlq.decode({ 0x81, 0x80, 0x80, 0x00 }))
-    assert.are.same({ 0x08000000 }, vlq.decode({ 0xc0, 0x80, 0x80, 0x00 }))
-    assert.are.same({ 0x0fffffff }, vlq.decode({ 0xff, 0xff, 0xff, 0x7f }))
-  end)
+    it('largest single byte', function()
+      assert.are.same({ 0x7f }, vlq.encode({ 0x7f }))
+    end)
 
-  it('should decode multiple values', function()
-    assert.are.same(
-      { 0x2000, 0x123456, 0x0fffffff, 0x00, 0x3fff, 0x4000 },
-      vlq.decode({ 0xc0, 0x00, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xff, 0x7f, 0x81, 0x80, 0x00 })
-    )
-  end)
+    it('smallest double byte', function()
+      assert.are.same({ 0x81, 0x0 }, vlq.encode({ 0x80 }))
+    end)
 
-  it('should encode single bytes', function()
-    assert.are.same({ 0x00 }, vlq.encode({ 0x00 }))
-    assert.are.same({ 0x40 }, vlq.encode({ 0x40 }))
-    assert.are.same({ 0x7f }, vlq.encode({ 0x7f }))
-  end)
+    it('arbitrary double byte', function()
+      assert.are.same({ 0xc0, 0x0 }, vlq.encode({ 0x2000 }))
+    end)
 
-  it('should encode double bytes', function()
-    assert.are.same({ 0x81, 0x00 }, vlq.encode({ 0x80 }))
-    assert.are.same({ 0xc0, 0x00 }, vlq.encode({ 0x2000 }))
-    assert.are.same({ 0xff, 0x7f }, vlq.encode({ 0x3fff }))
-  end)
+    it('asymmetric double byte', function()
+      assert.are.same({ 0x81, 0x2d }, vlq.encode({ 0xad }))
+    end)
 
-  it('should encode triple bytes', function()
-    assert.are.same({ 0x81, 0x80, 0x00 }, vlq.encode({ 0x4000 }))
-    assert.are.same({ 0xc0, 0x80, 0x00 }, vlq.encode({ 0x100000 }))
-    assert.are.same({ 0xff, 0xff, 0x7f }, vlq.encode({ 0x1fffff }))
-  end)
+    it('largest double byte', function()
+      assert.are.same({ 0xff, 0x7f }, vlq.encode({ 0x3fff }))
+    end)
 
-  it('should encode quadruple bytes', function()
-    assert.are.same({ 0x81, 0x80, 0x80, 0x00 }, vlq.encode({ 0x200000 }))
-    assert.are.same({ 0xc0, 0x80, 0x80, 0x00 }, vlq.encode({ 0x08000000 }))
-    assert.are.same({ 0xff, 0xff, 0xff, 0x7f }, vlq.encode({ 0x0fffffff }))
-  end)
+    it('smallest triple byte', function()
+      assert.are.same({ 0x81, 0x80, 0x0 }, vlq.encode({ 0x4000 }))
+    end)
+
+    it('arbitrary triple byte', function()
+      assert.are.same({ 0xc0, 0x80, 0x0 }, vlq.encode({ 0x100000 }))
+    end)
+
+    it('asymmetric triple byte', function()
+      assert.are.same({ 0x87, 0xab, 0x1c }, vlq.encode({ 0x1d59c }))
+    end)
+
+    it('largest triple byte', function()
+      assert.are.same({ 0xff, 0xff, 0x7f }, vlq.encode({ 0x1fffff }))
+    end)
+
+    it('smallest quadruple byte', function()
+      assert.are.same({ 0x81, 0x80, 0x80, 0x0 }, vlq.encode({ 0x200000 }))
+    end)
+
+    it('arbitrary quadruple byte', function()
+      assert.are.same({ 0xc0, 0x80, 0x80, 0x0 }, vlq.encode({ 0x8000000 }))
+    end)
+
+    it('asymmetric quadruple byte', function()
+      assert.are.same({ 0x81, 0xd5, 0xee, 0x4 }, vlq.encode({ 0x357704 }))
+    end)
 
-  it('should encode multiple values', function()
-    assert.are.same({ 0x40, 0x7f }, vlq.encode({ 0x40, 0x7f }))
-    assert.are.same({ 0x81, 0x80, 0x00, 0xc8, 0xe8, 0x56 }, vlq.encode({ 0x4000, 0x123456 }))
-    assert.are.same(
-      { 0xc0, 0x00, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x00, 0xff, 0x7f, 0x81, 0x80, 0x00 },
-      vlq.encode({ 0x2000, 0x123456, 0x0fffffff, 0x00, 0x3fff, 0x4000 })
-    )
+    it('largest quadruple byte', function()
+      assert.are.same({ 0xff, 0xff, 0xff, 0x7f }, vlq.encode({ 0xfffffff }))
+    end)
+
+    it('smallest quintuple byte', function()
+      assert.are.same({ 0x81, 0x80, 0x80, 0x80, 0x0 }, vlq.encode({ 0x10000000 }))
+    end)
+
+    it('arbitrary quintuple byte', function()
+      assert.are.same({ 0x8f, 0xf8, 0x80, 0x80, 0x0 }, vlq.encode({ 0xff000000 }))
+    end)
+
+    it('asymmetric quintuple byte', function()
+      assert.are.same({ 0x88, 0xb3, 0x95, 0xc2, 0x5 }, vlq.encode({ 0x86656105 }))
+    end)
+
+    it('maximum 32-bit integer input', function()
+      assert.are.same({ 0x8f, 0xff, 0xff, 0xff, 0x7f }, vlq.encode({ 0xffffffff }))
+    end)
+
+    it('two single-byte values', function()
+      assert.are.same({ 0x40, 0x7f }, vlq.encode({ 0x40, 0x7f }))
+    end)
+
+    it('two multi-byte values', function()
+      assert.are.same({ 0x81, 0x80, 0x0, 0xc8, 0xe8, 0x56 }, vlq.encode({ 0x4000, 0x123456 }))
+    end)
+
+    it('many multi-byte values', function()
+      assert.are.same({ 0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0 },
+                      vlq.encode({ 0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000 }))
+    end)
   end)
 
-  it('should raise an error when decoding an incomplete byte sequence', function()
-    assert.has.error(function()
-      vlq.decode({ 0x81, 0x00, 0x80 })
-    end, 'incomplete byte sequence')
+  describe('decode a series of bytes, producing a series of integers.', function()
+    it('one byte', function()
+      assert.are.same({ 0x7f }, vlq.decode({ 0x7f }))
+    end)
+
+    it('two bytes', function()
+      assert.are.same({ 0x2000 }, vlq.decode({ 0xc0, 0x0 }))
+    end)
+
+    it('three bytes', function()
+      assert.are.same({ 0x1fffff }, vlq.decode({ 0xff, 0xff, 0x7f }))
+    end)
+
+    it('four bytes', function()
+      assert.are.same({ 0x200000 }, vlq.decode({ 0x81, 0x80, 0x80, 0x0 }))
+    end)
+
+    it('maximum 32-bit integer', function()
+      assert.are.same({ 0xffffffff }, vlq.decode({ 0x8f, 0xff, 0xff, 0xff, 0x7f }))
+    end)
+
+    it('incomplete sequence causes error', function()
+      assert.has_error(function()
+        vlq.decode({ 0xff })
+      end)
+    end)
+
+    it('incomplete sequence causes error, even if value is zero', function()
+      assert.has_error(function()
+        vlq.decode({ 0x80 })
+      end)
+    end)
+
+    it('multiple values', function()
+      assert.are.same({ 0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000 }, vlq.decode(
+                        { 0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0 }))
+    end)
   end)
 end)
--- LuaFormatter on