msgpack 0.4.7-x86-mingw32 → 0.5.0-x86-mingw32

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/format_spec.rb

@@ -0,0 +1,225 @@
+# 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 16" do
+    check_raw 3, (1<<5)
+    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 "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
+  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
+end
+

data/spec/packer_spec.rb

@@ -0,0 +1,127 @@
+# 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 'Packer' do
+  #  Packer(packer).object_id.should == packer.object_id
+  #  Packer(nil).class.should == Packer
+  #  Packer('').class.should == Packer
+  #  Packer('initbuf').to_s.should == 'initbuf'
+  #end
+
+  it 'write' do
+    packer.write([])
+    packer.to_s.should == "\x90"
+  end
+
+  it 'write_nil' do
+    packer.write_nil
+    packer.to_s.should == "\xc0"
+  end
+
+  it 'write_array_header 0' do
+    packer.write_array_header(0)
+    packer.to_s.should == "\x90"
+  end
+
+  it 'write_array_header 1' do
+    packer.write_array_header(1)
+    packer.to_s.should == "\x91"
+  end
+
+  it 'write_map_header 0' do
+    packer.write_map_header(0)
+    packer.to_s.should == "\x80"
+  end
+
+  it 'write_map_header 1' do
+    packer.write_map_header(1)
+    packer.to_s.should == "\x81"
+  end
+
+  it 'flush' do
+    io = StringIO.new
+    pk = Packer.new(io)
+    pk.write_nil
+    pk.flush
+    pk.to_s.should == ''
+    io.string.should == "\xc0"
+  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
+
+  it 'to_msgpack returns String' do
+    nil.to_msgpack.class.should == String
+    true.to_msgpack.class.should == String
+    false.to_msgpack.class.should == String
+    1.to_msgpack.class.should == String
+    1.0.to_msgpack.class.should == String
+    "".to_msgpack.class.should == String
+    Hash.new.to_msgpack.class.should == String
+    Array.new.to_msgpack.class.should == String
+  end
+
+  class CustomPack01
+    def to_msgpack(pk=nil)
+      return MessagePack.pack(self, pk) unless pk.class == MessagePack::Packer
+      pk.write_array_header(2)
+      pk.write(1)
+      pk.write(2)
+      return pk
+    end
+  end
+
+  class CustomPack02
+    def to_msgpack(pk=nil)
+      [1,2].to_msgpack(pk)
+    end
+  end
+
+  it 'calls custom to_msgpack method' do
+    MessagePack.pack(CustomPack01.new).should == [1,2].to_msgpack
+    MessagePack.pack(CustomPack02.new).should == [1,2].to_msgpack
+    CustomPack01.new.to_msgpack.should == [1,2].to_msgpack
+    CustomPack02.new.to_msgpack.should == [1,2].to_msgpack
+  end
+
+  it 'calls custom to_msgpack method with io' do
+    s01 = StringIO.new
+    MessagePack.pack(CustomPack01.new, s01)
+    s01.string.should == [1,2].to_msgpack
+
+    s02 = StringIO.new
+    MessagePack.pack(CustomPack02.new, s02)
+    s02.string.should == [1,2].to_msgpack
+
+    s03 = StringIO.new
+    CustomPack01.new.to_msgpack(s03)
+    s03.string.should == [1,2].to_msgpack
+
+    s04 = StringIO.new
+    CustomPack02.new.to_msgpack(s04)
+    s04.string.should == [1,2].to_msgpack
+  end
+end
+

data/spec/random_compat.rb

@@ -0,0 +1,24 @@
+
+unless defined? Random
+  class Random
+    def initialize(seed=Time.now.to_i)
+      Kernel.srand(seed)
+      @seed = seed
+    end
+
+    attr_reader :seed
+
+    def rand(arg)
+      Kernel.rand(arg)
+    end
+
+    def bytes(n)
+      array = []
+      n.times do
+        array << rand(256)
+      end
+      array.pack('C*')
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+
+if ENV['SIMPLE_COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter 'spec/'
+    add_filter 'pkg/'
+    add_filter 'vendor/'
+  end
+end
+
+if ENV['GC_STRESS']
+  puts "enable GC.stress"
+  GC.stress = true
+end
+
+require 'msgpack'
+
+Packer = MessagePack::Packer
+Unpacker = MessagePack::Unpacker
+Buffer = MessagePack::Buffer
+

data/spec/unpacker_spec.rb

@@ -0,0 +1,128 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+describe Unpacker do
+  let :unpacker do
+    Unpacker.new
+  end
+
+  # TODO initialize
+
+  it 'read_array_header succeeds' do
+    unpacker.feed("\x91")
+    unpacker.read_array_header.should == 1
+  end
+
+  it 'read_array_header fails' do
+    unpacker.feed("\x81")
+    lambda {
+      unpacker.read_array_header
+    }.should raise_error(MessagePack::TypeError)
+  end
+
+  it 'read_map_header succeeds' do
+    unpacker.feed("\x81")
+    unpacker.read_map_header.should == 1
+  end
+
+  it 'read_map_header fails' do
+    unpacker.feed("\x91")
+    lambda {
+      unpacker.read_map_header
+    }.should raise_error(MessagePack::TypeError)
+  end
+
+  it 'skip_nil succeeds' do
+    unpacker.feed("\xc0")
+    unpacker.skip_nil.should == true
+  end
+
+  it 'skip_nil fails' do
+    unpacker.feed("\x90")
+    unpacker.skip_nil.should == false
+  end
+
+  it 'skip_nil raises EOFError' do
+    lambda {
+      unpacker.skip_nil
+    }.should raise_error(EOFError)
+  end
+
+  # TODO skip methods
+  # TODO feed
+  # TODO each
+  # TODO feed_each
+
+  it 'buffer' do
+    o1 = unpacker.buffer.object_id
+    unpacker.buffer << 'frsyuki'
+    unpacker.buffer.to_s.should == 'frsyuki'
+    unpacker.buffer.object_id.should == o1
+  end
+
+  it 'raises level stack too deep error' do
+    packer = Packer.new
+    512.times do
+      packer.write_array_header(1)
+    end
+    packer.write(nil)
+
+    unpacker = Unpacker.new(packer.buffer)
+    lambda {
+      unpacker.read
+    }.should raise_error(MessagePack::StackError)
+  end
+
+  it 'raises invalid byte error' do
+    unpacker.feed("\xc6")
+    lambda {
+      unpacker.read
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "gc mark" do
+    obj = [1024, {["a","b"]=>["c","d"]}, ["e","f"], "d", 70000, 4.12, 1.5, 1.5, 1.5]
+    raw = obj.to_msgpack.to_s * 4
+
+    n = 0
+    raw.split(//).each do |b|
+      GC.start
+      unpacker.feed_each(b) {|o|
+        GC.start
+        o.should == obj
+        n += 1
+      }
+      GC.start
+    end
+
+    n.should == 4
+  end
+
+  it "buffer" do
+    orig = "a"*32*1024*4
+    raw = orig.to_msgpack.to_s
+
+    n = 655
+    times = raw.size / n
+    times += 1 unless raw.size % n == 0
+
+    off = 0
+    parsed = false
+
+    times.times do
+      parsed.should == false
+
+      seg = raw[off, n]
+      off += seg.length
+
+      unpacker.feed_each(seg) {|obj|
+        parsed.should == false
+        obj.should == orig
+        parsed = true
+      }
+    end
+
+    parsed.should == true
+  end
+end
+