mochilo 1.2.1 → 2.0

data/ext/mochilo/mochilo_api.h

@@ -4,21 +4,6 @@ MOAPI mo_value moapi_bytes_new(const char *src, size_t len)
 	return (mo_value)rb_str_new(src, len);
 }
 
-MOAPI mo_value moapi_sym_new(const char *src, size_t len)
-{
-	char *symbol;
-
-	if (len > 0xFF)
-		rb_raise(rb_eArgError, "Symbol too long to encode in BananaPack");
-
-	symbol = alloca(len + 1);
-	memcpy(symbol, src, len);
-	symbol[len] = '\0';
-
-	return (mo_value)ID2SYM(rb_intern(symbol));
-}
-
-#ifdef HAVE_RUBY_ENCODING_H
 MOAPI mo_value moapi_str_new(const char *src, size_t len, enum msgpack_enc_t encoding)
 {
 	int index = 0;
@@ -32,7 +17,6 @@ MOAPI mo_value moapi_str_new(const char *src, size_t len, enum msgpack_enc_t enc
 
 	return (mo_value)str;
 }
-#endif
 
 MOAPI mo_value moapi_array_new(size_t array_size)
 {

data/ext/mochilo/mochilo_pack.c

@@ -7,7 +7,7 @@
 
 extern VALUE rb_eMochiloPackError;
 
-void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object, int trusted);
+void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object);
 
 void mochilo_pack_fixnum(mochilo_buf *buf, VALUE rb_fixnum)
 {
@@ -75,14 +75,13 @@ void mochilo_pack_bignum(mochilo_buf *buf, VALUE rb_bignum)
 
 struct mochilo_hash_pack {
 	mochilo_buf *buf;
-	int trusted;
 };
 
 static int hash_callback(VALUE key, VALUE val, VALUE opaque)
 {
 	struct mochilo_hash_pack *hash_pack = (struct mochilo_hash_pack*)opaque;
-	mochilo_pack_one(hash_pack->buf, key, hash_pack->trusted);
-	mochilo_pack_one(hash_pack->buf, val, hash_pack->trusted);
+	mochilo_pack_one(hash_pack->buf, key);
+	mochilo_pack_one(hash_pack->buf, val);
 	return 0;
 }
 
@@ -93,13 +92,12 @@ void mochilo_pack_double(mochilo_buf *buf, VALUE rb_double)
 	mochilo_buf_put64be(buf, &d);
 }
 
-void mochilo_pack_hash(mochilo_buf *buf, VALUE rb_hash, int trusted)
+void mochilo_pack_hash(mochilo_buf *buf, VALUE rb_hash)
 {
 	struct mochilo_hash_pack hash_pack;
 	long size = RHASH_SIZE(rb_hash);
 
 	hash_pack.buf = buf;
-	hash_pack.trusted = trusted;
 
 	if (size < 0x10) {
 		uint8_t lead = 0x80 | size;
@@ -124,46 +122,26 @@ void mochilo_pack_bytes(mochilo_buf *buf, VALUE rb_bytes)
 {
 	long size = RSTRING_LEN(rb_bytes);
 
-	if (size < 0x20) {
-		uint8_t lead = 0xA0 | size;
+	if (size < 0x100) {
+		uint8_t lead = size;
+		mochilo_buf_putc(buf, MSGPACK_T_BIN8);
 		mochilo_buf_putc(buf, lead);
-	}
-
-	else if (size < 0x10000) {
+	} else if (size < 0x10000) {
 		uint16_t lead = size;
-		mochilo_buf_putc(buf, MSGPACK_T_RAW16);
+		mochilo_buf_putc(buf, MSGPACK_T_BIN16);
 		mochilo_buf_put16be(buf, &lead);
-	}
-
-	else {
-		mochilo_buf_putc(buf, MSGPACK_T_RAW32);
+	} else if (size < 0x100000000) {
+		mochilo_buf_putc(buf, MSGPACK_T_BIN32);
 		mochilo_buf_put32be(buf, &size);
-	}
-
-	mochilo_buf_put(buf, RSTRING_PTR(rb_bytes), size);
-}
-
-void mochilo_pack_symbol(mochilo_buf *buf, VALUE rb_symbol)
-{
-	long size;
-	const char *name;
-
-	name = rb_id2name(SYM2ID(rb_symbol));
-	size = strlen(name);
-
-	if (size < 0x100) {
-		uint8_t lead = size;
-		mochilo_buf_putc(buf, MSGPACK_T_SYM);
-		mochilo_buf_putc(buf, lead);
 	} else {
+		// there is no bin 64
 		rb_raise(rb_eMochiloPackError,
-			"Symbol too long: must be under %d bytes, %ld given", 0x100, size);
+			"Binary string cannot be larger than %ld bytes", 0x100000000);
 	}
 
-	mochilo_buf_put(buf, name, size);
+	mochilo_buf_put(buf, RSTRING_PTR(rb_bytes), size);
 }
 
-#ifdef HAVE_RUBY_ENCODING_H
 void mochilo_pack_str(mochilo_buf *buf, VALUE rb_str)
 {
 	long size = RSTRING_LEN(rb_str);
@@ -172,27 +150,57 @@ void mochilo_pack_str(mochilo_buf *buf, VALUE rb_str)
 	const struct mochilo_enc_map *enc2id;
 	const char *enc_name;
 
-	if (size < 0x10000) {
-		uint16_t lead = size;
-		mochilo_buf_putc(buf, MSGPACK_T_STR16);
-		mochilo_buf_put16be(buf, &lead);
-	}
-
-	else {
-		mochilo_buf_putc(buf, MSGPACK_T_STR32);
-		mochilo_buf_put32be(buf, &size);
-	}
-
 	encoding = rb_enc_get(rb_str);
 	enc_name = rb_enc_name(encoding);
-	enc2id = mochilo_encoding_to_id(enc_name, (unsigned int)strlen(enc_name));
 
-	mochilo_buf_putc(buf, enc2id ? enc2id->id : 0);
+	if (encoding == rb_utf8_encoding()) {
+		// use str type from msgpack spec
+		if (size < 0x20) {
+			uint8_t lead = 0xa0 | size;
+			mochilo_buf_putc(buf, lead);
+		} else if (size < 0x100) {
+			uint8_t lead = size;
+			mochilo_buf_putc(buf, MSGPACK_T_STR8);
+			mochilo_buf_putc(buf, lead);
+		} else if (size < 0x10000) {
+			uint16_t lead = size;
+			mochilo_buf_putc(buf, MSGPACK_T_STR16);
+			mochilo_buf_put16be(buf, &lead);
+		} else if (size < 0x100000000) {
+			mochilo_buf_putc(buf, MSGPACK_T_STR32);
+			mochilo_buf_put32be(buf, &size);
+		} else {
+			// there is no str 64
+			rb_raise(rb_eMochiloPackError,
+				"String cannot be larger than %ld bytes", 0x100000000);
+		}
+	} else {
+		// if another encoding is used we need to use our custom types
+		if (size < 0x100) {
+			uint8_t lead = size;
+			mochilo_buf_putc(buf, MSGPACK_T_ENC8);
+			mochilo_buf_putc(buf, lead);
+		} else if (size < 0x10000) {
+			uint16_t lead = size;
+			mochilo_buf_putc(buf, MSGPACK_T_ENC16);
+			mochilo_buf_put16be(buf, &lead);
+		} else if (size < 0x100000000) {
+			mochilo_buf_putc(buf, MSGPACK_T_ENC32);
+			mochilo_buf_put32be(buf, &size);
+		} else {
+			// there is no ext 64
+			rb_raise(rb_eMochiloPackError,
+				"String cannot be larger than %ld bytes", 0x100000000);
+		}
+
+		enc2id = mochilo_encoding_to_id(enc_name, (unsigned int)strlen(enc_name));
+		mochilo_buf_putc(buf, enc2id ? enc2id->id : 0);
+	}
+
 	mochilo_buf_put(buf, RSTRING_PTR(rb_str), size);
 }
-#endif
 
-void mochilo_pack_array(mochilo_buf *buf, VALUE rb_array, int trusted)
+void mochilo_pack_array(mochilo_buf *buf, VALUE rb_array)
 {
 	long i, size = RARRAY_LEN(rb_array);
 
@@ -213,11 +221,11 @@ void mochilo_pack_array(mochilo_buf *buf, VALUE rb_array, int trusted)
 	}
 
 	for (i = 0; i < size; i++) {
-		mochilo_pack_one(buf, rb_ary_entry(rb_array, i), trusted);
+		mochilo_pack_one(buf, rb_ary_entry(rb_array, i));
 	}
 }
 
-void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object, int trusted)
+void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object)
 {
 	switch (rb_type(rb_object)) {
 	case T_NIL:
@@ -236,28 +244,19 @@ void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object, int trusted)
 		mochilo_pack_fixnum(buf, rb_object);
 		return;
 
-	case T_SYMBOL:
-		if (trusted)
-			mochilo_pack_symbol(buf, rb_object);
-		else
-			mochilo_pack_str(buf, rb_obj_as_string(rb_object));
-		return;
-
 	case T_STRING:
-#ifdef HAVE_RUBY_ENCODING_H
 		if (ENCODING_GET(rb_object) != 0)
 			mochilo_pack_str(buf, rb_object);
 		else
-#endif
 			mochilo_pack_bytes(buf, rb_object);
 		return;
 
 	case T_HASH:
-		mochilo_pack_hash(buf, rb_object, trusted);
+		mochilo_pack_hash(buf, rb_object);
 		return;
 
 	case T_ARRAY:
-		mochilo_pack_array(buf, rb_object, trusted);
+		mochilo_pack_array(buf, rb_object);
 		return;
 
 	case T_FLOAT:
@@ -269,14 +268,8 @@ void mochilo_pack_one(mochilo_buf *buf, VALUE rb_object, int trusted)
 		return;
 
 	default:
-		if (rb_respond_to(rb_object, rb_intern("to_bpack"))) {
-			VALUE bpack = rb_funcall(rb_object, rb_intern("to_bpack"), 0);
-
-			mochilo_buf_put(buf, RSTRING_PTR(bpack), RSTRING_LEN(bpack));
-		} else {
-			rb_raise(rb_eMochiloPackError,
-					"Unsupported object type: %s", rb_obj_classname(rb_object));
-		}
+		rb_raise(rb_eMochiloPackError,
+				"Unsupported object type: %s", rb_obj_classname(rb_object));
 		return;
 	}
 }

data/ext/mochilo/mochilo_unpack.c

@@ -159,14 +159,10 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 			return unpack_hash(_value, (size_t)length, src);
 		}
 
-		case MSGPACK_T_SYM:
+		case MSGPACK_T_STR8:
 		{
 			uint8_t length;
 			const char *ptr;
-			
-			if (!src->trusted) {
-				return MSGPACK_EUNSAFE;
-			}
 
 			SRC_ENSURE_AVAIL(src, 1);
 			mochilo_src_get8be(src, &length);
@@ -174,12 +170,58 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 			if (!(ptr = mochilo_src_peek(src, length)))
 				return -1;
 
-			*_value = moapi_sym_new(ptr, length);
+			*_value = moapi_str_new(ptr, length, MSGPACK_ENC_UTF_8);
 			return 0;
 		}
 
-#ifdef HAVE_RUBY_ENCODING_H
 		case MSGPACK_T_STR16:
+		{
+			uint16_t length;
+			const char *ptr;
+
+			SRC_ENSURE_AVAIL(src, 2 + 1);
+			mochilo_src_get16be(src, &length);
+
+			if (!(ptr = mochilo_src_peek(src, length)))
+				return -1;
+
+			*_value = moapi_str_new(ptr, length, MSGPACK_ENC_UTF_8);
+			return 0;
+		}
+
+		case MSGPACK_T_STR32:
+		{
+			uint32_t length;
+			const char *ptr;
+
+			SRC_ENSURE_AVAIL(src, 4 + 1);
+			mochilo_src_get32be(src, &length);
+
+			if (!(ptr = mochilo_src_peek(src, length)))
+				return -1;
+
+			*_value = moapi_str_new(ptr, length, MSGPACK_ENC_UTF_8);
+			return 0;
+		}
+
+		case MSGPACK_T_ENC8:
+		{
+			uint8_t length;
+			uint8_t encoding;
+			const char *ptr;
+
+			SRC_ENSURE_AVAIL(src, 1 + 1);
+			mochilo_src_get8be(src, &length);
+			mochilo_src_get8be(src, &encoding);
+
+			if (!(ptr = mochilo_src_peek(src, length)))
+				return -1;
+
+			*_value = moapi_str_new(ptr, length, encoding);
+			return 0;
+		}
+
+		case MSGPACK_T_ENC16:
 		{
 			uint16_t length;
 			uint8_t encoding;
@@ -196,7 +238,7 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 			return 0;
 		}
 
-		case MSGPACK_T_STR32:
+		case MSGPACK_T_ENC32:
 		{
 			uint32_t length;
 			uint8_t encoding;
@@ -212,9 +254,23 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 			*_value = moapi_str_new(ptr, length, encoding);
 			return 0;
 		}
-#endif
 
-		case MSGPACK_T_RAW16:
+		case MSGPACK_T_BIN8:
+		{
+			uint8_t length;
+			const char *ptr;
+
+			SRC_ENSURE_AVAIL(src, 1);
+			mochilo_src_get8be(src, &length);
+
+			if (!(ptr = mochilo_src_peek(src, length)))
+				return -1;
+
+			*_value = moapi_bytes_new(ptr, length);
+			return 0;
+		}
+
+		case MSGPACK_T_BIN16:
 		{
 			uint16_t length;
 			const char *ptr;
@@ -229,7 +285,7 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 			return 0;
 		}
 
-		case MSGPACK_T_RAW32:
+		case MSGPACK_T_BIN32:
 		{
 			uint32_t length;
 			const char *ptr;
@@ -268,7 +324,7 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 				if (!(ptr = mochilo_src_peek(src, length)))
 					return -1;
 
-				*_value = moapi_bytes_new(ptr, length);
+				*_value = moapi_str_new(ptr, length, MSGPACK_ENC_UTF_8);
 				return 0;
 			}
 
@@ -276,4 +332,3 @@ int mochilo_unpack_one(mo_value *_value, mochilo_src *src)
 		}
 	}
 }
-

data/lib/mochilo/version.rb

@@ -1,3 +1,3 @@
 module Mochilo
-  VERSION = "1.2.1"
+  VERSION = "2.0"
 end

data/mochilo.gemspec

@@ -13,10 +13,12 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.4.2}
   s.summary = %q{A ruby library for BananaPack}
-  s.test_files = `git ls-files test`.split("\n")
+  s.test_files = `git ls-files spec`.split("\n")
   s.required_ruby_version = ">= 1.9.3"
 
   # tests
   s.add_development_dependency 'rake-compiler', ">= 0.8.1"
   s.add_development_dependency 'minitest', ">= 4.1.0"
+  # benchmarks
+  s.add_development_dependency 'msgpack'
 end

data/script/bootstrap

@@ -12,5 +12,5 @@ cd "$(dirname "$0")/.."
 if bundle check 1>/dev/null 2>&1; then
     echo "Gem environment up-to-date"
 else
-    exec bundle install --binstubs --path vendor/gems --without benchmark "$@"
+    exec bundle install --binstubs --path vendor/gems "$@"
 fi

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
@@ -175,4 +275,10 @@ class MochiloPackTest < MiniTest::Unit::TestCase
       Mochilo.pack(Object.new)
     end
   end
+
+  def test_pack_symbol_fails
+    assert_raises Mochilo::PackError do
+      Mochilo.pack(:symbol)
+    end
+  end
 end