hessian2 2.0.2 → 2.0.3

data/spec/int_spec.rb

@@ -1,54 +1,54 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when int" do
-      
-      it "should write one-octet compact int (-x10 to x2f, x90 is 0) ::= [x80-xbf]" do
-        (-0x10..0x2f).each do |val|
-          bin = Hessian2.write(val)
-
-          expect(bin.unpack('C').first - 0x90).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write two-octet compact int (-x800 to x7ff) ::= [xc0-xcf] b0" do
-        -0x800.step(0x7ff, 0x100).select{|x| !(-0x10..0x2f).include?(x)}.each do |val|
-          bin = Hessian2.write(val)
-
-          b1, b0 = bin[0, 2].unpack('CC')
-          expect(((b1 - 0xc8) << 8) + b0).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write three-octet compact int (-x40000 to x3ffff) ::= [xd0-xd7] b1 b0" do
-        -0x40000.step(0x3ffff, 0x10000).select{|x| !(-0x800..0x7ff).include?(x)}.each do |val|
-          bin = Hessian2.write(val)
-
-          b2, b1, b0 = bin[0, 3].unpack('CCC')
-          expect(((b2 - 0xd4) << 16) + (b1 << 8) + b0).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write 32-bit signed integer ('I') ::= 'I' b3 b2 b1 b0" do
-        fixnum_max = 2 ** (0.size * 8 - 2) - 1
-        fixnum_min = -(2 ** (0.size * 8 - 2))
-
-        [ -0x80_000_000, 0x7f_fff_fff, -0x40001, 0x40000 ].each do |val|
-          bin = Hessian2.write(val > fixnum_max || val < fixnum_min ? Hessian2::TypeWrapper.new(:int, val) : val)
-
-          expect(bin[0]).to eq('I')
-          expect(bin[1, 4].unpack('l>').first).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when int" do
+      
+      it "should write one-octet compact int (-x10 to x2f, x90 is 0) ::= [x80-xbf]" do
+        (-0x10..0x2f).each do |val|
+          bin = Hessian2.write(val)
+
+          expect(bin.unpack('C').first - 0x90).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write two-octet compact int (-x800 to x7ff) ::= [xc0-xcf] b0" do
+        -0x800.step(0x7ff, 0x100).select{|x| !(-0x10..0x2f).include?(x)}.each do |val|
+          bin = Hessian2.write(val)
+
+          b1, b0 = bin[0, 2].unpack('CC')
+          expect(((b1 - 0xc8) << 8) + b0).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write three-octet compact int (-x40000 to x3ffff) ::= [xd0-xd7] b1 b0" do
+        -0x40000.step(0x3ffff, 0x10000).select{|x| !(-0x800..0x7ff).include?(x)}.each do |val|
+          bin = Hessian2.write(val)
+
+          b2, b1, b0 = bin[0, 3].unpack('CCC')
+          expect(((b2 - 0xd4) << 16) + (b1 << 8) + b0).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write 32-bit signed integer ('I') ::= 'I' b3 b2 b1 b0" do
+        fixnum_max = 2 ** (0.size * 8 - 2) - 1
+        fixnum_min = -(2 ** (0.size * 8 - 2))
+
+        [ -0x80_000_000, 0x7f_fff_fff, -0x40001, 0x40000 ].each do |val|
+          bin = Hessian2.write(val > fixnum_max || val < fixnum_min ? Hessian2::TypeWrapper.new(:int, val) : val)
+
+          expect(bin[0]).to eq('I')
+          expect(bin[1, 4].unpack('l>').first).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+    end
+  end
+end

data/spec/list_spec.rb

@@ -1,66 +1,66 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when list" do
-
-      it "should write variable-length list/vector ('U') ::= x55 type value* 'Z'" do
-        # not implemented
-      end
-
-
-      it "should write fixed-length list/vector ('V') ::= 'V' type int value*" do
-        val = (1..9).to_a
-        bin = Hessian2.write(Hessian2::TypeWrapper.new('[int', val))
-
-        bytes = bin.each_byte
-        expect([ bytes.next ].pack('C')).to eq('V')
-        expect(Hessian2.parse_string(bytes)).to eq('[I')
-        expect(Hessian2.parse_int(bytes)).to eq(val.size)
-        expect(Hessian2.parse(bin)).to eq(val)
-      end
-
-
-      it "should write variable-length untyped list/vector ('W') ::= x57 value* 'Z'" do
-        # not implemented
-      end
-
-
-      it "should write fixed-length untyped list/vector ('X') ::= x58 int value*" do
-        val = [ Time.new(2005, 3, 4), '阿门', 59.59 ] * 3
-        bin = Hessian2.write(val)
-        
-        bytes = bin.each_byte
-        expect([ bytes.next ].pack('C')).to eq('X')
-        expect(Hessian2.parse_int(bytes)).to eq(val.size)
-        expect(Hessian2.parse(bin)).to eq(val)
-      end
-
-
-      it "should write fixed list with direct length ::= [x70-77] type value*" do
-        8.times do |i|
-          val = (0...i).to_a
-          bin = Hessian2.write(Hessian2::TypeWrapper.new('[int', val))
-
-          bytes = bin.each_byte
-          expect(bytes.next - 0x70).to eq(val.size)
-          expect(Hessian2.parse_string(bytes)).to eq('[I')
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write fixed untyped list with direct length ::= [x78-7f] value*" do
-        8.times do |i|
-          val = (0...i).to_a
-          bin = Hessian2.write(val)
-
-          bytes = bin.each_byte
-          expect(bytes.next - 0x78).to eq(val.size)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when list" do
+
+      it "should write variable-length list/vector ('U') ::= x55 type value* 'Z'" do
+        # not implemented
+      end
+
+
+      it "should write fixed-length list/vector ('V') ::= 'V' type int value*" do
+        val = (1..9).to_a
+        bin = Hessian2.write(Hessian2::TypeWrapper.new('[int', val))
+
+        bytes = bin.each_byte
+        expect([ bytes.next ].pack('C')).to eq('V')
+        expect(Hessian2.parse_string(bytes)).to eq('[I')
+        expect(Hessian2.parse_int(bytes)).to eq(val.size)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+
+      it "should write variable-length untyped list/vector ('W') ::= x57 value* 'Z'" do
+        # not implemented
+      end
+
+
+      it "should write fixed-length untyped list/vector ('X') ::= x58 int value*" do
+        val = [ Time.new(2005, 3, 4), '阿门', 59.59 ] * 3
+        bin = Hessian2.write(val)
+        
+        bytes = bin.each_byte
+        expect([ bytes.next ].pack('C')).to eq('X')
+        expect(Hessian2.parse_int(bytes)).to eq(val.size)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+
+      it "should write fixed list with direct length ::= [x70-77] type value*" do
+        8.times do |i|
+          val = (0...i).to_a
+          bin = Hessian2.write(Hessian2::TypeWrapper.new('[int', val))
+
+          bytes = bin.each_byte
+          expect(bytes.next - 0x70).to eq(val.size)
+          expect(Hessian2.parse_string(bytes)).to eq('[I')
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write fixed untyped list with direct length ::= [x78-7f] value*" do
+        8.times do |i|
+          val = (0...i).to_a
+          bin = Hessian2.write(val)
+
+          bytes = bin.each_byte
+          expect(bytes.next - 0x78).to eq(val.size)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+    end
+  end
+end

data/spec/long_spec.rb

@@ -1,68 +1,68 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when long" do
-      
-      it "should write one-octet compact long (-x8 to xf, xe0 is 0) ::= [xd8-xef]" do
-        (-0x08..0x0f).each do |val|
-          bin = Hessian2.write(Hessian2::TypeWrapper.new(:long, val))
-
-          expect(bin.unpack('C').first - 0xe0).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write two-octet compact long (-x800 to x7ff, xf8 is 0) ::= [xf0-xff] b0" do
-        -0x800.step(0x7ff, 0x100).select{|x| !(-0x08..0x0f).include?(x)}.each do |val|
-          bin = Hessian2.write(Hessian2::TypeWrapper.new(:long, val))
-
-          b1, b0 = bin[0, 2].unpack('CC')
-          expect(((b1 - 0xf8) << 8) + b0).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write three-octet compact long (-x40000 to x3ffff) ::= [x38-x3f] b1 b0" do
-        -0x40000.step(0x3ffff, 0x10000).select{|x| !(-0x800..0x7ff).include?(x)}.each do |val|
-          bin = Hessian2.write(Hessian2::TypeWrapper.new(:long, val))
-
-          b2, b1, b0 = bin[0, 3].unpack('CCC')
-          expect(((b2 - 0x3c) << 16) + (b1 << 8) + b0).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write long encoded as 32-bit int ('Y') ::= x59 b3 b2 b1 b0" do
-        fixnum_max = 2 ** (0.size * 8 - 2) - 1
-        fixnum_min = -(2 ** (0.size * 8 - 2))
-
-        [ -0x80_000_000, 0x7f_fff_fff, -0x40001, 0x40000 ].each do |val|
-          bin = Hessian2.write(val <= fixnum_max && val >= fixnum_min ? Hessian2::TypeWrapper.new(:long, val) : val)
-
-          expect(bin[0]).to eq('Y')
-          expect(bin[1, 4].unpack('l>').first).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-
-      it "should write 64-bit signed long integer ('L') ::= 'L' b7 b6 b5 b4 b3 b2 b1 b0" do
-        fixnum_max = 2 ** (0.size * 8 - 2) - 1
-        fixnum_min = -(2 ** (0.size * 8 - 2))
-
-        [ -0x8_000_000_000_000_000, 0x7_fff_fff_fff_fff_fff, -0x80_000_001, 0x80_000_000 ].each do |val|
-          bin = Hessian2.write(val <= fixnum_max && val >= fixnum_min ? Hessian2::TypeWrapper.new(:long, val) : val)
-
-          expect(bin[0]).to eq('L')
-          expect(bin[1, 8].unpack('q>').first).to eq(val)
-          expect(Hessian2.parse(bin)).to eq(val)
-        end
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when long" do
+      
+      it "should write one-octet compact long (-x8 to xf, xe0 is 0) ::= [xd8-xef]" do
+        (-0x08..0x0f).each do |val|
+          bin = Hessian2.write(Hessian2::TypeWrapper.new(:long, val))
+
+          expect(bin.unpack('C').first - 0xe0).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write two-octet compact long (-x800 to x7ff, xf8 is 0) ::= [xf0-xff] b0" do
+        -0x800.step(0x7ff, 0x100).select{|x| !(-0x08..0x0f).include?(x)}.each do |val|
+          bin = Hessian2.write(Hessian2::TypeWrapper.new(:long, val))
+
+          b1, b0 = bin[0, 2].unpack('CC')
+          expect(((b1 - 0xf8) << 8) + b0).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write three-octet compact long (-x40000 to x3ffff) ::= [x38-x3f] b1 b0" do
+        -0x40000.step(0x3ffff, 0x10000).select{|x| !(-0x800..0x7ff).include?(x)}.each do |val|
+          bin = Hessian2.write(Hessian2::TypeWrapper.new(:long, val))
+
+          b2, b1, b0 = bin[0, 3].unpack('CCC')
+          expect(((b2 - 0x3c) << 16) + (b1 << 8) + b0).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write long encoded as 32-bit int ('Y') ::= x59 b3 b2 b1 b0" do
+        fixnum_max = 2 ** (0.size * 8 - 2) - 1
+        fixnum_min = -(2 ** (0.size * 8 - 2))
+
+        [ -0x80_000_000, 0x7f_fff_fff, -0x40001, 0x40000 ].each do |val|
+          bin = Hessian2.write(val <= fixnum_max && val >= fixnum_min ? Hessian2::TypeWrapper.new(:long, val) : val)
+
+          expect(bin[0]).to eq('Y')
+          expect(bin[1, 4].unpack('l>').first).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write 64-bit signed long integer ('L') ::= 'L' b7 b6 b5 b4 b3 b2 b1 b0" do
+        fixnum_max = 2 ** (0.size * 8 - 2) - 1
+        fixnum_min = -(2 ** (0.size * 8 - 2))
+
+        [ -0x8_000_000_000_000_000, 0x7_fff_fff_fff_fff_fff, -0x80_000_001, 0x80_000_000 ].each do |val|
+          bin = Hessian2.write(val <= fixnum_max && val >= fixnum_min ? Hessian2::TypeWrapper.new(:long, val) : val)
+
+          expect(bin[0]).to eq('L')
+          expect(bin[1, 8].unpack('q>').first).to eq(val)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+    end
+  end
+end

data/spec/map_spec.rb

@@ -1,36 +1,36 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when map" do
-      hash = { born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
-
-      it "should write map with type ('M') ::= M type (value value)* Z" do
-        type = 'Monkey'
-        bin = Hessian2.write(Hessian2::TypeWrapper.new(type, hash))
-
-        bytes = bin.each_byte
-        expect([ bytes.next ].pack('C')).to eq('M')
-        expect(Hessian2.parse_string(bytes)).to eq(type)
-        _hash = Hessian2.parse(bin)
-        expect([ _hash['born_at'], _hash['name'], _hash['price'] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-        _hash2 = Hessian2.parse(bin, nil, symbolize_keys: true)
-        expect(_hash2).to eq(hash)
-      end
-
-
-      it "should write untyped map ::= 'H' (value value)* 'Z'" do
-        bin = Hessian2.write(hash)
-
-        bytes = bin.each_byte
-        expect(bin[0]).to eq('H')
-        expect(bin[-1]).to eq('Z')
-        _hash = Hessian2.parse(bin)
-        expect([ _hash['born_at'], _hash['name'], _hash['price'] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-        _hash2 = Hessian2.parse(bin, nil, symbolize_keys: true)
-        expect(_hash2).to eq(hash)
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when map" do
+      hash = { born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write map with type ('M') ::= M type (value value)* Z" do
+        type = 'Monkey'
+        bin = Hessian2.write(Hessian2::TypeWrapper.new(type, hash))
+
+        bytes = bin.each_byte
+        expect([ bytes.next ].pack('C')).to eq('M')
+        expect(Hessian2.parse_string(bytes)).to eq(type)
+        _hash = Hessian2.parse(bin)
+        expect([ _hash['born_at'], _hash['name'], _hash['price'] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        _hash2 = Hessian2.parse(bin, nil, symbolize_keys: true)
+        expect(_hash2).to eq(hash)
+      end
+
+
+      it "should write untyped map ::= 'H' (value value)* 'Z'" do
+        bin = Hessian2.write(hash)
+
+        bytes = bin.each_byte
+        expect(bin[0]).to eq('H')
+        expect(bin[-1]).to eq('Z')
+        _hash = Hessian2.parse(bin)
+        expect([ _hash['born_at'], _hash['name'], _hash['price'] ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        _hash2 = Hessian2.parse(bin, nil, symbolize_keys: true)
+        expect(_hash2).to eq(hash)
+      end
+
+    end
+  end
+end

data/spec/null_spec.rb

@@ -1,17 +1,17 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when null" do
-      
-      it "should write null ('N') ::= 'N'" do
-        val = nil
-        bin = Hessian2.write(val)
-
-        expect(bin).to eq('N')
-        expect(Hessian2.parse(bin)).to eq(val)
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when null" do
+      
+      it "should write null ('N') ::= 'N'" do
+        val = nil
+        bin = Hessian2.write(val)
+
+        expect(bin).to eq('N')
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/object_spec.rb

@@ -1,78 +1,78 @@
-require File.expand_path('../spec_helper', __FILE__)
-
-module Hessian2
-  describe Writer do
-    context "when object" do
-      hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
-
-      it "should write object type definition ('C') ::= 'C' string int string* and object with direct type ::= [x60-x6f] value*" do
-        [ 'Monkey', 'AnotherMonkey' ].each do |klass|
-          bin = Hessian2.write(Kernel.const_get(klass).new(hash))
-
-          bytes = bin.each_byte
-          expect([ bytes.next ].pack('C')).to eq('C')
-          expect(Hessian2.parse_string(bytes)).to eq(klass)
-          expect(Hessian2.parse_int(bytes)).to eq(4)
-          4.times{ Hessian2.parse_string(bytes) }
-          expect(bytes.next - 0x60).to eq(0)
-          _monkey = Hessian2.parse(bin)
-          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-        end
-      end
-
-
-      it "should write object instance ('O') ::= 'O' int value*" do
-        arr = []
-        17.times do |i|
-          arr << Hessian2::ClassWrapper.new("com.sun.java.Monkey#{i}", hash)
-        end
-        bin = Hessian2.write(arr)
-
-        bytes = bin.each_byte
-
-        # skip x58 int
-        bytes.next
-        Hessian2.parse_int(bytes)
-
-        # skip top 16
-        16.times do
-          bytes.next
-          Hessian2.parse_string(bytes)
-          Hessian2.parse_int(bytes)
-          4.times{ Hessian2.parse_string(bytes) }
-          bytes.next
-          4.times{ Hessian2.parse_bytes(bytes) }
-        end
-
-        # skip 17th class definition
-        bytes.next
-        Hessian2.parse_string(bytes)
-        Hessian2.parse_int(bytes)
-        4.times{ Hessian2.parse_string(bytes) }
-
-        expect([ bytes.next ].pack('C')).to eq('O')
-        expect(Hessian2.parse_int(bytes)).to eq(16)
-
-        _monkeys = Hessian2.parse(bin)
-        expect(_monkeys.size).to eq(17)
-        _monkeys.each do |_monkey|
-          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
-        end
-      end
-
-      it "should write ActiveRecord::Relation" do
-        val = Monkey.where(true).limit(2)
-        bin = Hessian2.write(val)
-
-        bytes = bin.each_byte
-        expect(bytes.next - 0x78).to eq(val.size)
-
-        born_at = Time.new(1989, 5, 8)
-        Hessian2.parse(bin).each_with_index do |_monkey, i|
-          expect([ _monkey.id, _monkey.name, _monkey.price, _monkey.born_at ]).to eq([ i + 1, "#{i}号猴", 0.25 * i, born_at + 86400 * i ])
-        end
-      end
-
-    end
-  end
-end
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when object" do
+      hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+      it "should write object type definition ('C') ::= 'C' string int string* and object with direct type ::= [x60-x6f] value*" do
+        [ 'Monkey', 'AnotherMonkey' ].each do |klass|
+          bin = Hessian2.write(Kernel.const_get(klass).new(hash))
+
+          bytes = bin.each_byte
+          expect([ bytes.next ].pack('C')).to eq('C')
+          expect(Hessian2.parse_string(bytes)).to eq(klass)
+          expect(Hessian2.parse_int(bytes)).to eq(4)
+          4.times{ Hessian2.parse_string(bytes) }
+          expect(bytes.next - 0x60).to eq(0)
+          _monkey = Hessian2.parse(bin)
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        end
+      end
+
+
+      it "should write object instance ('O') ::= 'O' int value*" do
+        arr = []
+        17.times do |i|
+          arr << Hessian2::ClassWrapper.new("com.sun.java.Monkey#{i}", hash)
+        end
+        bin = Hessian2.write(arr)
+
+        bytes = bin.each_byte
+
+        # skip x58 int
+        bytes.next
+        Hessian2.parse_int(bytes)
+
+        # skip top 16
+        16.times do
+          bytes.next
+          Hessian2.parse_string(bytes)
+          Hessian2.parse_int(bytes)
+          4.times{ Hessian2.parse_string(bytes) }
+          bytes.next
+          4.times{ Hessian2.parse_bytes(bytes) }
+        end
+
+        # skip 17th class definition
+        bytes.next
+        Hessian2.parse_string(bytes)
+        Hessian2.parse_int(bytes)
+        4.times{ Hessian2.parse_string(bytes) }
+
+        expect([ bytes.next ].pack('C')).to eq('O')
+        expect(Hessian2.parse_int(bytes)).to eq(16)
+
+        _monkeys = Hessian2.parse(bin)
+        expect(_monkeys.size).to eq(17)
+        _monkeys.each do |_monkey|
+          expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+        end
+      end
+
+      it "should write ActiveRecord::Relation" do
+        val = Monkey.where(true).limit(2)
+        bin = Hessian2.write(val)
+
+        bytes = bin.each_byte
+        expect(bytes.next - 0x78).to eq(val.size)
+
+        born_at = Time.new(1989, 5, 8)
+        Hessian2.parse(bin).each_with_index do |_monkey, i|
+          expect([ _monkey.id, _monkey.name, _monkey.price, _monkey.born_at ]).to eq([ i + 1, "#{i}号猴", 0.25 * i, born_at + 86400 * i ])
+        end
+      end
+
+    end
+  end
+end