hessian2 1.1.1 → 2.0.1

data/spec/binary_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when binary" do
+      
+      it "should write binary data length 0-15 ::= [x20-x2f] <binary-data>" do
+        (0..15).to_a.each do |len|
+          val = ['b' * len].pack('a*')
+          bin = Hessian2.write(Hessian2::TypeWrapper.new(:bin, val))
+
+          expect(bin[0].unpack('C').first - 0x20).to eq(val.size)
+          expect(bin.size).to eq(1 + val.size)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write binary data length 0-1023 ::= [x34-x37] <binary-data>" do
+        [ 16, 256, 512, 1023 ].each do |len|
+          val = ['b' * len].pack('a*')
+          bin = Hessian2.write(Hessian2::TypeWrapper.new(:bin, val))
+
+          b1, b0 = bin[0, 2].unpack('CC')
+          expect(256 * (b1 - 0x34) + b0).to eq(val.size)
+          expect(bin.size).to eq(2 + val.size)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write 8-bit binary data non-final chunk ('A') ::= x41 b1 b0 <binary-data> and 8-bit binary data final chunk ('B') ::= 'B' b1 b0 <binary-data>" do
+        val = IO.binread(File.expand_path("../Lighthouse.jpg", __FILE__))
+        bin = Hessian2.write(Hessian2::TypeWrapper.new(:bin, val))
+        chunks = val.size / 0x8000
+
+        chunks.times do |c|
+          i = c * 0x8003
+          expect(bin[i]).to eq('A')
+          expect(bin[i + 1, 2].unpack('n').first).to eq(0x8000)
+        end
+
+        i = chunks * 0x8003
+        expect(bin[i]).to eq('B')
+        expect(bin[i + 1, 2].unpack('n').first).to eq(val.size - 0x8000 * chunks)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/boolean_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when boolean" do
+      
+      it "should write true ::= 'T'" do
+        val = true
+        bin = Hessian2.write(val)
+
+        expect(bin).to eq('T')
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+
+      it "should write false ::= 'F'" do
+        val = false
+        bin = Hessian2.write(val)
+
+        expect(bin).to eq('F')
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+    end
+  end
+end

data/spec/class_wrapper_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe ClassWrapper do
+		hash = { id: nil, born_at: Time.new(2009, 5, 8), name: '大鸡', price: 99.99 }
+
+		it "should raise error" do
+			expect(lambda{ Hessian2::ClassWrapper.new('com.sun.java.Monkey') }).to raise_error
+			expect(lambda{ Hessian2::ClassWrapper.new('com.sun.java.Monkey', 59) }).to raise_error
+		end
+
+
+		it "should wrap nil" do
+			bin = Hessian2.write(Hessian2::ClassWrapper.new('com.sun.java.Monkey', nil))
+
+			expect(bin).to eq('N')
+			expect(Hessian2.parse(bin)).to eq(nil)
+		end
+
+
+		it "should wrap hash, monkey, another monkey" do
+			bin = Hessian2.write(Hessian2::ClassWrapper.new('com.sun.java.Monkey', hash))
+			
+			 [ hash, Monkey.new(hash), AnotherMonkey.new(hash) ].each do |val|
+        bin = Hessian2.write(Hessian2::ClassWrapper.new('com.sun.java.Monkey', val))
+
+				bytes = bin.each_byte
+	      expect([ bytes.next ].pack('C')).to eq('C')
+	      expect(Hessian2.parse_string(bytes)).to eq('com.sun.java.Monkey')
+	      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 wrap array" do
+			arr = [nil, hash, Monkey.new(hash), AnotherMonkey.new(hash)]
+			bin = Hessian2.write(Hessian2::ClassWrapper.new('[com.sun.java.Monkey', arr))
+			
+			_monkey1, _monkey2, _monkey3, _monkey4 = Hessian2.parse(bin)
+			expect(_monkey1).to eq(nil)
+			[ _monkey2, _monkey3, _monkey4 ].each do |_monkey|
+				expect([ _monkey.born_at, _monkey.name, _monkey.price ]).to eq([ hash[:born_at], hash[:name], hash[:price] ])
+			end
+			
+		end
+		
+	end
+end

data/spec/create_monkeys.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../spec_helper',  __FILE__)
+
+ActiveRecord::Base.connection.execute("drop table if exists monkeys")
+ActiveRecord::Base.connection.execute("create table monkeys(id integer(11) not null auto_increment, born_at datetime, name varchar(255), price decimal(10, 2), primary key(id)) charset=utf8")
+
+now = Time.new
+1.upto(1000).each do |i|
+  Monkey.create(
+    id: i, 
+    name: "#{i}号猴",
+    price: 0.25 * i, 
+    born_at: now - 3600 * (1000 - i)
+  )
+end

data/spec/date_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when date" do
+      
+      it "should write 32-bit UTC minute date ::= x4b b3 b2 b1 b0" do
+        val = Time.new(2008, 8, 8, 8, 8)
+        bin = Hessian2.write(val)
+
+        expect(bin[0].unpack('C').first).to eq(0x4b)
+        expect(Time.at(bin[1, 4].unpack('l>').first * 60)).to eq(val)
+        expect(Hessian2.parse(bin)).to eq(val)
+      end
+
+
+      it "should write 64-bit UTC millisecond date ::= x4a b7 b6 b5 b4 b3 b2 b1 b0" do
+        val = Time.new(2008, 8, 8, 8, 8, 8)
+        bin = Hessian2.write(val)
+
+        expect(bin[0].unpack('C').first).to eq(0x4a)
+        _val = bin[1, 8].unpack('q>').first
+        expect(Time.at(_val / 1000, _val % 1000 * 1000)).to eq(val)
+        expect(Hessian2.parse(bin)).to eq(val)
+
+        val2 = Time.at(946684800, 123456.789)
+        bin2 = Hessian2.write(val2)
+
+        expect(bin2[0].unpack('C').first).to eq(0x4a)
+        _val2 = bin2[1, 8].unpack('Q>').first
+        expect(Time.at(_val2 / 1000, _val2 % 1000 * 1000)).to eq(Time.at(val2.to_i, val2.usec / 1000 * 1000))
+        expect(Hessian2.parse(bin2)).to eq(Time.at(val2.to_i, val2.usec / 1000 * 1000))
+
+        val3 = Time.at(946684800.2)
+        bin3 = Hessian2.write(val3)
+
+        expect(bin3[0].unpack('C').first).to eq(0x4a)
+        _val3 = bin3[1, 8].unpack('Q>').first
+        expect(Time.at(_val3 / 1000, _val3 % 1000 * 1000)).to eq(Time.at(val3.to_i, val3.usec / 1000 * 1000))
+        expect(Hessian2.parse(bin3)).to eq(Time.at(val3.to_i, val3.usec / 1000 * 1000))
+      end
+
+    end
+  end
+end

data/spec/double_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Hessian2
+  describe Writer do
+    context "when double" do
+
+      it "should write double 0.0 ::= x5b" do
+        bin = Hessian2.write(0.0)
+
+        expect(bin.unpack('C').first).to eq(0x5b)
+        expect(Hessian2.parse(bin)).to eq(0)
+      end
+
+
+      it "should write double 1.0 ::= x5c" do
+        bin = Hessian2.write(1.0)
+
+        expect(bin.unpack('C').first).to eq(0x5c)
+        expect(Hessian2.parse(bin)).to eq(1)
+      end
+
+
+      it "should write double represented as byte (-128.0 to 127.0) ::= x5d b0" do
+        [ -128.0, 127.0 ].each do |val|
+          bin = Hessian2.write(val)
+
+          expect(bin[0].unpack('C').first).to eq(0x5d)
+          expect(bin.bytesize).to eq(2)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write double represented as short (-32768.0 to 327676.0) ::= x5e b1 b0" do
+        [ -32768.0, 32767.0, -129.0, 128.0 ].each do |val|
+          bin = Hessian2.write(val)
+
+          expect(bin[0].unpack('C').first).to eq(0x5e)
+          expect(bin.bytesize).to eq(3)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write double represented as float ::= x5f b3 b2 b1 b0" do
+        [ -123.456, 123.456 ].each do |val|
+          bin = Hessian2.write(val)
+
+          expect(bin[0].unpack('C').first).to eq(0x5f)
+          expect(bin.bytesize).to eq(5)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write 64-bit IEEE encoded double ('D') ::= 'D' b7 b6 b5 b4 b3 b2 b1 b0" do
+        [ 4.9E-324, 1.7976931348623157E308, Float::INFINITY, -Float::INFINITY ].each do |val|
+          bin = Hessian2.write(val)
+          
+          expect(bin[0]).to eq('D')
+          expect(bin.bytesize).to eq(9)
+          expect(Hessian2.parse(bin)).to eq(val)
+        end
+      end
+
+
+      it "should write NAN" do
+        val = Float::NAN
+        bin = Hessian2.write(val)
+          
+        expect(bin[0]).to eq('D')
+        expect(bin.bytesize).to eq(9)
+        expect(Hessian2.parse(bin).nan?).to eq(true)
+      end
+
+    end
+  end
+end

data/spec/int_spec.rb

@@ -0,0 +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

data/spec/list_spec.rb

@@ -0,0 +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

data/spec/long_spec.rb

@@ -0,0 +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