gitlab-cbor 1.0.0

data/spec/format_spec.rb

@@ -0,0 +1,603 @@
+# encoding: utf-8
+require 'spec_helper'
+
+def bignum_to_bytes(bn)
+  bn.to_s(16).chars.each_slice(2).map{|a| a.join.to_i(16).chr}.join
+end
+# => "\x98!sHq#\x98W\x91\x82sY\x87)Hu#E"
+# 0x982173487123985791827359872948752345
+
+unless defined?(Float::INFINITY)
+  class Float
+    INFINITY = 1.0/0.0
+    NAN = 0.0/0.0
+  end
+end
+
+describe MessagePack do
+  it "nil" do
+    check 1, nil
+  end
+
+  it "true" do
+    check 1, true
+  end
+
+  it "false" do
+    check 1, false
+  end
+
+  it "zero" do
+    check 1, 0
+  end
+
+  it "positive fixnum" do
+    check 1, 1
+    check 2, (1<<6)
+    check 2, (1<<7)-1
+  end
+
+  it "positive int 8" do
+    check 1, -1
+    check 2, (1<<7)
+    check 2, (1<<8)-1
+  end
+
+  it "positive int 16" do
+    check 3, (1<<8)
+    check 3, (1<<16)-1
+    check 3, 1024
+    check 4, [1024]
+  end
+
+  it "positive int 32" do
+    check 5, (1<<16)
+    check 5, (1<<32)-1
+  end
+
+  it "positive int 64" do
+    check 9, (1<<32)
+    check 9, (1<<64)-1
+  end
+
+  it "negative fixnum" do
+    check 1, -1
+    check 1, -24
+    check 2, -25
+  end
+
+  it "negative int 8" do
+    check 2, -((1<<5)+1)
+    check 2, -(1<<7)
+  end
+
+  it "negative int 16" do
+    check 2, -((1<<7)+1)
+    check 2, -256
+    check 3, -(1<<15)
+  end
+
+  it "negative int 32" do
+    check 3, -((1<<15)+1)
+    check 3, -(1<<16)
+    check 5, -(1<<31)
+    check 5, -(1<<32)
+  end
+
+  it "negative int 64" do
+    check 5, -((1<<31)+1)
+    check 9, -(1<<63)
+    check 9, -(1<<64)
+  end
+
+  it "half" do
+    check 3, 1.0
+    check 3, -1.0
+    check 3, -2.0
+    check 3, 65504.0
+    check 3, -65504.0
+    check 3, Math.ldexp(1, -14) # ≈ 6.10352 × 10−5 (minimum positive normal)
+    check 3, -Math.ldexp(1, -14) # ≈ 6.10352 × 10−5 (maximum negative normal)
+    check 3, Math.ldexp(1, -14) - Math.ldexp(1, -24) # ≈ 6.09756 × 10−5 (maximum subnormal)
+    check 3, Math.ldexp(1, -24) # ≈ 5.96046 × 10−8 (minimum positive subnormal)
+    check 3, -Math.ldexp(1, -24) # ≈ -5.96046 × 10−8 (maximum negative subnormal)
+    check 5, Math.ldexp(1, -14) - Math.ldexp(0.5, -24) # check loss of precision
+    check 5, Math.ldexp(1.5, -24)                      # loss of precision (subnormal)
+    check 3, Math.ldexp(1.5, -23)
+    check 5, Math.ldexp(1.75, -23)
+    check 3, Float::INFINITY
+    check 3, -Float::INFINITY
+    # check 3, Float::NAN     # NAN is not equal to itself, to this never checks out...
+    raw = Float::NAN.to_cbor.to_s
+    raw.length.should == 3
+    MessagePack.unpack(raw).nan?.should == true
+  end
+
+  it "double" do
+    check 9, 0.1
+    check 9, -0.1
+  end
+
+  it "fixraw" do
+    check_raw 1, 0
+    check_raw 1, 23
+  end
+
+  it "raw 16" do
+    check_raw 2, (1<<5)
+    check_raw 3, (1<<16)-1
+  end
+
+  it "raw 32" do
+    check_raw 5, (1<<16)
+    #check_raw 5, (1<<32)-1  # memory error
+  end
+
+  it "fixarray" do
+    check_array 1, 0
+    check_array 1, (1<<4)-1
+    check_array 1, 23
+  end
+
+  it "array 16" do
+    check_array 1, (1<<4)
+    #check_array 3, (1<<16)-1
+  end
+
+  it "array 32" do
+    #check_array 5, (1<<16)
+    #check_array 5, (1<<32)-1  # memory error
+  end
+
+  it "nil" do
+    match nil, "\xf6".b
+  end
+
+  it "false" do
+    match false, "\xf4".b
+  end
+
+  it "true" do
+    match true, "\xf5".b
+  end
+
+  it "0" do
+    match 0, "\x00".b
+  end
+
+  it "127" do
+    match 127, "\x18\x7f".b
+  end
+
+  it "128" do
+    match 128, "\x18\x80".b
+  end
+
+  it "256" do
+    match 256, "\x19\x01\x00".b
+  end
+
+  it "-1" do
+    match -1, "\x20".b
+  end
+
+  it "-33" do
+    match -33, "\x38\x20".b
+  end
+
+  it "-129" do
+    match -129, "\x38\x80".b
+  end
+
+  it "-257" do
+    match -257, "\x39\x01\x00".b
+  end
+
+  it "{1=>1}" do
+    obj = {1=>1}
+    match obj, "\xA1\x01\x01".b
+  end
+
+  it "1.0" do
+    match 1.0, "\xF9\x3c\x00".b
+  end
+
+  it "NaN" do
+    match Float::NAN, "\xF9\x7e\x00".b
+  end
+
+  it "[]" do
+    match [], "\x80".b
+  end
+
+  it "[0, 1, ..., 14]" do
+    obj = (0..14).to_a
+    match obj, "\x8f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e".b
+  end
+
+  it "[0, 1, ..., 15]" do
+    obj = (0..15).to_a
+    match obj, "\x90\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f".b
+  end
+
+  it "[0, 1, ..., 22]" do
+    obj = (0..22).to_a
+    match obj, "\x97\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16".b
+  end
+
+  it "[0, 1, ..., 23]" do
+    obj = (0..23).to_a
+    match obj, "\x98\x18\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17".b
+  end
+
+  it "{}" do
+    obj = {}
+    match obj, "\xA0".b
+  end
+
+  it "very simple bignums" do
+    CBOR.decode("\xc2\x40").should == 0
+    CBOR.decode("\xc2\x41\x00").should == 0
+    CBOR.decode("\xc2\x41a").should == 97
+    CBOR.decode("\xc2\x42aa").should == 24929
+    CBOR.decode("\xc3\x40").should == ~0
+    CBOR.decode("\xc3\x41\x00").should == ~0
+    CBOR.decode("\xc3\x41a").should == ~97
+    CBOR.decode("\xc3\x42aa").should == ~24929
+  end
+
+  it "0x982173487123985791827359872948752345" do
+    check_bn(0x982173487123985791827359872948752345, 0xc2)
+    check_bn(-0x982173487123985791827359872948752345, 0xc3)
+    check_bn(0x9821734871239857918273598729487523, 0xc2)
+    check_bn(0x98217348712398579182735987294875, 0xc2)
+    check_bn(0x982173487123985791827359872948, 0xc2)
+    check_bn(0x9821734871239857918273598729, 0xc2)
+    check_bn(0x98217348712398579182735987, 0xc2)
+    check 20, 0x982173487123985791827359872948752345
+    check 20, -0x982173487123985791827359872948752345
+    check 19, 0x9821734871239857918273598729487523
+    check 18, 0x98217348712398579182735987294875
+    check 18, -0x98217348712398579182735987294875
+    check 17, 0x982173487123985791827359872948
+    check 16, 0x9821734871239857918273598729
+    check 15, 0x98217348712398579182735987
+    check 15, 0x9821734871239857918273598
+    check 16, [0x9821734871239857918273598]
+    check 39, 0x982173487123985791827359872948752345982173487123985791827359872948752345
+    check 3005, 256**3000+4711       # 3001 bignum, 3 string, 1 tag
+  end
+
+  it "fixnum/bignum switch" do
+    CBOR.encode(CBOR.decode("\xc2\x40")).should == "\x00".b
+    CBOR.encode(CBOR.decode("\xc2\x41\x00")).should == "\x00".b
+    CBOR.encode(CBOR.decode("\xc2\x41a")).should == "\x18a".b
+    CBOR.encode(CBOR.decode("\xc2\x42aa")).should == "\x19aa".b
+    CBOR.encode(CBOR.decode("\xc2\x43aaa")).should == "\x1A\x00aaa".b
+    CBOR.encode(CBOR.decode("\xc2\x44aaaa")).should == "\x1Aaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x45aaaaa")).should == "\e\x00\x00\x00aaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x46aaaaaa")).should == "\e\x00\x00aaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x47aaaaaaa")).should == "\e\x00aaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x48aaaaaaaa")).should == "\eaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x49\x00aaaaaaaa")).should == "\eaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x49aaaaaaaaa")).should == "\xC2Iaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4a\x00aaaaaaaaa")).should == "\xC2Iaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4aaaaaaaaaaa")).should == "\xC2Jaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4b\x00aaaaaaaaaa")).should == "\xC2Jaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4baaaaaaaaaaa")).should == "\xC2Kaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4c\x00aaaaaaaaaaa")).should == "\xC2Kaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4caaaaaaaaaaaa")).should == "\xC2Laaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4d\x00aaaaaaaaaaaa")).should == "\xC2Laaaaaaaaaaaa".b
+    CBOR.encode(CBOR.decode("\xc2\x4daaaaaaaaaaaaa")).should == "\xC2Maaaaaaaaaaaaa".b
+  end
+
+  it "a-non-ascii" do
+    if ''.respond_to? :encode
+      match "abc".encode("UTF-32BE"), "cabc"
+    end
+  end
+
+  it "a" do
+    match "a".encode_as_utf8, "aa"
+    check 2, "a".encode_as_utf8
+    check_decode "aa", "a".encode_as_utf8
+  end
+  
+  it "a.b" do
+    if ''.respond_to? :encode
+      match "a".b, "Aa"
+    end
+    check 2, "a".b
+    check_decode "Aa", "a".b
+  end
+
+  it "[_ ]" do
+    check_decode "\x9f\xff", []
+  end
+
+  it "[_ 1]" do
+    check_decode "\x9f\x01\xff", [1]
+  end
+
+  it "{_ }" do
+    check_decode "\xbf\xff", {}
+  end
+
+  it "{_ 1 => 2}" do
+    check_decode "\xbf\x01\x02\xff", {1 => 2}
+  end
+
+
+  it "{_ 1 => BREAK}" do
+    lambda {
+      check_decode "\xbf\x01\xff", {1 => 2}
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  # Regression tests for https://github.com/cabo/cbor-ruby/issues/20
+  # Nested indefinite-length containers should decode correctly.
+
+  it "{_ 'a' => [_ 1]}" do
+    # indefinite map containing an indefinite array
+    check_decode "\xbf\x61a\x9f\x01\xff\xff", {"a" => [1]}
+  end
+
+  it "{_ 'a' => [_ 1], 'b' => [2, 3]}" do
+    # indefinite map containing an indefinite and a definite array
+    check_decode "\xbf\x61a\x9f\x01\xff\x61b\x82\x02\x03\xff", {"a" => [1], "b" => [2, 3]}
+  end
+
+  it "{_ 'a' => {_ 'b' => 1}}" do
+    # indefinite map containing an indefinite map
+    check_decode "\xbf\x61a\xbf\x61b\x01\xff\xff", {"a" => {"b" => 1}}
+  end
+
+  it "{_ 'a' => {_ }}" do
+    # indefinite map containing an empty indefinite map
+    check_decode "\xbf\x61a\xbf\xff\xff", {"a" => {}}
+  end
+
+  it "{_ 'a' => {_ NO BREAK}" do
+    # indefinite map containing an empty indefinite map
+    lambda {
+      check_decode "\xbf\x61a\xbf\xff", {"a" => {}}
+    }.should raise_error(EOFError)
+  end
+
+  it "{_ 'a' => {} NO BREAK" do
+    # indefinite map containing an empty indefinite map
+    lambda {
+      check_decode "\xbf\x61a\xa0", {"a" => {}}
+    }.should raise_error(EOFError)
+  end
+
+  it "{_ 'a' => {_ 'b' => 1}, 'b' => {'c' => 2}}" do
+    # indefinite map containing an indefinite and a definite map
+    check_decode "\xbf\x61a\xbf\x61b\x01\xff\x61b\xa1\x61c\x02\xff", {"a" => {"b" => 1}, "b" => {"c" => 2}}
+  end
+
+  it "[_ {_ 'a' => 1}]" do
+    # indefinite array containing an indefinite map
+    check_decode "\x9f\xbf\x61a\x01\xff\xff", [{"a" => 1}]
+  end
+
+  it "{_ 'files' => [{_ 'name' => 'foo'}]}" do
+    # indefinite map containing a definite array of indefinite maps
+    # (the exact pattern produced by Jackson's CBOR serializer)
+    check_decode "\xbf\x65files\x81\xbf\x64name\x63foo\xff\xff",
+                 {"files" => [{"name" => "foo"}]}
+  end
+
+  it "deeply nested indefinite containers" do
+    # {_ "a" => {_ "b" => [_ {_ "c" => 1}]}}
+    check_decode "\xbf\x61a\xbf\x61b\x9f\xbf\x61c\x01\xff\xff\xff\xff",
+                 {"a" => {"b" => [{"c" => 1}]}}
+  end
+
+  it "(_ a b)" do
+    check_decode "\x7f\xff", "".encode_as_utf8
+    check_decode "\x5f\xff", "".b
+    check_decode "\x7faa\xff", "a".encode_as_utf8
+    check_decode "\x5fAa\xff", "a".b
+    check_decode "\x7faabbb\xff", "abb".encode_as_utf8
+    check_decode "\x5fAaBbb\xff", "abb".b
+    if ''.respond_to? :encode
+      lambda {
+        check_decode "\x7faaBbb\xff", "abb".encode_as_utf8
+      }.should raise_error(MessagePack::MalformedFormatError)
+      lambda {
+        check_decode "\x7fAa\xff", "a".encode_as_utf8
+      }.should raise_error(MessagePack::MalformedFormatError)
+      lambda {
+        check_decode "\x5fAabbb\xff", "abb".b
+      }.should raise_error(MessagePack::MalformedFormatError)
+      lambda {
+        check_decode "\x5faa\xff", "a".b
+      }.should raise_error(MessagePack::MalformedFormatError)
+    end
+  end
+
+  it "(_ not-a-string)" do
+    lambda {
+      check_decode "\x5f\x00\xff", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "bare break" do
+    lambda {
+      check_decode "\xff", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+    lambda {
+      check_decode "\x82\xff\x00\x00", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+    lambda {
+      check_decode "\x82\x9f\xff\xff", "".b
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "Tagged" do
+    expect { check 10, CBOR::Tagged.new("foo", 2) }.to raise_error(TypeError)
+    check 2, CBOR::Tagged.new(10, 2)
+    check 4, CBOR::Tagged.new(0xBEEF, 2)
+    check 6, CBOR::Tagged.new(0xDEADBEEF, 2)
+    check 10, CBOR::Tagged.new(0xDEADBEEFDEADBEEF, 2)
+    expect { check 10, CBOR::Tagged.new(0x1DEADBEEFDEADBEEF, 2) }.to raise_error(RangeError)
+  end
+
+  it "Time" do
+    check_decode "\xc1\x19\x12\x67", Time.at(4711)
+    check 6, Time.at(Time.now.to_i)
+  end
+
+  it "URI" do
+    require 'uri'
+    # Safe default: object-constructing tags are not reconstructed.
+    check_decode "\xd8\x20\x78\x13http://www.ietf.org", CBOR::Tagged.new(32, "http://www.ietf.org")
+    # Opt in to reconstruct the URI by listing its tag.
+    check_decode "\xd8\x20\x78\x13http://www.ietf.org", URI.parse("http://www.ietf.org"), reconstruct_from_tags: [CBOR::TAG_URI]
+  end
+
+  it "regexp" do
+    # Safe default: tag 35 is not compiled into a Regexp.
+    check_decode "\xd8\x23\x63foo", CBOR::Tagged.new(35, "foo")
+    # Opt in to reconstruct the Regexp by listing its tag.
+    check_decode "\xd8\x23\x63foo", /foo/, reconstruct_from_tags: [CBOR::TAG_REGEXP]
+    check 14, /(?-mix:foo)/, reconstruct_from_tags: [CBOR::TAG_REGEXP]
+    check 6, /foo/, reconstruct_from_tags: [CBOR::TAG_REGEXP]
+  end
+
+  it "Unknown simple 0" do
+    check_decode "\xf3", CBOR::Simple.new(19)
+    check 1, CBOR::Simple.new(0)
+  end
+
+  it "Unknown tag 0" do
+    check_decode "\xc0\x00", CBOR::Tagged.new(0, 0)
+    check 11, CBOR::Tagged.new(4711, "Frotzel")
+  end
+
+  it "Keys as Symbols" do       # Experimental!
+    CBOR.decode(CBOR.encode({:a => 1}), :keys_as_symbols).should == {:a => 1}
+    CBOR.decode(CBOR.encode({:a => 1})).should == {"a" => 1}
+    expect { CBOR.decode("\x00", :foobar) }.to raise_error(ArgumentError)
+  end
+
+  it 'CBOR.decode symbolize_keys' do
+    symbolized_hash = {:a => 'b', :c => 'd'}
+    CBOR.decode(CBOR.encode(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
+  end
+
+  it 'Unpacker#read symbolize_keys' do
+    unpacker = Unpacker.new(:symbolize_keys => true)
+    symbolized_hash = {:a => 'b', :c => 'd'}
+    unpacker.feed(CBOR.encode(symbolized_hash)).read.should == symbolized_hash
+  end
+
+  it 'handle outrageous sizes 1' do
+    expect { CBOR.decode("\xa1") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xba\xff\xff\xff\xff") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xbb\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xbb\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\xbb\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x81") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x9a\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 2' do
+    expect { CBOR.decode("\x9b\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 3' do
+    expect { CBOR.decode("\x9b\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 4' do
+    expect { CBOR.decode("\x9b\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x61") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x7a\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 5' do
+    expect { CBOR.decode("\x7b\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 6' do
+    expect { CBOR.decode("\x7b\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 7' do
+    expect { CBOR.decode("\x7b\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x41") }.to raise_error(EOFError)
+    expect { CBOR.decode("\x5a\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 8' do
+    expect { CBOR.decode("\x5b\xff\xff\xff\xff\xff\xff\xff\xff") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 9' do
+    expect { CBOR.decode("\x5b\x01\x01\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+  it 'handle outrageous sizes 10' do
+    expect { CBOR.decode("\x5b\x00\x00\x01\x01\x01\x01\x01\x01") }.to raise_error(EOFError)
+  end
+
+
+## FIXME
+#  it "{0=>0, 1=>1, ..., 14=>14}" do
+#    a = (0..14).to_a;
+#    match Hash[*a.zip(a).flatten], "\x8f\x05\x05\x0b\x0b\x00\x00\x06\x06\x0c\x0c\x01\x01\x07\x07\x0d\x0d\x02\x02\x08\x08\x0e\x0e\x03\x03\x09\x09\x04\x04\x0a\x0a"
+#  end
+#
+#  it "{0=>0, 1=>1, ..., 15=>15}" do
+#    a = (0..15).to_a;
+#    match Hash[*a.zip(a).flatten], "\xde\x00\x10\x05\x05\x0b\x0b\x00\x00\x06\x06\x0c\x0c\x01\x01\x07\x07\x0d\x0d\x02\x02\x08\x08\x0e\x0e\x03\x03\x09\x09\x0f\x0f\x04\x04\x0a\x0a"
+#  end
+
+## FIXME
+#  it "fixmap" do
+#    check_map 1, 0
+#    check_map 1, (1<<4)-1
+#  end
+#
+#  it "map 16" do
+#    check_map 3, (1<<4)
+#    check_map 3, (1<<16)-1
+#  end
+#
+#  it "map 32" do
+#    check_map 5, (1<<16)
+#    #check_map 5, (1<<32)-1  # memory error
+#  end
+
+  def check(len, obj, opts = nil)
+    raw = obj.to_cbor.to_s
+    raw.length.should == len
+    obj2 = opts ? MessagePack.unpack(raw, opts) : MessagePack.unpack(raw)
+    obj2.should == obj
+    if obj.respond_to? :encoding
+      obj2.encoding.should == obj.encoding
+    end
+  end
+
+  def check_raw(overhead, num)
+    check num+overhead, " "*num
+  end
+
+  def check_array(overhead, num)
+    check num+overhead, Array.new(num)
+  end
+
+  def check_bn(bn, tag)
+    bnb = bignum_to_bytes(bn < 0 ? ~bn : bn)
+    bnbs = bnb.size
+    match bn, "#{tag.chr}#{(bnbs + 0x40).chr}#{bnb}"
+  end
+
+  def match(obj, buf)
+    raw = obj.to_cbor.to_s
+    raw.should == buf
+  end
+
+  def check_decode(c, obj, opts = nil)
+    obj2 = opts ? MessagePack.unpack(c, opts) : MessagePack.unpack(c)
+    obj2.should == obj
+    if obj.respond_to? :encoding
+      obj2.encoding.should == obj.encoding
+    end
+  end
+
+end
+