msgpack 0.5.10-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d07eeab3d2c7fc9c0d225855561ccc9ad55cb7cb
+  data.tar.gz: 4e6a1646d60d10aa49a5cc65d190dac4ef5de39e
+SHA512:
+  metadata.gz: 53ee1f839a89bd60d9f3b80d053391973e5729cf106b5e3ef62cb53c954c62964bf62a6f76ca3754a152e1e025edcc81465742b7859fc342636a40353068895f
+  data.tar.gz: d997c52d92fa6e744e567d0a17f52c24f4b6804963308b1bb0a96fdfba4b0c8b71708b814ab0df584de194e058599acab591e3a6c6517511134721f4f2b921c9

data/lib/msgpack.rb

@@ -0,0 +1,13 @@
+require "msgpack/version"
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby" # This is same with `/java/ =~ RUBY_VERSION`
+  require "java"
+  require "msgpack/msgpack.jar"
+  org.msgpack.jruby.MessagePackLibrary.new.load(JRuby.runtime, false)
+else
+  begin
+    require "msgpack/#{RUBY_VERSION[/\d+.\d+/]}/msgpack"
+  rescue LoadError
+    require "msgpack/msgpack"
+  end
+end

data/lib/msgpack/version.rb

@@ -0,0 +1,3 @@
+module MessagePack
+	VERSION = "0.5.10"
+end

data/spec/cases.json

@@ -0,0 +1 @@
+[false,true,null,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,127,127,255,65535,4294967295,-32,-32,-128,-32768,-2147483648,0.0,-0.0,1.0,-1.0,"a","a","a","","","",[0],[0],[0],[],[],[],{},{},{},{"a":97},{"a":97},{"a":97},[[]],[["a"]]]

data/spec/cases_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'json'
+
+describe MessagePack do
+  here = File.dirname(__FILE__)
+  CASES         = File.read("#{here}/cases.msg")
+  CASES_JSON    = File.read("#{here}/cases.json")
+  CASES_COMPACT = File.read("#{here}/cases_compact.msg")
+
+  it 'compare with json' do
+    ms = []
+    MessagePack::Unpacker.new.feed_each(CASES) {|m|
+      ms << m
+    }
+
+    js = JSON.load(CASES_JSON)
+
+    ms.zip(js) {|m,j|
+      m.should == j
+    }
+  end
+
+  it 'compare with compat' do
+    ms = []
+    MessagePack::Unpacker.new.feed_each(CASES) {|m|
+      ms << m
+    }
+
+    cs = []
+    MessagePack::Unpacker.new.feed_each(CASES_COMPACT) {|c|
+      cs << c
+    }
+
+    ms.zip(cs) {|m,c|
+      m.should == c
+    }
+  end
+end
+

data/spec/cruby/buffer_io_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+require 'random_compat'
+
+require 'stringio'
+if defined?(Encoding)
+  Encoding.default_external = 'ASCII-8BIT'
+end
+
+describe Buffer do
+  r = Random.new
+  random_seed = r.seed
+  puts "buffer_io random seed: 0x#{random_seed.to_s(16)}"
+
+  let :source do
+    ''
+  end
+
+  def set_source(s)
+    source.replace(s)
+  end
+
+  let :io do
+    StringIO.new(source.dup)
+  end
+
+  let :buffer do
+    Buffer.new(io)
+  end
+
+  it 'io returns internal io' do
+    buffer.io.should == io
+  end
+
+  it 'close closes internal io' do
+    io.should_receive(:close)
+    buffer.close
+  end
+
+  it 'short feed and read all' do
+    set_source 'aa'
+    buffer.read.should == 'aa'
+  end
+
+  it 'short feed and read short' do
+    set_source 'aa'
+    buffer.read(1).should == 'a'
+    buffer.read(1).should == 'a'
+    buffer.read(1).should == nil
+  end
+
+  it 'long feed and read all' do
+    set_source ' '*(1024*1024)
+    s = buffer.read
+    s.size.should == source.size
+    s.should == source
+  end
+
+  it 'long feed and read mixed' do
+    set_source ' '*(1024*1024)
+    buffer.read(10).should == source.slice!(0, 10)
+    buffer.read(10).should == source.slice!(0, 10)
+    buffer.read(10).should == source.slice!(0, 10)
+    s = buffer.read
+    s.size.should == source.size
+    s.should == source
+  end
+
+  it 'eof' do
+    set_source ''
+    buffer.read.should == ''
+  end
+
+  it 'eof 2' do
+    set_source 'a'
+    buffer.read.should == 'a'
+    buffer.read.should == ''
+  end
+
+  it 'write short once and flush' do
+    buffer.write('aa')
+    buffer.flush
+    io.string.should == 'aa'
+  end
+
+  it 'write short twice and flush' do
+    buffer.write('a')
+    buffer.write('a')
+    buffer.flush
+    io.string.should == 'aa'
+  end
+
+  it 'write long once and flush' do
+    s = ' '*(1024*1024)
+    buffer.write s
+    buffer.flush
+    io.string.size.should == s.size
+    io.string.should == s
+  end
+
+  it 'write short multi and flush' do
+    s = ' '*(1024*1024)
+    1024.times {
+      buffer.write ' '*1024
+    }
+    buffer.flush
+    io.string.size.should == s.size
+    io.string.should == s
+  end
+
+  it 'random read' do
+    r = Random.new(random_seed)
+
+    50.times {
+      fragments = []
+
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        s = r.bytes(n)
+        fragments << s
+      end
+
+      io = StringIO.new(fragments.join)
+      b = Buffer.new(io)
+
+      fragments.each {|s|
+        x = b.read(s.size)
+        x.size.should == s.size
+        x.should == s
+      }
+      b.empty?.should == true
+      b.read.should == ''
+    }
+  end
+
+  it 'random read_all' do
+    r = Random.new(random_seed)
+
+    50.times {
+      fragments = []
+      sx = r.bytes(0)
+
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        s = r.bytes(n)
+        fragments << s
+      end
+
+      io = StringIO.new(fragments.join)
+      b = Buffer.new(io)
+
+      fragments.each {|s|
+        x = b.read_all(s.size)
+        x.size.should == s.size
+        x.should == s
+      }
+      b.empty?.should == true
+      lambda {
+        b.read_all(1)
+      }.should raise_error(EOFError)
+    }
+  end
+
+  it 'random skip' do
+    r = Random.new(random_seed)
+
+    50.times {
+      fragments = []
+
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        s = r.bytes(n)
+        fragments << s
+      end
+
+      io = StringIO.new(fragments.join)
+      b = Buffer.new(io)
+
+      fragments.each {|s|
+        b.skip(s.size).should == s.size
+      }
+      b.empty?.should == true
+      b.skip(1).should == 0
+    }
+  end
+
+  it 'random skip_all' do
+    r = Random.new(random_seed)
+
+    50.times {
+      fragments = []
+
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        s = r.bytes(n)
+        fragments << s
+      end
+
+      io = StringIO.new(fragments.join)
+      b = Buffer.new(io)
+
+      fragments.each {|s|
+        lambda {
+          b.skip_all(s.size)
+        }.should_not raise_error
+      }
+      b.empty?.should == true
+      lambda {
+        b.skip_all(1)
+      }.should raise_error(EOFError)
+    }
+  end
+
+  it 'random write and flush' do
+    r = Random.new(random_seed)
+
+    50.times {
+      s = r.bytes(0)
+      io = StringIO.new
+      b = Buffer.new(io)
+
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b.write(x)
+      end
+
+      (io.string.size + b.size).should == s.size
+
+      b.flush
+
+      io.string.size.should == s.size
+      io.string.should == s
+    }
+  end
+
+  it 'random write and clear' do
+    r = Random.new(random_seed)
+    b = Buffer.new
+
+    50.times {
+      s = r.bytes(0)
+
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b.write(x)
+      end
+
+      b.size.should == s.size
+      b.clear
+    }
+  end
+end
+

data/spec/cruby/buffer_packer.rb

@@ -0,0 +1,29 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+require 'stringio'
+if defined?(Encoding)
+  Encoding.default_external = 'ASCII-8BIT'
+end
+
+describe Packer do
+  let :packer do
+    Packer.new
+  end
+
+  it 'initialize' do
+    Packer.new
+    Packer.new(nil)
+    Packer.new(StringIO.new)
+    Packer.new({})
+    Packer.new(StringIO.new, {})
+  end
+
+  it 'buffer' do
+    o1 = packer.buffer.object_id
+    packer.buffer << 'frsyuki'
+    packer.buffer.to_s.should == 'frsyuki'
+    packer.buffer.object_id.should == o1
+  end
+end
+

data/spec/cruby/buffer_spec.rb

@@ -0,0 +1,572 @@
+require 'spec_helper'
+require 'random_compat'
+
+describe Buffer do
+  STATIC_EXAMPLES = {}
+  STATIC_EXAMPLES[:empty01] = ''
+  STATIC_EXAMPLES[:empty02] = ''
+  STATIC_EXAMPLES[:copy01] = 'short'
+  STATIC_EXAMPLES[:copy02] = 'short'*2
+  STATIC_EXAMPLES[:ref01] = 'short'*128
+  STATIC_EXAMPLES[:ref02] = 'short'*128*2
+  STATIC_EXAMPLES[:ref03] = 'a'*((1024*1024+2)*2)
+  STATIC_EXAMPLES[:refcopy01] = 'short'*128
+  STATIC_EXAMPLES[:expand01] = 'short'*1024
+  STATIC_EXAMPLES[:expand02] = 'short'*(127+1024)
+  STATIC_EXAMPLES[:offset01] = 'ort'+'short'
+  STATIC_EXAMPLES[:offset02] = 'ort'+'short'*127
+  STATIC_EXAMPLES[:offset03] = 'ort'+'short'*(126+1024)
+
+  if ''.respond_to?(:force_encoding)
+    STATIC_EXAMPLES.each_value {|v| v.force_encoding('ASCII-8BIT') }
+  end
+  STATIC_EXAMPLES.each_value {|v| v.freeze }
+
+  r = Random.new
+  random_seed = r.seed
+  puts "buffer random seed: 0x#{random_seed.to_s(16)}"
+
+  let :random_cases_examples do
+    r = Random.new(random_seed)
+    cases = {}
+    examples = {}
+
+    10.times do |i|
+      b = Buffer.new
+      s = r.bytes(0)
+      r.rand(3).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b << x
+      end
+      r.rand(2).times do
+        n = r.rand(1024*1400)
+        b.read(n)
+        s.slice!(0, n)
+      end
+      key = :"random#{"%02d"%i}"
+      cases[key] = b
+      examples[key] = s
+    end
+
+    [cases, examples]
+  end
+
+  let :static_cases do
+    map = {}
+    map[:empty01] = empty01
+    map[:empty02] = empty02
+    map[:copy01] = copy01
+    map[:copy02] = copy02
+    map[:ref01] = ref01
+    map[:ref02] = ref02
+    map[:ref03] = ref03
+    map[:refcopy01] = refcopy01
+    map[:expand01] = expand01
+    map[:expand02] = expand02
+    map[:offset01] = offset01
+    map[:offset02] = offset02
+    map[:offset03] = offset03
+    map
+  end
+
+  let :static_examples do
+    STATIC_EXAMPLES
+  end
+
+  let :random_cases do
+    random_cases_examples[0]
+  end
+
+  let :random_examples do
+    random_cases_examples[1]
+  end
+
+  let :cases do
+    static_cases.merge(random_cases)
+  end
+
+  let :examples do
+    static_examples.merge(random_examples)
+  end
+
+  let :case_keys do
+    examples.keys
+  end
+
+  let :empty01 do
+    Buffer.new
+  end
+
+  let :empty02 do
+    b = Buffer.new
+    b << 'a'
+    b.read_all(1)
+    b
+  end
+
+  let :copy01 do
+    # one copy chunk
+    b = Buffer.new
+    b << 'short'
+    b
+  end
+
+  let :copy02 do
+    # one copy chunk
+    b = Buffer.new
+    b << 'short'
+    b << 'short'
+    b
+  end
+
+  let :expand02 do
+    # one copy chunk / expanded
+    b = Buffer.new
+    1024.times do
+      b << 'short'
+    end
+    b
+  end
+
+  let :ref01 do
+    # one reference chunk
+    b = Buffer.new
+    b << 'short'*128
+    b.to_s
+    b
+  end
+
+  let :ref02 do
+    # two reference chunks
+    b = Buffer.new
+    b << 'short'*128
+    b.to_s
+    b << 'short'*128
+    b.to_a
+    b
+  end
+
+  let :ref03 do
+    # two reference chunks
+    b = Buffer.new
+    b << 'a'*(1024*1024+2)
+    b << 'a'*(1024*1024+2)
+    b
+  end
+
+  let :refcopy01 do
+    # one reference chunk + one copy chunk
+    b = Buffer.new
+    b << 'short'*127
+    b.to_s
+    b << 'short'
+    b
+  end
+
+  let :expand01 do
+    # one copy chunk / expanded
+    b = Buffer.new
+    1024.times do
+      b << 'short'
+    end
+    b
+  end
+
+  let :expand02 do
+    # one reference chunk + one copy chunk / expanded
+    b = Buffer.new
+    b << 'short'*127
+    b.to_s
+    1024.times do
+      b << 'short'
+    end
+    b
+  end
+
+  let :offset01 do
+    # one copy chunk / offset
+    b = Buffer.new
+    b << 'short'
+    b << 'short'
+    b.skip(2)
+    b
+  end
+
+  let :offset02 do
+    # one reference chunk / offset
+    b = Buffer.new
+    b << 'short'*127
+    b.to_s
+    b.skip(2)
+    b << 'short'
+    b
+  end
+
+  let :offset03 do
+    # one reference chunk / offset + one copy chunk / expanded
+    b = Buffer.new
+    b << 'short'*127
+    b.to_s
+    1024.times do
+      b << 'short'
+    end
+    b.skip(2)
+    b
+  end
+
+  it 'empty?' do
+    empty01.empty?.should == true
+    empty02.empty?.should == true
+  end
+
+  it 'size' do
+    case_keys.each {|k|
+      cases[k].size.should == examples[k].size
+    }
+  end
+
+  it 'short write increments size' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      10.times do |i|
+        cases[k].write 'short'
+        sz += 'short'.size
+        cases[k].size.should == sz
+      end
+    }
+  end
+
+  it 'read with limit decrements size' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      next if sz < 2
+
+      cases[k].read(1).should == examples[k][0,1]
+      sz -= 1
+      cases[k].size.should == sz
+
+      cases[k].read(1).should == examples[k][1,1]
+      sz -= 1
+      cases[k].size.should == sz
+    }
+  end
+
+  it 'read_all with limit decrements size' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      next if sz < 2
+
+      cases[k].read_all(1).should == examples[k][0,1]
+      sz -= 1
+      cases[k].size.should == sz
+
+      cases[k].read_all(1).should == examples[k][1,1]
+      sz -= 1
+      cases[k].size.should == sz
+    }
+  end
+
+  it 'skip decrements size' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      next if sz < 2
+
+      cases[k].skip(1).should == 1
+      sz -= 1
+      cases[k].size.should == sz
+
+      cases[k].skip(1).should == 1
+      sz -= 1
+      cases[k].size.should == sz
+    }
+  end
+
+  it 'skip_all decrements size' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      next if sz < 2
+
+      cases[k].skip_all(1)
+      sz -= 1
+      cases[k].size.should == sz
+
+      cases[k].skip_all(1)
+      sz -= 1
+      cases[k].size.should == sz
+    }
+  end
+
+  it 'read_all against insufficient buffer raises EOFError and consumes nothing' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      lambda {
+        cases[k].read_all(sz+1)
+      }.should raise_error(EOFError)
+      cases[k].size.should == sz
+    }
+  end
+
+  it 'skip_all against insufficient buffer raises EOFError and consumes nothing' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      lambda {
+        cases[k].skip_all(sz+1)
+      }.should raise_error(EOFError)
+      cases[k].size.should == sz
+    }
+  end
+
+  it 'read against insufficient buffer consumes all buffer or return nil' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      if sz == 0
+        cases[k].read(sz+1).should == nil
+      else
+        cases[k].read(sz+1).should == examples[k]
+      end
+      cases[k].size.should == 0
+    }
+  end
+
+  it 'skip against insufficient buffer consumes all buffer' do
+    case_keys.each {|k|
+      sz = examples[k].size
+      cases[k].skip(sz+1).should == examples[k].size
+      cases[k].size.should == 0
+    }
+  end
+
+  it 'read with no arguments consumes all buffer and returns string and do not return nil' do
+    case_keys.each {|k|
+      cases[k].read_all.should == examples[k]
+      cases[k].size.should == 0
+    }
+  end
+
+  it 'read_all with no arguments consumes all buffer and returns string' do
+    case_keys.each {|k|
+      cases[k].read_all.should == examples[k]
+      cases[k].size.should == 0
+    }
+  end
+
+  it 'to_s returns a string and consume nothing' do
+    case_keys.each {|k|
+      cases[k].to_s.should == examples[k]
+      cases[k].size.should == examples[k].size
+    }
+  end
+
+  it 'to_s and modify' do
+    case_keys.each {|k|
+      s = cases[k].to_s
+      s << 'x'
+      cases[k].to_s.should == examples[k]
+    }
+  end
+
+  it 'big write and modify reference' do
+    big2 = "a" * (1024*1024 + 2)
+
+    case_keys.each {|k|
+      big1 = "a" * (1024*1024 + 2)
+      cases[k].write(big1)
+      big1 << 'x'
+      cases[k].read.should == examples[k] + big2
+    }
+  end
+
+  it 'big write -> short write' do
+    biglen = 1024*1024 + 2
+    big1 = "a" * (1024*1024 + 2)
+
+    case_keys.each {|k|
+      sz = examples[k].size
+
+      cases[k].write big1
+      cases[k].size.should == sz + big1.size
+
+      cases[k].write("c")
+      cases[k].size.should == sz + big1.size + 1
+
+      cases[k].read_all.should == examples[k] + big1 + "c"
+      cases[k].size.should == 0
+      cases[k].empty?.should == true
+    }
+  end
+
+  it 'big write 2'do
+    big1 = "a" * (1024*1024 + 2)
+    big2 = "b" * (1024*1024 + 2)
+
+    case_keys.each {|k|
+      sz = examples[k].size
+
+      cases[k].write big1
+      cases[k].write big2
+      cases[k].size.should == sz + big1.size + big2.size
+
+      cases[k].read_all(sz + big1.size).should == examples[k] + big1
+      cases[k].size.should == big2.size
+
+      cases[k].read.should == big2
+      cases[k].size.should == 0
+      cases[k].empty?.should == true
+    }
+  end
+
+  it 'read 0' do
+    case_keys.each {|k|
+      cases[k].read(0).should == ''
+      cases[k].read.should == examples[k]
+    }
+  end
+
+  it 'skip 0' do
+    case_keys.each {|k|
+      cases[k].skip(0).should == 0
+      cases[k].read.should == examples[k]
+    }
+  end
+
+  it 'read_all 0' do
+    case_keys.each {|k|
+      cases[k].read_all(0).should == ''
+      cases[k].read_all.should == examples[k]
+    }
+  end
+
+  it 'skip_all 0' do
+    case_keys.each {|k|
+      cases[k].skip_all(0)
+      cases[k].read_all.should == examples[k]
+    }
+  end
+
+  it 'write_to' do
+    case_keys.each {|k|
+      sio = StringIO.new
+      cases[k].write_to(sio).should == examples[k].size
+      cases[k].size.should == 0
+      sio.string.should == examples[k]
+    }
+  end
+
+  it 'random read/write' do
+    r = Random.new(random_seed)
+    s = r.bytes(0)
+    b = Buffer.new
+
+    10.times {
+      # write
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b.write(x)
+      end
+
+      # read
+      r.rand(3).times do
+        n = r.rand(1024*1400)
+        ex = s.slice!(0, n)
+        ex = nil if ex.empty?
+        x = b.read(n)
+        x.size == ex.size if x != nil
+        x.should == ex
+        b.size.should == s.size
+      end
+    }
+  end
+
+  it 'random read_all/write' do
+    r = Random.new(random_seed)
+    s = r.bytes(0)
+    b = Buffer.new
+
+    10.times {
+      # write
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b.write(x)
+      end
+
+      # read_all
+      r.rand(3).times do
+        n = r.rand(1024*1400)
+        begin
+          x = b.read_all(n)
+          ex = s.slice!(0, n)
+          x.size == n
+          x.should == ex
+          b.size.should == s.size
+        rescue EOFError
+          b.size.should == s.size
+          b.read.should == s
+          s.clear
+          break
+        end
+      end
+    }
+  end
+
+  it 'random skip write' do
+    r = Random.new(random_seed)
+    s = r.bytes(0)
+    b = Buffer.new
+
+    10.times {
+      # write
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b.write(x)
+      end
+
+      # skip
+      r.rand(3).times do
+        n = r.rand(1024*1400)
+        ex = s.slice!(0, n)
+        b.skip(n).should == ex.size
+        b.size.should == s.size
+      end
+    }
+  end
+
+  it 'random skip_all write' do
+    r = Random.new(random_seed)
+    s = r.bytes(0)
+    b = Buffer.new
+
+    10.times {
+      # write
+      r.rand(4).times do
+        n = r.rand(1024*1400)
+        x = r.bytes(n)
+        s << x
+        b.write(x)
+      end
+
+      # skip_all
+      r.rand(3).times do
+        n = r.rand(1024*1400)
+        begin
+          b.skip_all(n)
+          ex = s.slice!(0, n)
+          b.size.should == s.size
+        ensure EOFError
+          b.size.should == s.size
+          b.read.should == s
+          s.clear
+          break
+        end
+      end
+    }
+  end
+end
+