msgpack 1.4.3-java → 1.4.4-java

data/spec/ext_value_spec.rb

@@ -1,99 +0,0 @@
-# encoding: ascii-8bit
-require 'spec_helper'
-
-describe MessagePack::ExtensionValue do
-  subject do
-    described_class.new(1, "data")
-  end
-
-  describe '#type/#type=' do
-    it 'returns value set by #initialize' do
-      subject.type.should == 1
-    end
-
-    it 'assigns a value' do
-      subject.type = 2
-      subject.type.should == 2
-    end
-  end
-
-  describe '#payload/#payload=' do
-    it 'returns value set by #initialize' do
-      subject.payload.should == "data"
-    end
-
-    it 'assigns a value' do
-      subject.payload = "a"
-      subject.payload.should == "a"
-    end
-  end
-
-  describe '#==/#eql?/#hash' do
-    it 'returns equivalent if the content is same' do
-      ext1 = MessagePack::ExtensionValue.new(1, "data")
-      ext2 = MessagePack::ExtensionValue.new(1, "data")
-      (ext1 == ext2).should be true
-      ext1.eql?(ext2).should be true
-      (ext1.hash == ext2.hash).should be true
-    end
-
-    it 'returns not equivalent if type is not same' do
-      ext1 = MessagePack::ExtensionValue.new(1, "data")
-      ext2 = MessagePack::ExtensionValue.new(2, "data")
-      (ext1 == ext2).should be false
-      ext1.eql?(ext2).should be false
-      (ext1.hash == ext2.hash).should be false
-    end
-
-    it 'returns not equivalent if payload is not same' do
-      ext1 = MessagePack::ExtensionValue.new(1, "data")
-      ext2 = MessagePack::ExtensionValue.new(1, "value")
-      (ext1 == ext2).should be false
-      ext1.eql?(ext2).should be false
-      (ext1.hash == ext2.hash).should be false
-    end
-  end
-
-  describe '#to_msgpack' do
-    it 'serializes very short payload' do
-      ext = MessagePack::ExtensionValue.new(1, "a"*2).to_msgpack
-      ext.should == "\xd5\x01" + "a"*2
-    end
-
-    it 'serializes short payload' do
-      ext = MessagePack::ExtensionValue.new(1, "a"*18).to_msgpack
-      ext.should == "\xc7\x12\x01" + "a"*18
-    end
-
-    it 'serializes long payload' do
-      ext = MessagePack::ExtensionValue.new(1, "a"*65540).to_msgpack
-      ext.should == "\xc9\x00\x01\x00\x04\x01" + "a"*65540
-    end
-
-    it 'with a packer serializes to a packer' do
-      ext = MessagePack::ExtensionValue.new(1, "aa")
-      packer = MessagePack::Packer.new
-      ext.to_msgpack(packer)
-      packer.buffer.to_s.should == "\xd5\x01aa"
-    end
-
-    [-129, -65540, -(2**40), 128, 65540, 2**40].each do |type|
-      context "with invalid type (#{type})" do
-        it 'raises RangeError' do
-          lambda { MessagePack::ExtensionValue.new(type, "a").to_msgpack }.should raise_error(RangeError)
-        end
-      end
-    end
-  end
-
-  describe '#dup' do
-    it 'duplicates' do
-      ext1 = MessagePack::ExtensionValue.new(1, "data")
-      ext2 = ext1.dup
-      ext2.type = 2
-      ext2.payload = "data2"
-      ext1.type.should == 1
-      ext1.payload.should == "data"
-    end
-  end
-end

data/spec/exttypes.rb

@@ -1,51 +0,0 @@
-class DummyTimeStamp1
-  TYPE = 15
-
-  attr_reader :utime, :usec, :time
-
-  def initialize(utime, usec)
-    @utime = utime
-    @usec = usec
-    @time = Time.at(utime, usec)
-  end
-
-  def ==(other)
-    self.utime == other.utime && self.usec == other.usec
-  end
-
-  def self.type_id
-    15
-  end
-
-  def self.from_msgpack_ext(data)
-    new(*data.unpack('I*'))
-  end
-
-  def to_msgpack_ext
-    [@utime,@usec].pack('I*')
-  end
-end
-
-class DummyTimeStamp2
-  TYPE = 16
-
-  attr_reader :utime, :usec, :time
-
-  def initialize(utime, usec)
-    @utime = utime
-    @usec = usec
-    @time = Time.at(utime, usec)
-  end
-
-  def ==(other)
-    self.utime == other.utime && self.usec == other.usec
-  end
-
-  def self.deserialize(data)
-    new(* data.split(',', 2).map(&:to_i))
-  end
-
-  def serialize
-    [@utime,@usec].map(&:to_s).join(',')
-  end
-end

data/spec/factory_spec.rb

@@ -1,384 +0,0 @@
-# encoding: ascii-8bit
-require 'spec_helper'
-
-describe MessagePack::Factory do
-  subject do
-    described_class.new
-  end
-
-  describe '#packer' do
-    it 'creates a Packer instance' do
-      subject.packer.should be_kind_of(MessagePack::Packer)
-    end
-
-    it 'creates new instance' do
-      subject.packer.object_id.should_not == subject.packer.object_id
-    end
-  end
-
-  describe '#unpacker' do
-    it 'creates a Unpacker instance' do
-      subject.unpacker.should be_kind_of(MessagePack::Unpacker)
-    end
-
-    it 'creates new instance' do
-      subject.unpacker.object_id.should_not == subject.unpacker.object_id
-    end
-
-    it 'creates unpacker with symbolize_keys option' do
-      unpacker = subject.unpacker(symbolize_keys: true)
-      unpacker.feed(MessagePack.pack({'k'=>'v'}))
-      unpacker.read.should == {:k => 'v'}
-    end
-
-    it 'creates unpacker with allow_unknown_ext option' do
-      unpacker = subject.unpacker(allow_unknown_ext: true)
-      unpacker.feed(MessagePack::ExtensionValue.new(1, 'a').to_msgpack)
-      unpacker.read.should == MessagePack::ExtensionValue.new(1, 'a')
-    end
-
-    it 'creates unpacker without allow_unknown_ext option' do
-      unpacker = subject.unpacker
-      unpacker.feed(MessagePack::ExtensionValue.new(1, 'a').to_msgpack)
-      expect{ unpacker.read }.to raise_error(MessagePack::UnknownExtTypeError)
-    end
-  end
-
-  describe '#dump and #load' do
-    it 'can be used like a standard coder' do
-      subject.register_type(0x00, Symbol)
-      expect(subject.load(subject.dump(:symbol))).to be == :symbol
-    end
-
-    it 'is alias as pack and unpack' do
-      subject.register_type(0x00, Symbol)
-      expect(subject.unpack(subject.pack(:symbol))).to be == :symbol
-    end
-
-    it 'accept options' do
-      hash = subject.unpack(MessagePack.pack('k' => 'v'), symbolize_keys: true)
-      expect(hash).to be == { k: 'v' }
-    end
-  end
-
-  describe '#freeze' do
-    it 'can freeze factory instance to deny new registrations anymore' do
-      subject.register_type(0x00, Symbol)
-      subject.freeze
-      expect(subject.frozen?).to be_truthy
-      expect{ subject.register_type(0x01, Array) }.to raise_error(RuntimeError, "can't modify frozen Factory")
-    end
-  end
-
-  class MyType
-    def initialize(a, b)
-      @a = a
-      @b = b
-    end
-
-    attr_reader :a, :b
-
-    def to_msgpack_ext
-      [a, b].pack('CC')
-    end
-
-    def self.from_msgpack_ext(data)
-      new(*data.unpack('CC'))
-    end
-
-    def to_msgpack_ext_only_a
-      [a, 0].pack('CC')
-    end
-
-    def self.from_msgpack_ext_only_b(data)
-      a, b = *data.unpack('CC')
-      new(0, b)
-    end
-  end
-
-  class MyType2 < MyType
-  end
-
-  describe '#registered_types' do
-    it 'returns Array' do
-      expect(subject.registered_types).to be_instance_of(Array)
-    end
-
-    it 'returns Array of Hash contains :type, :class, :packer, :unpacker' do
-      subject.register_type(0x20, ::MyType)
-      subject.register_type(0x21, ::MyType2)
-
-      list = subject.registered_types
-
-      expect(list.size).to eq(2)
-      expect(list[0]).to be_instance_of(Hash)
-      expect(list[1]).to be_instance_of(Hash)
-      expect(list[0].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
-      expect(list[1].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
-
-      expect(list[0][:type]).to eq(0x20)
-      expect(list[0][:class]).to eq(::MyType)
-      expect(list[0][:packer]).to eq(:to_msgpack_ext)
-      expect(list[0][:unpacker]).to eq(:from_msgpack_ext)
-
-      expect(list[1][:type]).to eq(0x21)
-      expect(list[1][:class]).to eq(::MyType2)
-      expect(list[1][:packer]).to eq(:to_msgpack_ext)
-      expect(list[1][:unpacker]).to eq(:from_msgpack_ext)
-    end
-
-    it 'returns Array of Hash which has nil for unregistered feature' do
-      subject.register_type(0x21, ::MyType2, unpacker: :from_msgpack_ext)
-      subject.register_type(0x20, ::MyType, packer: :to_msgpack_ext)
-
-      list = subject.registered_types
-
-      expect(list.size).to eq(2)
-      expect(list[0]).to be_instance_of(Hash)
-      expect(list[1]).to be_instance_of(Hash)
-      expect(list[0].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
-      expect(list[1].keys.sort).to eq([:type, :class, :packer, :unpacker].sort)
-
-      expect(list[0][:type]).to eq(0x20)
-      expect(list[0][:class]).to eq(::MyType)
-      expect(list[0][:packer]).to eq(:to_msgpack_ext)
-      expect(list[0][:unpacker]).to be_nil
-
-      expect(list[1][:type]).to eq(0x21)
-      expect(list[1][:class]).to eq(::MyType2)
-      expect(list[1][:packer]).to be_nil
-      expect(list[1][:unpacker]).to eq(:from_msgpack_ext)
-    end
-  end
-
-  describe '#type_registered?' do
-    it 'receive Class or Integer, and return bool' do
-      expect(subject.type_registered?(0x00)).to be_falsy
-      expect(subject.type_registered?(0x01)).to be_falsy
-      expect(subject.type_registered?(::MyType)).to be_falsy
-    end
-
-    it 'has option to specify what types are registered for' do
-      expect(subject.type_registered?(0x00, :both)).to be_falsy
-      expect(subject.type_registered?(0x00, :packer)).to be_falsy
-      expect(subject.type_registered?(0x00, :unpacker)).to be_falsy
-      expect{ subject.type_registered?(0x00, :something) }.to raise_error(ArgumentError)
-    end
-
-    it 'returns true if specified type or class is already registered' do
-      subject.register_type(0x20, ::MyType)
-      subject.register_type(0x21, ::MyType2)
-
-      expect(subject.type_registered?(0x00)).to be_falsy
-      expect(subject.type_registered?(0x01)).to be_falsy
-
-      expect(subject.type_registered?(0x20)).to be_truthy
-      expect(subject.type_registered?(0x21)).to be_truthy
-      expect(subject.type_registered?(::MyType)).to be_truthy
-      expect(subject.type_registered?(::MyType2)).to be_truthy
-    end
-  end
-
-  describe '#register_type' do
-    let :src do
-      ::MyType.new(1, 2)
-    end
-
-    it 'registers #to_msgpack_ext and .from_msgpack_ext by default' do
-      subject.register_type(0x7f, ::MyType)
-
-      data = subject.packer.write(src).to_s
-      my = subject.unpacker.feed(data).read
-      my.a.should == 1
-      my.b.should == 2
-    end
-
-    it 'registers custom packer method name' do
-      subject.register_type(0x7f, ::MyType, packer: :to_msgpack_ext_only_a, unpacker: :from_msgpack_ext)
-
-      data = subject.packer.write(src).to_s
-      my = subject.unpacker.feed(data).read
-      my.a.should == 1
-      my.b.should == 0
-    end
-
-    it 'registers custom unpacker method name' do
-      subject.register_type(0x7f, ::MyType, packer: :to_msgpack_ext, unpacker: 'from_msgpack_ext_only_b')
-
-      data = subject.packer.write(src).to_s
-      my = subject.unpacker.feed(data).read
-      my.a.should == 0
-      my.b.should == 2
-    end
-
-    it 'registers custom proc objects' do
-      pk = lambda {|obj| [obj.a + obj.b].pack('C') }
-      uk = lambda {|data| ::MyType.new(data.unpack('C').first, -1) }
-      subject.register_type(0x7f, ::MyType, packer: pk, unpacker: uk)
-
-      data = subject.packer.write(src).to_s
-      my = subject.unpacker.feed(data).read
-      my.a.should == 3
-      my.b.should == -1
-    end
-
-    it 'does not affect existent packer and unpackers' do
-      subject.register_type(0x7f, ::MyType)
-      packer = subject.packer
-      unpacker = subject.unpacker
-
-      subject.register_type(0x7f, ::MyType, packer: :to_msgpack_ext_only_a, unpacker: :from_msgpack_ext_only_b)
-
-      data = packer.write(src).to_s
-      my = unpacker.feed(data).read
-      my.a.should == 1
-      my.b.should == 2
-    end
-
-    describe "registering an ext type for a module" do
-      before do
-        mod = Module.new do
-          def self.from_msgpack_ext(data)
-            "unpacked #{data}"
-          end
-
-          def to_msgpack_ext
-            'value_msgpacked'
-          end
-        end
-        stub_const('Mod', mod)
-      end
-      let(:factory) { described_class.new }
-      before { factory.register_type(0x01, Mod) }
-
-      describe "packing an object whose class included the module" do
-        subject { factory.packer.pack(value).to_s }
-        before { stub_const('Value', Class.new{ include Mod }) }
-        let(:value) { Value.new }
-        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
-      end
-
-      describe "packing an object which has been extended by the module" do
-        subject { factory.packer.pack(object).to_s }
-        let(:object) { Object.new.extend Mod }
-        it { is_expected.to eq "\xC7\x0F\x01value_msgpacked" }
-      end
-
-      describe "unpacking with the module" do
-        subject { factory.unpacker.feed("\xC7\x06\x01module").unpack }
-        it { is_expected.to eq "unpacked module" }
-      end
-    end
-  end
-
-  describe 'the special treatment of symbols with ext type' do
-    let(:packer) { subject.packer }
-    let(:unpacker) { subject.unpacker }
-
-    def symbol_after_roundtrip
-      packed_symbol = packer.pack(:symbol).to_s
-      unpacker.feed(packed_symbol).unpack
-    end
-
-    context 'using the optimized symbol unpacker' do
-      before do
-        skip if IS_JRUBY # JRuby implementation doesn't support the optimized symbols unpacker for now
-        subject.register_type(
-          0x00,
-          ::Symbol,
-          packer: :to_msgpack_ext,
-          unpacker: :from_msgpack_ext,
-          optimized_symbols_parsing: true,
-        )
-      end
-
-      it 'lets symbols survive a roundtrip' do
-        expect(symbol_after_roundtrip).to be :symbol
-      end
-    end
-
-    context 'if no ext type is registered for symbols' do
-      it 'converts symbols to string' do
-        expect(symbol_after_roundtrip).to eq 'symbol'
-      end
-    end
-
-    context 'if an ext type is registered for symbols' do
-      context 'if using the default serializer' do
-        before { subject.register_type(0x00, ::Symbol) }
-
-        it 'lets symbols survive a roundtrip' do
-          expect(symbol_after_roundtrip).to be :symbol
-        end
-      end
-
-      context 'if using a custom serializer' do
-        before do
-          class Symbol
-            alias_method :to_msgpack_ext_orig, :to_msgpack_ext
-            def to_msgpack_ext
-              self.to_s.codepoints.to_a.pack('n*')
-            end
-          end
-
-          class << Symbol
-            alias_method :from_msgpack_ext_orig, :from_msgpack_ext
-            def from_msgpack_ext(data)
-              data.unpack('n*').map(&:chr).join.to_sym
-            end
-          end
-        end
-
-        before { subject.register_type(0x00, ::Symbol) }
-
-        it 'lets symbols survive a roundtrip' do
-          expect(symbol_after_roundtrip).to be :symbol
-        end
-
-        after do
-          class Symbol
-            alias_method :to_msgpack_ext, :to_msgpack_ext_orig
-          end
-
-          class << Symbol
-            alias_method :from_msgpack_ext, :from_msgpack_ext_orig
-          end
-        end
-      end
-    end
-  end
-
-  describe 'under stressful GC' do
-    it 'works well' do
-      begin
-        GC.stress = true
-
-        f = MessagePack::Factory.new
-        f.register_type(0x0a, Symbol)
-      ensure
-        GC.stress = false
-      end
-    end
-  end
-
-  describe 'DefaultFactory' do
-    it 'is a factory' do
-      MessagePack::DefaultFactory.should be_kind_of(MessagePack::Factory)
-    end
-
-    require_relative 'exttypes'
-
-    it 'should be referred by MessagePack.pack and MessagePack.unpack' do
-      MessagePack::DefaultFactory.register_type(DummyTimeStamp1::TYPE, DummyTimeStamp1)
-      MessagePack::DefaultFactory.register_type(DummyTimeStamp2::TYPE, DummyTimeStamp2, packer: :serialize, unpacker: :deserialize)
-
-      t = Time.now
-
-      dm1 = DummyTimeStamp1.new(t.to_i, t.usec)
-      expect(MessagePack.unpack(MessagePack.pack(dm1))).to eq(dm1)
-
-      dm2 = DummyTimeStamp1.new(t.to_i, t.usec)
-      expect(MessagePack.unpack(MessagePack.pack(dm2))).to eq(dm2)
-    end
-  end
-end