hx_cbor 2021.8.20

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 == "\x80"
+  end
+
+  it 'write_nil' do
+    packer.write_nil
+    packer.to_s.should == "\xf6"
+  end
+
+  it 'write_array_header 0' do
+    packer.write_array_header(0)
+    packer.to_s.should == "\x80"
+  end
+
+  it 'write_array_header 1' do
+    packer.write_array_header(1)
+    packer.to_s.should == "\x81"
+  end
+
+  it 'write_map_header 0' do
+    packer.write_map_header(0)
+    packer.to_s.should == "\xa0"
+  end
+
+  it 'write_map_header 1' do
+    packer.write_map_header(1)
+    packer.to_s.should == "\xa1"
+  end
+
+  it 'flush' do
+    io = StringIO.new
+    pk = Packer.new(io)
+    pk.write_nil
+    pk.flush
+    pk.to_s.should == ''
+    io.string.should == "\xf6"
+  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_cbor returns String' do
+    nil.to_cbor.class.should == String
+    true.to_cbor.class.should == String
+    false.to_cbor.class.should == String
+    1.to_cbor.class.should == String
+    1.0.to_cbor.class.should == String
+    "".to_cbor.class.should == String
+    Hash.new.to_cbor.class.should == String
+    Array.new.to_cbor.class.should == String
+  end
+
+  class CustomPack01
+    def to_cbor(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_cbor(pk=nil)
+      [1,2].to_cbor(pk)
+    end
+  end
+
+  it 'calls custom to_cbor method' do
+    MessagePack.pack(CustomPack01.new).should == [1,2].to_cbor
+    MessagePack.pack(CustomPack02.new).should == [1,2].to_cbor
+    CustomPack01.new.to_cbor.should == [1,2].to_cbor
+    CustomPack02.new.to_cbor.should == [1,2].to_cbor
+  end
+
+  it 'calls custom to_cbor method with io' do
+    s01 = StringIO.new
+    MessagePack.pack(CustomPack01.new, s01)
+    s01.string.should == [1,2].to_cbor
+
+    s02 = StringIO.new
+    MessagePack.pack(CustomPack02.new, s02)
+    s02.string.should == [1,2].to_cbor
+
+    s03 = StringIO.new
+    CustomPack01.new.to_cbor(s03)
+    s03.string.should == [1,2].to_cbor
+
+    s04 = StringIO.new
+    CustomPack02.new.to_cbor(s04)
+    s04.string.should == [1,2].to_cbor
+  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,68 @@
+require 'rubygems'              # for 1.8
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end
+
+
+class String
+  if ''.respond_to? :encode
+    def encode_as_utf8
+      encode(Encoding::UTF_8)
+    end
+    def force_as_utf8
+      force_encoding(Encoding::UTF_8)
+    end
+    unless String.instance_methods.include?(:b)
+      def b
+        dup.force_encoding(Encoding::BINARY)
+      end
+    end
+  else
+    def encode_as_utf8
+      self                      # MRI 1.8
+    end
+    def force_as_utf8
+      self                      # MRI 1.8
+    end
+    def b
+      self
+    end
+  end
+  unless ''.respond_to? :clear
+    def clear
+      replace('')
+    end
+  end
+  def hexbytes(sep = '')
+    bytes.map{|x| "%02x" % x}.join(sep)
+  end
+end
+
+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 'cbor'
+
+MessagePack = CBOR              # XXX
+
+Packer = MessagePack::Packer
+Unpacker = MessagePack::Unpacker
+Buffer = MessagePack::Buffer
+

data/spec/unpacker_spec.rb

@@ -0,0 +1,260 @@
+# encoding: ascii-8bit
+require 'spec_helper'
+
+describe Unpacker do
+  let :unpacker do
+    Unpacker.new
+  end
+
+  let :packer do
+    Packer.new
+  end
+
+  # TODO initialize
+
+  it 'read_array_header succeeds' do
+    unpacker.feed("\x81")
+    unpacker.read_array_header.should == 1
+  end
+
+  it 'read_array_header fails' do
+    unpacker.feed("\xa1")
+    lambda {
+      unpacker.read_array_header
+    }.should raise_error(MessagePack::TypeError)
+  end
+
+  it 'read_array_header converts an array to value sequence' do
+    packer.write_array_header(2)
+    packer.write("e")
+    packer.write(1)
+    unpacker = Unpacker.new
+    unpacker.feed(packer.to_s)
+    unpacker.read_array_header.should == 2
+    unpacker.read.should == "e"
+    unpacker.read.should == 1
+  end
+
+  it 'read_map_header succeeds' do
+    unpacker.feed("\xa1")
+    unpacker.read_map_header.should == 1
+  end
+
+  it 'read_map_header converts an map to key-value sequence' do
+    packer.write_map_header(1)
+    packer.write("k")
+    packer.write("v")
+    unpacker = Unpacker.new
+    unpacker.feed(packer.to_s)
+    unpacker.read_map_header.should == 1
+    unpacker.read.should == "k"
+    unpacker.read.should == "v"
+  end
+
+  it 'read_map_header fails' do
+    unpacker.feed("\x81")
+    lambda {
+      unpacker.read_map_header
+    }.should raise_error(MessagePack::TypeError)
+  end
+
+  it 'skip_nil succeeds' do
+    unpacker.feed("\xf6")
+    unpacker.skip_nil.should == true
+  end
+
+  it 'skip_nil fails' do
+    unpacker.feed("\x80")
+    unpacker.skip_nil.should == false
+  end
+
+  it 'skip skips objects' do
+    packer.write(1)
+    packer.write(2)
+    packer.write(3)
+    packer.write(4)
+    packer.write(5)
+
+    unpacker = Unpacker.new(packer.buffer)
+
+    unpacker.read.should == 1
+    unpacker.skip
+    unpacker.read.should == 3
+    unpacker.skip
+    unpacker.read.should == 5
+  end
+
+  it 'read raises EOFError' do
+    lambda {
+      unpacker.read
+    }.should raise_error(EOFError)
+  end
+
+  it 'skip raises EOFError' do
+    lambda {
+      unpacker.skip
+    }.should raise_error(EOFError)
+  end
+
+  it 'skip_nil raises EOFError' do
+    lambda {
+      unpacker.skip_nil
+    }.should raise_error(EOFError)
+  end
+
+  let :sample_object do
+    [1024, {["a","b"]=>["c","d"]}, ["e","f"], "d", 70000, 4.12, 1.5, 1.5, 1.5]
+  end
+
+  it 'sample object OK' do
+    obj2 = MessagePack.unpack(sample_object.to_cbor)
+    obj2.should == sample_object
+  end
+
+  it 'feed and each continue internal state' do
+    raw = sample_object.to_cbor.to_s * 4
+    objects = []
+
+    raw.split(//).each do |b|
+      unpacker.feed(b)
+      unpacker.each {|c|
+        objects << c
+      }
+    end
+
+    objects.should == [sample_object] * 4
+  end
+
+  it 'feed_each continues internal state' do
+    raw = sample_object.to_cbor.to_s * 4
+    objects = []
+
+    raw.split(//).each do |b|
+      unpacker.feed_each(b) {|c|
+        objects << c
+      }
+    end
+
+    objects.should == [sample_object] * 4
+  end
+
+  it 'reset clears internal buffer' do
+    # 1-element array
+    unpacker.feed("\x91")
+    unpacker.reset
+    unpacker.feed("\x01")
+
+    unpacker.each.map {|x| x }.should == [1]
+  end
+
+  it 'reset clears internal state' do
+    # 1-element array
+    unpacker.feed("\x91")
+    unpacker.each.map {|x| x }.should == []
+
+    unpacker.reset
+
+    unpacker.feed("\x01")
+    unpacker.each.map {|x| x }.should == [1]
+  end
+
+  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 'frozen short strings' do
+    raw = sample_object.to_cbor.to_s.force_as_utf8
+    lambda {
+      unpacker.feed_each(raw.freeze) { }
+    }.should_not raise_error
+  end
+
+  it 'frozen long strings' do
+    raw = (sample_object.to_cbor.to_s * 10240).force_as_utf8
+    lambda {
+      unpacker.feed_each(raw.freeze) { }
+    }.should_not raise_error
+  end
+
+  it 'read raises level stack too deep error' do
+    512.times { packer.write_array_header(1) }
+    packer.write(nil)
+
+    unpacker = Unpacker.new(packer.buffer)
+    lambda {
+      unpacker.read
+    }.should raise_error(MessagePack::StackError)
+  end
+
+  it 'skip raises level stack too deep error' do
+    512.times { packer.write_array_header(1) }
+    packer.write(nil)
+
+    unpacker = Unpacker.new(packer.buffer)
+    lambda {
+      unpacker.skip
+    }.should raise_error(MessagePack::StackError)
+  end
+
+  it 'read raises invalid byte error' do
+    unpacker.feed("\xdf")
+    lambda {
+      unpacker.read
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it 'skip raises invalid byte error' do
+    unpacker.feed("\xdf")
+    lambda {
+      unpacker.skip
+    }.should raise_error(MessagePack::MalformedFormatError)
+  end
+
+  it "gc mark" do
+    raw = sample_object.to_cbor.to_s * 4
+
+    n = 0
+    raw.split(//).each do |b|
+      GC.start
+      unpacker.feed_each(b) {|o|
+        GC.start
+        o.should == sample_object
+        n += 1
+      }
+      GC.start
+    end
+
+    n.should == 4
+  end
+
+  it "buffer" do
+    orig = "a"*32*1024*4
+    raw = orig.to_cbor.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
+