mochilo 1.3.0 → 2.0

data/test/pack_test.rb

@@ -4,7 +4,7 @@ require File.expand_path('../setup', __FILE__)
 require 'mochilo'
 require 'stringio'
 
-class MochiloPackTest < MiniTest::Unit::TestCase
+class MochiloPackTest < Minitest::Test
 
   OBJECTS = [
     {"hello" => "world"},
@@ -52,122 +52,222 @@ class MochiloPackTest < MiniTest::Unit::TestCase
   end
 
   def test_pack_positive_fixed
-    assert_equal "\x15", Mochilo.pack(21)
+    [0,127].each do |int|
+      assert_equal int.chr, Mochilo.pack(int)
+    end
   end
 
   def test_pack_negative_fixed
-    assert_equal "\xEB", Mochilo.pack(-21)
+    assert_equal "\xFF", Mochilo.pack(-1)
+    assert_equal "\xE0", Mochilo.pack(-32)
   end
 
   def test_pack_uint8
-    assert_equal "\xCC\xD6", Mochilo.pack(214)
+    [128,255].each do |int|
+      assert_equal "\xCC#{int.chr}", Mochilo.pack(int)
+    end
   end
 
   def test_pack_uint16
-    assert_equal "\xCDS\xE2", Mochilo.pack(21474)
+    [256,((2**16)-1)].each do |int|
+      packed = [int].pack("n")
+      assert_equal "\xCD#{packed}", Mochilo.pack(int)
+    end
   end
 
   def test_pack_uint32
-    assert_equal "\xCE\x7F\xFF\xFF\xFF", Mochilo.pack(2147483647)
+    [(2**16),((2**32)-1)].each do |int|
+      packed = [int].pack("N")
+      assert_equal "\xCE#{packed}", Mochilo.pack(int)
+    end
   end
 
   def test_pack_uint64
-    assert_equal "\xCF\x00\x00\x00\x04\xFF\xFF\xFF\xFF", Mochilo.pack(21474836479)
+    [(2**32),((2**64)-1)].each do |int|
+      packed = [int].pack("Q>")
+      assert_equal "\xCF#{packed}", Mochilo.pack(int)
+    end
   end
 
   def test_pack_int8
-    assert_equal "\xD0\xDE", Mochilo.pack(-34)
+    assert_equal "\xD0\xDF", Mochilo.pack(-33)
+    assert_equal "\xD0\x80", Mochilo.pack(-128)
   end
 
   def test_pack_int16
-    assert_equal "\xD1\xAC\x1E", Mochilo.pack(-21474)
+    assert_equal "\xD1\xFF\x7F", Mochilo.pack(-129)
+    assert_equal "\xD1\x80\x00", Mochilo.pack(-32768)
   end
 
   def test_pack_int32
-    assert_equal "\xD2\x80\x00\x00\x01", Mochilo.pack(-2147483647)
+    assert_equal "\xD2\xFF\xFF\x7F\xFF", Mochilo.pack(-32769)
+    assert_equal "\xD2\x80\x00\x00\x00", Mochilo.pack(-2147483648)
   end
 
   def test_pack_int64
-    assert_equal "\xD3\xFF\xFF\xFF\xFB\x00\x00\x00\x01", Mochilo.pack(-21474836479)
+    assert_equal "\xD3\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFF", Mochilo.pack(-2147483649)
+    assert_equal "\xD3\x80\x00\x00\x00\x00\x00\x00\x00", Mochilo.pack(-9223372036854775808)
   end
 
-  if defined?(Encoding)
-    def test_pack_str16
-      str = "this is a test".force_encoding('UTF-8')
-      assert_equal "\xD8\x00\x0E\x00#{str}", Mochilo.pack(str)
-    end
+  def test_pack_fixed_str
+    str = "a".force_encoding('UTF-8')
+    assert_equal "\xA1#{str}", Mochilo.pack(str)
+
+    str = ("a"*31).force_encoding('UTF-8')
+    assert_equal "\xBF#{str}", Mochilo.pack(str)
   end
 
-  def xtest_pack_str32
-    # TODO: not sure how to test this without making a massive 66k string
+  def test_pack_str8
+    str = ("a"*32).force_encoding('UTF-8')
+    assert_equal "\xD9#{str.bytesize.chr}#{str}", Mochilo.pack(str)
+
+    str = ("a"*255).force_encoding('UTF-8')
+    assert_equal "\xD9#{str.bytesize.chr}#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_fixed_raw
-    str = "this is a test"
-    assert_equal "\xAE#{str}", Mochilo.pack(str)
+  def test_pack_str16
+    str = ("a"*256).force_encoding('UTF-8')
+    assert_equal "\xDA\x01\x00#{str}", Mochilo.pack(str)
+
+    str = ("a"*(2**16-1)).force_encoding('UTF-8')
+    assert_equal "\xDA\xFF\xFF#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_raw16
-    str = ("a"*255)
-    assert_equal "\xDA\x00\xFF#{str}", Mochilo.pack(str)
+  def test_pack_str32
+    str = ("a"*(2**16)).force_encoding('UTF-8')
+    assert_equal "\xDB\x00\x01\x00\x00#{str}", Mochilo.pack(str)
+
+    # This will create a 4GB string, so let's just skip that ;)
+    # str = ("a"*(2**32-1)).force_encoding('UTF-8')
+    # assert_equal "\xDB\x00\x01\x00\x00#{str}", Mochilo.pack(str)
   end
 
-  def xtest_pack_raw32
-    # TODO: not sure how to test this without making a massive 66k string
+  def test_pack_enc8
+    str = ("a"*32).force_encoding('ISO-8859-1')
+    assert_equal "\xC7#{str.bytesize.chr}\x0C#{str}", Mochilo.pack(str)
+
+    str = ("a"*255).force_encoding('ISO-8859-1')
+    assert_equal "\xC7#{str.bytesize.chr}\x0C#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_fixed_array
-    assert_equal "\x90", Mochilo.pack([])
-    assert_equal "\x91\x01", Mochilo.pack([1])
+  def test_pack_enc16
+    str = ("a"*256).force_encoding('ISO-8859-1')
+    assert_equal "\xC8\x01\x00\x0C#{str}", Mochilo.pack(str)
+
+    str = ("a"*(2**16-1)).force_encoding('ISO-8859-1')
+    assert_equal "\xC8\xFF\xFF\x0C#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_array16
-    bytes = ("a"*34).bytes.to_a
-    assert_equal "\xDC\x00\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Mochilo.pack(bytes)
+  def test_pack_enc32
+    str = ("a"*(2**16)).force_encoding('ISO-8859-1')
+    assert_equal "\xC9\x00\x01\x00\x00\x0C#{str}", Mochilo.pack(str)
+
+    # This would create a 4GB string, so let's just skip that ;)
+    # str = ("a"*(2**32-1)).force_encoding('ISO-8859-1')
+    # assert_equal "\xC9\x00\x01\x00\x00\x0C#{str}", Mochilo.pack(str)
   end
 
-  def xtest_pack_array32
-    # TODO: not sure how to test this without making a massive 66k item array
+  def test_pack_bin8
+    str = ("a"*32).force_encoding('binary')
+    assert_equal "\xC4#{str.bytesize.chr}#{str}", Mochilo.pack(str)
+
+    str = ("a"*255).force_encoding('binary')
+    assert_equal "\xC4#{str.bytesize.chr}#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_fixed_map
-    assert_equal "\x80", Mochilo.pack({})
-    assert_equal "\x81\x01\x02", Mochilo.pack({1 => 2})
+  def test_pack_bin16
+    str = ("a"*256).force_encoding('binary')
+    assert_equal "\xC5\x01\x00#{str}", Mochilo.pack(str)
+
+    str = ("a"*(2**16-1)).force_encoding('binary')
+    assert_equal "\xC5\xFF\xFF#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_symbol
-    assert_equal "\xD8\x00\x04\x01test", Mochilo.pack(:test)
-    assert_equal "\xD4\x04test", Mochilo.pack_unsafe(:test)
+  def test_pack_bin32
+    str = ("a"*(2**16)).force_encoding('binary')
+    assert_equal "\xC6\x00\x01\x00\x00#{str}", Mochilo.pack(str)
+
+    # This would create a 4GB string, so let's just skip that ;)
+    # str = ("a"*(2**32-1)).force_encoding('UTF-8')
+    # assert_equal "\xC6\x00\x01\x00\x00#{str}", Mochilo.pack(str)
   end
 
-  def test_pack_symbol_size
-    too_big = ("a"*0x100).to_sym
-    fine = ("a"*0xff).to_sym
+  def test_pack_fixed_array
+    assert_equal "\x90", Mochilo.pack([])
 
-    assert_raises Mochilo::PackError do
-      Mochilo.pack_unsafe(too_big)
-    end
+    arr = (1..15).to_a
+    expected = "\x9F"
+    arr.each {|i| expected << Mochilo.pack(i)}
+    assert_equal expected, Mochilo.pack(arr)
+  end
 
-    begin
-      Mochilo.pack_unsafe(fine)
-    rescue Mochilo::PackError => boom
-      assert_nil boom, "exception raised, expected nothing"
-    end
+  def test_pack_array16
+    arr = (1..16).to_a
+    expected = "\xDC\x00\x10"
+    arr.each {|i| expected << Mochilo.pack(i)}
+    assert_equal expected, Mochilo.pack(arr)
+
+    arr = (1..2**16-1).to_a
+    expected = "\xDC\xFF\xFF"
+    arr.each {|i| expected << Mochilo.pack(i)}
+    assert_equal expected, Mochilo.pack(arr)
   end
 
-  def test_pack_map16
-    bytes = ("a"*34).bytes.to_a
-    assert_equal "\xDC\x00\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Mochilo.pack(bytes)
+  def test_pack_array32
+    arr = (1..2**16).to_a
+    expected = "\xDD\x00\x01\x00\x00"
+    arr.each {|i| expected << Mochilo.pack(i)}
+    assert_equal expected, Mochilo.pack(arr)
+
+    # This would create an array with 4294967295 entries in it, so let's not
+    # arr = (1..2**32-1).to_a
+    # expected = "\xDD\xFF\xFF\xFF\xFF"
+    # arr.each {|i| expected << Mochilo.pack(i)}
+    # assert_equal expected, Mochilo.pack(arr)
   end
 
-  def test_pack_map32
-    # TODO: not sure how to test this without making a massive 66k item hash
+  def test_pack_fixed_map
+    assert_equal "\x80", Mochilo.pack({})
+
+    arr = (1..15).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    expected = "\x8F"
+    arr.each {|i| expected << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal expected, Mochilo.pack(hash)
   end
 
-  def test_pack_custom_type
-    obj = CustomType.new("custom")
+  def test_pack_map16
+    arr = (1..16).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    expected = "\xDE\x00\x10"
+    arr.each {|i| expected << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal expected, Mochilo.pack(hash)
+
+    arr = (1..2**16-1).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    expected = "\xDE\xFF\xFF"
+    arr.each {|i| expected << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal expected, Mochilo.pack(hash)
+  end
 
-    assert_equal "\xA6custom", Mochilo.pack(obj)
+  def test_pack_map32
+    arr = (1..2**16).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    expected = "\xDF\x00\x01\x00\x00"
+    arr.each {|i| expected << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal expected, Mochilo.pack(hash)
+
+    # This would create a hash with 4294967295 entries in it, so let's not
+    # arr = (1..2**32-1).to_a
+    # hash = {}
+    # arr.each {|i| hash[i] = i }
+    # expected = "\xDF\xFF\xFF\xFF\xFF"
+    # arr.each {|i| expected << (Mochilo.pack(i) + Mochilo.pack(i))}
+    # assert_equal expected, Mochilo.pack(hash)
   end
 
   def test_pack_unsupported_type
@@ -176,27 +276,9 @@ class MochiloPackTest < MiniTest::Unit::TestCase
     end
   end
 
-  def test_pack_regexp
-    expected = "\xD5\x00\x07\x00\x00\x00\x00\x01pa.tern"
-    assert_equal expected, Mochilo.pack(/pa.tern/)
-    [
-      /pa.tern/,
-      /thing/im,
-    ].each do |re|
-      assert_equal re, Mochilo.unpack(Mochilo.pack(re))
+  def test_pack_symbol_fails
+    assert_raises Mochilo::PackError do
+      Mochilo.pack(:symbol)
     end
   end
-
-  def test_time
-    offset = -13*60*60 # I don't know if this is possible. There shouldn't be anything with a greater absolute value.
-    t = Time.gm(2042, 7, 21, 3, 32, 37, 974010).getlocal(offset)
-    expected = "\xD6" +
-      "\x00\x00\x00\x00\x88\x77\x66\x55" + # sec
-      "\x00\x00\x00\x00\x00\x0E\xDC\xBA" + # usec
-      "\xFF\xFF\x49\x30"                   # utc_offset
-    assert_equal expected, Mochilo.pack(t)
-    unpacked = Mochilo.unpack(expected)
-    assert_equal t, unpacked
-    assert_equal t.utc_offset, unpacked.utc_offset
-  end
 end

data/test/setup.rb

@@ -14,12 +14,3 @@ require 'minitest/autorun'
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 
-class CustomType
-  def initialize(str)
-    @str = str
-  end
-
-  def to_bpack
-    Mochilo.pack(@str)
-  end
-end

data/test/unpack_test.rb

@@ -1,9 +1,9 @@
-# encoding: utf-8
+# encoding: ascii-8bit
 require File.expand_path('../setup', __FILE__)
 
 require 'mochilo'
 
-class MochiloUnpackTest < MiniTest::Unit::TestCase
+class MochiloUnpackTest < Minitest::Test
   BUFFERS = [
     "\xCC\x80",
     "\xCD\x04\xD2",
@@ -39,14 +39,14 @@ class MochiloUnpackTest < MiniTest::Unit::TestCase
     assert_equal nil, Mochilo.unpack("\xC0")
   end
 
-  def test_unpack_true
-    assert_equal true, Mochilo.unpack("\xC3")
-  end
-
   def test_unpack_false
     assert_equal false, Mochilo.unpack("\xC2")
   end
 
+  def test_unpack_true
+    assert_equal true, Mochilo.unpack("\xC3")
+  end
+
   def xtest_unpack_float
     # ruby uses double's internally so we can't reliably
     # test for a float without some hacks
@@ -57,103 +57,261 @@ class MochiloUnpackTest < MiniTest::Unit::TestCase
   end
 
   def test_unpack_positive_fixed
-    assert_equal 21, Mochilo.unpack("\x15")
+    (0..127).each do |int|
+      assert_equal int, Mochilo.unpack(int.chr)
+    end
   end
 
   def test_unpack_negative_fixed
-    assert_equal -21, Mochilo.unpack("\xEB")
+    assert_equal -1, Mochilo.unpack("\xFF")
+    assert_equal -32, Mochilo.unpack("\xE0")
   end
 
   def test_unpack_uint8
-    assert_equal 214, Mochilo.unpack("\xCC\xD6")
+    [128,255].each do |int|
+      assert_equal int, Mochilo.unpack("\xCC#{int.chr}")
+    end
   end
 
   def test_unpack_uint16
-    assert_equal 21474, Mochilo.unpack("\xCDS\xE2")
+    [256,((2**16)-1)].each do |int|
+      packed = [int].pack("n")
+      assert_equal int, Mochilo.unpack("\xCD#{packed}")
+    end
   end
 
   def test_unpack_uint32
-    assert_equal 2147483647, Mochilo.unpack("\xCE\x7F\xFF\xFF\xFF")
+    [(2**16),((2**32)-1)].each do |int|
+      packed = [int].pack("N")
+      assert_equal int, Mochilo.unpack("\xCE#{packed}")
+    end
   end
 
   def test_unpack_uint64
-    assert_equal 21474836479, Mochilo.unpack("\xCF\x00\x00\x00\x04\xFF\xFF\xFF\xFF")
+    [(2**32),((2**64)-1)].each do |int|
+      packed = [int].pack("Q>")
+      assert_equal int, Mochilo.unpack("\xCF#{packed}")
+    end
   end
 
   def test_unpack_int8
-    assert_equal -34, Mochilo.unpack("\xD0\xDE")
+    assert_equal -33, Mochilo.unpack("\xD0\xDF")
+    assert_equal -128, Mochilo.unpack("\xD0\x80")
   end
 
   def test_unpack_int16
-    assert_equal -21474, Mochilo.unpack("\xD1\xAC\x1E")
+    assert_equal -129, Mochilo.unpack("\xD1\xFF\x7F")
+    assert_equal -32768, Mochilo.unpack("\xD1\x80\x00")
   end
 
   def test_unpack_int32
-    assert_equal -2147483647, Mochilo.unpack("\xD2\x80\x00\x00\x01")
+    assert_equal -32769, Mochilo.unpack("\xD2\xFF\xFF\x7F\xFF")
+    assert_equal -2147483648, Mochilo.unpack("\xD2\x80\x00\x00\x00")
   end
 
   def test_unpack_int64
-    assert_equal -21474836479, Mochilo.unpack("\xD3\xFF\xFF\xFF\xFB\x00\x00\x00\x01")
+    assert_equal -2147483649, Mochilo.unpack("\xD3\xFF\xFF\xFF\xFF\x7F\xFF\xFF\xFF")
+    assert_equal -9223372036854775808, Mochilo.unpack("\xD3\x80\x00\x00\x00\x00\x00\x00\x00")
   end
 
-  if defined?(Encoding)
-    def test_unpack_str16
-      str = "this is a test".force_encoding('UTF-8')
-      assert_equal str, Mochilo.unpack("\xD8\x00\x0E\x00#{str}")
-    end
+  def test_unpack_fixed_str
+    str = "a".force_encoding('UTF-8')
+    val = Mochilo.unpack("\xA1#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
+
+    str = ("a"*31).force_encoding('UTF-8')
+    val = Mochilo.unpack("\xBF#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
   end
 
-  def xtest_unpack_str32
-    # TODO: not sure how to test this without making a massive 66k string
+  def test_unpack_str8
+    str = ("a"*32).force_encoding('UTF-8')
+    val = Mochilo.unpack("\xD9#{str.bytesize.chr}#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
+
+    str = ("a"*255).force_encoding('UTF-8')
+    val = Mochilo.unpack("\xD9#{str.bytesize.chr}#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
   end
 
-  def test_unpack_fixed_raw
-    str = "this is a test"
-    assert_equal str, Mochilo.unpack("\xAE#{str}")
+  def test_unpack_str16
+    str = ("a"*256).force_encoding('UTF-8')
+    val = Mochilo.unpack("\xDA\x01\x00#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
+
+    str = ("a"*(2**16-1)).force_encoding('UTF-8')
+    val = Mochilo.unpack("\xDA\xFF\xFF#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
   end
 
-  def test_unpack_symbol
-    assert_raises Mochilo::UnpackError do
-      Mochilo.unpack("\xD4\x04test")
-    end
+  def test_unpack_str32
+    str = ("a"*(2**16)).force_encoding('UTF-8')
+    val = Mochilo.unpack("\xDB\x00\x01\x00\x00#{str}")
+    assert_equal str, val
+    assert_equal Encoding::UTF_8, val.encoding
+
+    # This will create a 4GB string, so let's just skip that ;)
+    # str = ("a"*(2**32-1)).force_encoding('UTF-8')
+    # val = Mochilo.unpack("\xDB\xFF\xFF\xFF\xFF#{str}")
+    # assert_equal str, val
+    # assert_equal Encoding::UTF_8, val.encoding
+  end
+
+  def test_unpack_enc8
+    str = ("a"*32).force_encoding('ISO-8859-1')
+    val = Mochilo.unpack("\xC7#{str.bytesize.chr}\x0C#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ISO_8859_1, val.encoding
+
+    str = ("a"*255).force_encoding('ISO-8859-1')
+    val = Mochilo.unpack("\xC7#{str.bytesize.chr}\x0C#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ISO_8859_1, val.encoding
+  end
+
+  def test_unpack_enc16
+    str = ("a"*256).force_encoding('ISO-8859-1')
+    val = Mochilo.unpack("\xC8\x01\x00\x0C#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ISO_8859_1, val.encoding
 
-    assert_equal :test, Mochilo.unpack_unsafe("\xD4\x04test")
+    str = ("a"*(2**16-1)).force_encoding('ISO-8859-1')
+    val = Mochilo.unpack("\xC8\xFF\xFF\x0C#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ISO_8859_1, val.encoding
   end
 
-  def test_unpack_raw16
-    str = ("a"*255)
-    assert_equal str, Mochilo.unpack("\xDA\x00\xFF#{str}")
+  def test_unpack_enc32
+    str = ("a"*(2**16)).force_encoding('ISO-8859-1')
+    val = Mochilo.unpack("\xC9\x00\x01\x00\x00\x0C#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ISO_8859_1, val.encoding
+
+    # This would create a 4GB string, so let's just skip that ;)
+    # str = ("a"*(2**32-1)).force_encoding('ISO-8859-1')
+    # val = Mochilo.unpack("\xC9\x00\x01\x00\x00\x0C#{str}")
+    # assert_equal str, val
+    # assert_equal Encoding::ISO_8859_1, val.encoding
   end
 
-  def xtest_unpack_raw32
-    # TODO: not sure how to test this without making a massive 66k string
+  def test_unpack_bin8
+    str = ("a"*32).force_encoding('binary')
+    val = Mochilo.unpack("\xC4#{str.bytesize.chr}#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ASCII_8BIT, val.encoding
+
+    str = ("a"*255).force_encoding('binary')
+    val = Mochilo.unpack("\xC4#{str.bytesize.chr}#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ASCII_8BIT, val.encoding
+  end
+
+  def test_unpack_bin16
+    str = ("a"*256).force_encoding('binary')
+    val = Mochilo.unpack("\xC5\x01\x00#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ASCII_8BIT, val.encoding
+
+    str = ("a"*(2**16-1)).force_encoding('binary')
+    val = Mochilo.unpack("\xC5\xFF\xFF#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ASCII_8BIT, val.encoding
+  end
+
+  def test_unpack_bin32
+    str = ("a"*(2**16)).force_encoding('binary')
+    val = Mochilo.unpack("\xC6\x00\x01\x00\x00#{str}")
+    assert_equal str, val
+    assert_equal Encoding::ASCII_8BIT, val.encoding
+
+    # This would create a 4GB string, so let's just skip that ;)
+    # str = ("a"*(2**32-1)).force_encoding('UTF-8')
+    # val = Mochilo.unpack("\xC6\x00\x01\x00\x00#{str}")
+    # assert_equal str, val
+    # assert_equal Encoding::ASCII_8BIT, val.encoding
   end
 
   def test_unpack_fixed_array
     assert_equal [], Mochilo.unpack("\x90")
-    assert_equal [1], Mochilo.unpack("\x91\x01")
+
+    arr = (1..15).to_a
+    data = "\x9F"
+    arr.each {|i| data << Mochilo.pack(i)}
+    assert_equal arr, Mochilo.unpack(data)
   end
 
   def test_unpack_array16
-    bytes = ("a"*34).bytes.to_a
-    assert_equal bytes, Mochilo.unpack("\xDC\x00\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+    arr = (1..16).to_a
+    data = "\xDC\x00\x10"
+    arr.each {|i| data << Mochilo.pack(i)}
+    assert_equal arr, Mochilo.unpack(data)
+
+    arr = (1..2**16-1).to_a
+    data = "\xDC\xFF\xFF"
+    arr.each {|i| data << Mochilo.pack(i)}
+    assert_equal arr, Mochilo.unpack(data)
   end
 
-  def xtest_unpack_array32
-    # TODO: not sure how to test this without making a massive 66k item array
+  def test_unpack_array32
+    arr = (1..2**16).to_a
+    data = "\xDD\x00\x01\x00\x00"
+    arr.each {|i| data << Mochilo.pack(i)}
+    assert_equal arr, Mochilo.unpack(data)
+
+    # This would create an array with 4294967295 entries in it, so let's not
+    # arr = (1..2**32-1).to_a
+    # data = "\xDD\xFF\xFF\xFF\xFF"
+    # arr.each {|i| data << Mochilo.pack(i)}
+    # assert_equal arr, Mochilo.unpack(data)
   end
 
-  def test_unpack_fixed_map
+  def test_pack_fixed_map
     assert_equal({}, Mochilo.unpack("\x80"))
-    assert_equal({1 => 2}, Mochilo.unpack("\x81\x01\x02"))
+
+    arr = (1..15).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    data = "\x8F"
+    arr.each {|i| data << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal hash, Mochilo.unpack(data)
   end
 
-  def test_unpack_map16
-    bytes = ("a"*34).bytes.to_a
-    assert_equal bytes, Mochilo.unpack("\xDC\x00\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+  def test_pack_map16
+    arr = (1..16).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    data = "\xDE\x00\x10"
+    arr.each {|i| data << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal hash, Mochilo.unpack(data)
+
+    arr = (1..2**16-1).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    data = "\xDE\xFF\xFF"
+    arr.each {|i| data << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal hash, Mochilo.unpack(data)
   end
 
-  def test_unpack_map32
-    # TODO: not sure how to test this without making a massive 66k item hash
+  def test_pack_map32
+    arr = (1..2**16).to_a
+    hash = {}
+    arr.each {|i| hash[i] = i }
+    data = "\xDF\x00\x01\x00\x00"
+    arr.each {|i| data << (Mochilo.pack(i) + Mochilo.pack(i))}
+    assert_equal hash, Mochilo.unpack(data)
+
+    # This would create a hash with 4294967295 entries in it, so let's not
+    # arr = (1..2**32-1).to_a
+    # hash = {}
+    # arr.each {|i| hash[i] = i }
+    # data = "\xDF\xFF\xFF\xFF\xFF"
+    # arr.each {|i| data << (Mochilo.pack(i) + Mochilo.pack(i))}
+    # assert_equal hash, Mochilo.unpack(data)
   end
 end