msgpack 1.5.6 → 1.8.0

data/spec/format_spec.rb

@@ -1,301 +0,0 @@
-# encoding: ascii-8bit
-require 'spec_helper'
-
-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 1, (1 << 6)
-    check 1, (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
-  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, -((1 << 5)-1)
-    check 1, -(1 << 5)
-  end
-
-  it "negative int 8" do
-    check 2, -((1 << 5)+1)
-    check 2, -(1 << 7)
-  end
-
-  it "negative int 16" do
-    check 3, -((1 << 7)+1)
-    check 3, -(1 << 15)
-  end
-
-  it "negative int 32" do
-    check 5, -((1 << 15)+1)
-    check 5, -(1 << 31)
-  end
-
-  it "negative int 64" do
-    check 9, -((1 << 31)+1)
-    check 9, -(1 << 63)
-  end
-
-  it "double" do
-    check 9, 1.0
-    check 9, 0.1
-    check 9, -0.1
-    check 9, -1.0
-  end
-
-  it "fixraw" do
-    check_raw 1, 0
-    check_raw 1, (1 << 5)-1
-  end
-
-  it "raw 8" do
-    check_raw 2, (1 << 5)
-    check_raw 2, (1 << 8)-1
-  end
-
-  it "raw 16" do
-    check_raw 3, (1 << 8)
-    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 "str encoding is UTF_8" do
-    v = pack_unpack('string'.force_encoding(Encoding::UTF_8))
-    v.encoding.should == Encoding::UTF_8
-  end
-
-  it "str transcode US-ASCII" do
-    v = pack_unpack('string'.force_encoding(Encoding::US_ASCII))
-    v.encoding.should == Encoding::UTF_8
-  end
-
-  it "str transcode UTF-16" do
-    v = pack_unpack('string'.encode(Encoding::UTF_16))
-    v.encoding.should == Encoding::UTF_8
-    v.should == 'string'
-  end
-
-  it "str transcode EUC-JP 7bit safe" do
-    v = pack_unpack('string'.force_encoding(Encoding::EUC_JP))
-    v.encoding.should == Encoding::UTF_8
-    v.should == 'string'
-  end
-
-  it "str transcode EUC-JP 7bit unsafe" do
-    v = pack_unpack([0xa4, 0xa2].pack('C*').force_encoding(Encoding::EUC_JP))
-    v.encoding.should == Encoding::UTF_8
-    v.should == "\xE3\x81\x82".force_encoding('UTF-8')
-  end
-
-  it "symbol to str" do
-    v = pack_unpack(:a)
-    v.should == "a".force_encoding('UTF-8')
-  end
-
-  it "symbol to str with encoding" do
-    a = "\xE3\x81\x82".force_encoding('UTF-8')
-    v = pack_unpack(a.encode('Shift_JIS').to_sym)
-    v.encoding.should == Encoding::UTF_8
-    v.should == a
-  end
-
-  it "symbol to bin" do
-    a = "\xE3\x81\x82".force_encoding('ASCII-8BIT')
-    v = pack_unpack(a.to_sym)
-    v.encoding.should == Encoding::ASCII_8BIT
-    v.should == a
-  end
-
-  it "bin 8" do
-    check_bin 2, (1<<8)-1
-  end
-
-  it "bin 16" do
-    check_bin 3, (1<<16)-1
-  end
-
-  it "bin 32" do
-    check_bin 5, (1<<16)
-  end
-
-  it "bin encoding is ASCII_8BIT" do
-    pack_unpack('string'.force_encoding(Encoding::ASCII_8BIT)).encoding.should == Encoding::ASCII_8BIT
-  end
-
-  it "fixarray" do
-    check_array 1, 0
-    check_array 1, (1 << 4)-1
-  end
-
-  it "array 16" do
-    check_array 3, (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, "\xc0"
-  end
-
-  it "false" do
-    match false, "\xc2"
-  end
-
-  it "true" do
-    match true, "\xc3"
-  end
-
-  it "0" do
-    match 0, "\x00"
-  end
-
-  it "127" do
-    match 127, "\x7f"
-  end
-
-  it "128" do
-    match 128, "\xcc\x80"
-  end
-
-  it "256" do
-    match 256, "\xcd\x01\x00"
-  end
-
-  it "-1" do
-    match -1, "\xff"
-  end
-
-  it "-33" do
-    match -33, "\xd0\xdf"
-  end
-
-  it "-129" do
-    match -129, "\xd1\xff\x7f"
-  end
-
-  it "{1=>1}" do
-    obj = {1=>1}
-    match obj, "\x81\x01\x01"
-  end
-
-  it "1.0" do
-    match 1.0, "\xcb\x3f\xf0\x00\x00\x00\x00\x00\x00"
-  end
-
-  it "[]" do
-    match [], "\x90"
-  end
-
-  it "[0, 1, ..., 14]" do
-    obj = (0..14).to_a
-    match obj, "\x9f\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e"
-  end
-
-  it "[0, 1, ..., 15]" do
-    obj = (0..15).to_a
-    match obj, "\xdc\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
-  end
-
-  it "{}" do
-    obj = {}
-    match obj, "\x80"
-  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)
-    raw = obj.to_msgpack.to_s
-    raw.length.should == len
-    MessagePack.unpack(raw).should == obj
-  end
-
-  def check_raw(overhead, num)
-    check num+overhead, (" "*num).force_encoding(Encoding::UTF_8)
-  end
-
-  def check_bin(overhead, num)
-    check num+overhead, (" "*num).force_encoding(Encoding::ASCII_8BIT)
-  end
-
-  def check_array(overhead, num)
-    check num+overhead, Array.new(num)
-  end
-
-  def match(obj, buf)
-    raw = obj.to_msgpack.to_s
-    raw.should == buf
-  end
-
-  def pack_unpack(obj)
-    MessagePack.unpack(obj.to_msgpack)
-  end
-end
-

data/spec/jruby/benchmarks/shootout_bm.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-if RUBY_PLATFORM.include?('java')
-  # JRuby should use this library, MRI should use the standard gem
-  $: << File.expand_path('../../../lib', __FILE__)
-end
-
-require 'viiite'
-require 'msgpack'
-require 'json'
-require 'bson'
-
-if RUBY_PLATFORM.include?('java')
-  BSON_IMPL = BSON::BSON_JAVA
-else
-  BSON_IMPL = BSON::BSON_C
-end
-
-OBJECT_STRUCTURE = {'x' => ['y', 34, 2**30 + 3, 2.1223423423356, {'hello' => 'world', '5' => [63, 'asjdl']}]}
-ENCODED_MSGPACK = "\x81\xA1x\x95\xA1y\"\xCE@\x00\x00\x03\xCB@\x00\xFA\x8E\x9F9\xFA\xC1\x82\xA5hello\xA5world\xA15\x92?\xA5asjdl"
-ENCODED_BSON = "d\x00\x00\x00\x04x\x00\\\x00\x00\x00\x020\x00\x02\x00\x00\x00y\x00\x101\x00\"\x00\x00\x00\x102\x00\x03\x00\x00@\x013\x00\xC1\xFA9\x9F\x8E\xFA\x00@\x034\x002\x00\x00\x00\x02hello\x00\x06\x00\x00\x00world\x00\x045\x00\x19\x00\x00\x00\x100\x00?\x00\x00\x00\x021\x00\x06\x00\x00\x00asjdl\x00\x00\x00\x00\x00"
-ENCODED_JSON = '{"x":["y",34,1073741827,2.1223423423356,{"hello":"world","5":[63,"asjdl"]}]}'
-ITERATIONS = 1_00_000
-IMPLEMENTATIONS = ENV.fetch('IMPLEMENTATIONS', 'json,bson,msgpack').split(',').map(&:to_sym)
-
-Viiite.bm do |b|
-  b.variation_point :ruby, Viiite.which_ruby
-  
-  IMPLEMENTATIONS.each do |lib|
-    b.variation_point :lib, lib
-    
-  
-    b.report(:pack) do
-      ITERATIONS.times do
-        case lib
-        when :msgpack then MessagePack.pack(OBJECT_STRUCTURE)
-        when :bson then BSON_IMPL.serialize(OBJECT_STRUCTURE).to_s
-        when :json then OBJECT_STRUCTURE.to_json
-        end
-      end
-    end
-  
-    b.report(:unpack) do
-      ITERATIONS.times do
-        case lib
-        when :msgpack then MessagePack.unpack(ENCODED_MSGPACK)
-        when :bson then BSON_IMPL.deserialize(ENCODED_BSON)
-        when :json then JSON.parse(ENCODED_JSON)
-        end
-      end
-    end
-    
-    b.report(:pack_unpack) do
-      ITERATIONS.times do
-        case lib
-        when :msgpack then MessagePack.unpack(MessagePack.pack(OBJECT_STRUCTURE))
-        when :bson then BSON_IMPL.deserialize(BSON_IMPL.serialize(OBJECT_STRUCTURE).to_s)
-        when :json then JSON.parse(OBJECT_STRUCTURE.to_json)
-        end
-      end
-    end
-
-    b.report(:unpack_pack) do
-      ITERATIONS.times do
-        case lib
-        when :msgpack then MessagePack.pack(MessagePack.unpack(ENCODED_MSGPACK))
-        when :bson then BSON_IMPL.serialize(BSON_IMPL.deserialize(ENCODED_BSON)).to_s
-        when :json then OBJECT_STRUCTURE.to_json(JSON.parse(ENCODED_JSON))
-        end
-      end
-    end
-  end
-end

data/spec/jruby/benchmarks/symbolize_keys_bm.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-$: << File.expand_path('../../../lib', __FILE__)
-
-require 'viiite'
-require 'msgpack'
-
-
-iterations = 10_000
-data = MessagePack.pack(:hello => 'world', :nested => ['structure', {:value => 42}])
-
-Viiite.bm do |b|
-  b.report(:strings) do
-    iterations.times do
-      MessagePack.unpack(data)
-    end
-  end
-
-  b.report(:symbols) do
-    options = {:symbolize_keys => true}
-    iterations.times do
-      MessagePack.unpack(data, options)
-    end
-  end
-end

data/spec/jruby/unpacker_spec.rb

@@ -1,186 +0,0 @@
-# encoding: ascii-8bit
-
-require 'stringio'
-require 'tempfile'
-
-require 'spec_helper'
-
-describe MessagePack::Unpacker do
-  let :unpacker do
-    MessagePack::Unpacker.new
-  end
-
-  let :packer do
-    MessagePack::Packer.new
-  end
-
-  let :buffer1 do
-    MessagePack.pack(:foo => 'bar')
-  end
-
-  let :buffer2 do
-    MessagePack.pack(:hello => {:world => [1, 2, 3]})
-  end
-
-  let :buffer3 do
-    MessagePack.pack(:x => 'y')
-  end
-
-  describe '#execute/#execute_limit/#finished?' do
-    let :buffer do
-      buffer1 + buffer2 + buffer3
-    end
-
-    it 'extracts an object from the buffer' do
-      subject.execute(buffer, 0)
-      subject.data.should == {'foo' => 'bar'}
-    end
-
-    it 'extracts an object from the buffer, starting at an offset' do
-      subject.execute(buffer, buffer1.length)
-      subject.data.should == {'hello' => {'world' => [1, 2, 3]}}
-    end
-
-    it 'extracts an object from the buffer, starting at an offset reading bytes up to a limit' do
-      subject.execute_limit(buffer, buffer1.length, buffer2.length)
-      subject.data.should == {'hello' => {'world' => [1, 2, 3]}}
-    end
-
-    it 'extracts nothing if the limit cuts an object in half' do
-      subject.execute_limit(buffer, buffer1.length, 3)
-      subject.data.should be_nil
-    end
-
-    it 'returns the offset where the object ended' do
-      subject.execute(buffer, 0).should == buffer1.length
-      subject.execute(buffer, buffer1.length).should == buffer1.length + buffer2.length
-    end
-
-    it 'is finished if #data returns an object' do
-      subject.execute_limit(buffer, buffer1.length, buffer2.length)
-      subject.should be_finished
-
-      subject.execute_limit(buffer, buffer1.length, 3)
-      subject.should_not be_finished
-    end
-  end
-
-  describe '#each' do
-    context 'with a StringIO stream' do
-      it 'yields each object in the stream' do
-        objects = []
-        subject.stream = StringIO.new(buffer1 + buffer2 + buffer3)
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-    end
-
-    context 'with a File stream' do
-      it 'yields each object in the stream' do
-        objects = []
-        file = Tempfile.new('msgpack')
-        file.write(buffer1)
-        file.write(buffer2)
-        file.write(buffer3)
-        file.open
-        subject.stream = file
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-    end
-  end
-
-  describe '#fill' do
-    it 'is a no-op' do
-      subject.stream = StringIO.new(buffer1 + buffer2 + buffer3)
-      subject.fill
-      subject.each { |obj| }
-    end
-  end
-
-  def flatten(struct, results = [])
-    case struct
-    when Array
-      struct.each { |v| flatten(v, results) }
-    when Hash
-      struct.each { |k, v| flatten(v, flatten(k, results)) }
-    else
-      results << struct
-    end
-    results
-  end
-
-  context 'encoding', :encodings do
-    before :all do
-      @default_internal = Encoding.default_internal
-      @default_external = Encoding.default_external
-    end
-
-    after :all do
-      Encoding.default_internal = @default_internal
-      Encoding.default_external = @default_external
-    end
-
-    let :buffer do
-      MessagePack.pack({'hello' => 'world', 'nested' => ['object', {"sk\xC3\xA5l".force_encoding('utf-8') => true}]})
-    end
-
-    let :unpacker do
-      described_class.new
-    end
-
-    before do
-      Encoding.default_internal = Encoding::UTF_8
-      Encoding.default_external = Encoding::ISO_8859_1
-    end
-
-    it 'produces results with encoding as binary or string(utf8)' do
-      unpacker.execute(buffer, 0)
-      strings = flatten(unpacker.data).grep(String)
-      strings.map(&:encoding).uniq.sort{|a,b| a.to_s <=> b.to_s}.should == [Encoding::ASCII_8BIT, Encoding::UTF_8]
-    end
-
-    it 'recodes to internal encoding' do
-      unpacker.execute(buffer, 0)
-      unpacker.data['nested'][1].keys.should == ["sk\xC3\xA5l".force_encoding(Encoding::UTF_8)]
-    end
-  end
-
-  context 'extensions' do
-    context 'symbolized keys' do
-      let :buffer do
-        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
-      end
-
-      let :unpacker do
-        described_class.new(:symbolize_keys => true)
-      end
-
-      it 'can symbolize keys when using #execute' do
-        unpacker.execute(buffer, 0)
-        unpacker.data.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
-      end
-    end
-
-    context 'encoding', :encodings do
-      let :buffer do
-        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
-      end
-
-      let :unpacker do
-        described_class.new()
-      end
-
-      it 'decode binary as ascii-8bit string when using #execute' do
-        unpacker.execute(buffer, 0)
-        strings = flatten(unpacker.data).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::ASCII_8BIT]
-      end
-    end
-  end
-end