msgpack 0.7.0dev1-x64-mingw32 → 0.7.0-x64-mingw32

data/ext/msgpack/packer_class.c

@@ -109,6 +109,12 @@ VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+static VALUE Packer_compatibility_mode_p(VALUE self)
+{
+    PACKER(self, pk);
+    return pk->compatibility_mode ? Qtrue : Qfalse;
+}
+
 static VALUE Packer_buffer(VALUE self)
 {
     PACKER(self, pk);
@@ -330,6 +336,7 @@ void MessagePack_Packer_module_init(VALUE mMessagePack)
     rb_define_alloc_func(cMessagePack_Packer, MessagePack_Packer_alloc);
 
     rb_define_method(cMessagePack_Packer, "initialize", MessagePack_Packer_initialize, -1);
+    rb_define_method(cMessagePack_Packer, "compatibility_mode?", Packer_compatibility_mode_p, 0);
     rb_define_method(cMessagePack_Packer, "buffer", Packer_buffer, 0);
     rb_define_method(cMessagePack_Packer, "write", Packer_write, 1);
     rb_define_alias(cMessagePack_Packer, "pack", "write");

data/ext/msgpack/packer_ext_registry.c

@@ -77,11 +77,3 @@ VALUE msgpack_packer_ext_registry_put(msgpack_packer_ext_registry_t* pkrg,
 #endif
     return rb_hash_aset(pkrg->hash, ext_class, e);
 }
-
-VALUE msgpack_packer_ext_registry_call(msgpack_packer_ext_registry_t* pkrg,
-        VALUE proc, VALUE ext_value)
-{
-    VALUE string = rb_funcall(proc, s_call, 1, ext_value);
-    StringValue(string);
-    return string;
-}

data/ext/msgpack/packer_ext_registry.h

@@ -95,7 +95,4 @@ static inline VALUE msgpack_packer_ext_registry_lookup(msgpack_packer_ext_regist
     return Qnil;
 }
 
-VALUE msgpack_packer_ext_registry_call(msgpack_packer_ext_registry_t* pkrg,
-        VALUE proc, VALUE ext_value);
-
 #endif

data/ext/msgpack/unpacker_class.c

@@ -116,6 +116,18 @@ VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
     return self;
 }
 
+static VALUE Unpacker_symbolized_keys_p(VALUE self)
+{
+    UNPACKER(self, uk);
+    return uk->symbolize_keys ? Qtrue : Qfalse;
+}
+
+static VALUE Unpacker_allow_unknown_ext_p(VALUE self)
+{
+    UNPACKER(self, uk);
+    return uk->allow_unknown_ext ? Qtrue : Qfalse;
+}
+
 static void raise_unpacker_error(int r)
 {
     switch(r) {
@@ -455,6 +467,8 @@ void MessagePack_Unpacker_module_init(VALUE mMessagePack)
     rb_define_alloc_func(cMessagePack_Unpacker, MessagePack_Unpacker_alloc);
 
     rb_define_method(cMessagePack_Unpacker, "initialize", MessagePack_Unpacker_initialize, -1);
+    rb_define_method(cMessagePack_Unpacker, "symbolize_keys?", Unpacker_symbolized_keys_p, 0);
+    rb_define_method(cMessagePack_Unpacker, "allow_unknown_ext?", Unpacker_allow_unknown_ext_p, 0);
     rb_define_method(cMessagePack_Unpacker, "buffer", Unpacker_buffer, 0);
     rb_define_method(cMessagePack_Unpacker, "read", Unpacker_read, 0);
     rb_define_alias(cMessagePack_Unpacker, "unpack", "read");

data/ext/msgpack/unpacker_ext_registry.c

@@ -60,9 +60,3 @@ VALUE msgpack_unpacker_ext_registry_put(msgpack_unpacker_ext_registry_t* ukrg,
     ukrg->array[ext_type + 128] = e;
     return before;
 }
-
-VALUE msgpack_unpacker_ext_registry_call(msgpack_unpacker_ext_registry_t* ukrg,
-        VALUE proc, VALUE ext_data)
-{
-    return rb_funcall(proc, s_call, 1, ext_data);
-}

data/ext/msgpack/unpacker_ext_registry.h

@@ -56,7 +56,4 @@ static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_re
     return rb_ary_entry(e, 1);
 }
 
-VALUE msgpack_unpacker_ext_registry_call(msgpack_unpacker_ext_registry_t* ukrg,
-        VALUE proc, VALUE ext_data);
-
 #endif

data/lib/msgpack/version.rb

@@ -1,3 +1,3 @@
 module MessagePack
-  VERSION = "0.7.0dev1"
+  VERSION = "0.7.0"
 end

data/msgpack.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.version = MessagePack::VERSION
   s.summary = "MessagePack, a binary-based efficient data interchange format."
   s.description = %q{MessagePack is a binary-based efficient object serialization library. It enables to exchange structured objects between many languages like JSON. But unlike JSON, it is very fast and small.}
-  s.authors = ["Sadayuki Furuhashi", "Theo Hultberg"]
-  s.email = ["frsyuki@gmail.com", "theo@iconara.net"]
+  s.authors = ["Sadayuki Furuhashi", "Theo Hultberg", "Satoshi Tagomori"]
+  s.email = ["frsyuki@gmail.com", "theo@iconara.net", "tagomoris@gmail.com"]
   s.license = "Apache 2.0"
   s.homepage = "http://msgpack.org/"
   s.rubyforge_project = "msgpack"
@@ -25,7 +25,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bundler', ['~> 1.0']
   s.add_development_dependency 'rake', ['~> 0.9.2']
   s.add_development_dependency 'rake-compiler', ['~> 0.9.4']
-  s.add_development_dependency 'rake-compiler-dock', ['~> 0.4.3']
+  if /java/ !~ RUBY_PLATFORM
+    s.add_development_dependency 'rake-compiler-dock', ['~> 0.4.3']
+  end
   s.add_development_dependency 'rspec', ['~> 3.3']
   s.add_development_dependency 'yard', ['~> 0.8.2']
   s.add_development_dependency 'json'

data/spec/cruby/unpacker_spec.rb

@@ -10,60 +10,6 @@ describe Unpacker do
     Packer.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)  # TypeError is included in UnexpectedTypeError
-    lambda {
-      unpacker.read_array_header
-    }.should raise_error(MessagePack::UnexpectedTypeError)
-  end
-
-  it 'read_map_header converts an map to key-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("\x81")
-    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("\x91")
-    lambda {
-      unpacker.read_map_header
-    }.should raise_error(MessagePack::TypeError)  # TypeError is included in UnexpectedTypeError
-    lambda {
-      unpacker.read_map_header
-    }.should raise_error(MessagePack::UnexpectedTypeError)
-  end
-
   it 'skip_nil succeeds' do
     unpacker.feed("\xc0")
     unpacker.skip_nil.should == true
@@ -91,12 +37,6 @@ describe Unpacker do
     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
@@ -109,88 +49,6 @@ describe Unpacker do
     }.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 'feed and each continue internal state' do
-    raw = sample_object.to_msgpack.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_msgpack.to_s * 4
-    objects = []
-
-    raw.split(//).each do |b|
-      unpacker.feed_each(b) {|c|
-        objects << c
-      }
-    end
-
-    objects.should == [sample_object] * 4
-  end
-
-  it 'feed_each enumerator' do
-    raw = sample_object.to_msgpack.to_s * 4
-
-    unpacker.feed_each(raw).to_a.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 'frozen short strings' do
-    raw = sample_object.to_msgpack.to_s.force_encoding('UTF-8')
-    lambda {
-      unpacker.feed_each(raw.freeze) { }
-    }.should_not raise_error
-  end
-
-  it 'frozen long strings' do
-    raw = (sample_object.to_msgpack.to_s * 10240).force_encoding('UTF-8')
-    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
-    unpacker.feed(packer.to_s)
-    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)
@@ -202,116 +60,11 @@ describe Unpacker do
     }.should raise_error(MessagePack::StackError)
   end
 
-  it 'read raises invalid byte error' do
-    unpacker.feed("\xc1")
-    lambda {
-      unpacker.read
-    }.should raise_error(MessagePack::MalformedFormatError)
-  end
-
   it 'skip raises invalid byte error' do
     unpacker.feed("\xc1")
     lambda {
       unpacker.skip
     }.should raise_error(MessagePack::MalformedFormatError)
   end
-
-  it "gc mark" do
-    raw = sample_object.to_msgpack.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_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
-
-  it 'MessagePack.unpack symbolize_keys' do
-    symbolized_hash = {:a => 'b', :c => 'd'}
-    MessagePack.load(MessagePack.pack(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
-    MessagePack.unpack(MessagePack.pack(symbolized_hash), :symbolize_keys => true).should == symbolized_hash
-  end
-
-  it 'Unpacker#unpack symbolize_keys' do
-    unpacker = Unpacker.new(:symbolize_keys => true)
-    symbolized_hash = {:a => 'b', :c => 'd'}
-    unpacker.feed(MessagePack.pack(symbolized_hash)).read.should == symbolized_hash
-  end
-
-  it "msgpack str 8 type" do
-    MessagePack.unpack([0xd9, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xd9, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
-    MessagePack.unpack([0xd9, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xd9, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack str 16 type" do
-    MessagePack.unpack([0xda, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xda, 0x00, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
-    MessagePack.unpack([0xda, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xda, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack str 32 type" do
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x00].pack('C*')).encoding.should == Encoding::UTF_8
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xdb, 0x00, 0x00, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack bin 8 type" do
-    MessagePack.unpack([0xc4, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xc4, 0x00].pack('C*')).encoding.should == Encoding::ASCII_8BIT
-    MessagePack.unpack([0xc4, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xc4, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack bin 16 type" do
-    MessagePack.unpack([0xc5, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xc5, 0x00, 0x00].pack('C*')).encoding.should == Encoding::ASCII_8BIT
-    MessagePack.unpack([0xc5, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xc5, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
-
-  it "msgpack bin 32 type" do
-    MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x00].pack('C*')).should == ""
-    MessagePack.unpack([0xc6, 0x0, 0x00, 0x00, 0x000].pack('C*')).encoding.should == Encoding::ASCII_8BIT
-    MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x01].pack('C*') + 'a').should == "a"
-    MessagePack.unpack([0xc6, 0x00, 0x00, 0x00, 0x02].pack('C*') + 'aa').should == "aa"
-  end
 end
 

data/spec/factory_spec.rb

@@ -1,8 +1,6 @@
 # encoding: ascii-8bit
 require 'spec_helper'
 
-eval("return") if java?
-
 describe MessagePack::Factory do
   subject do
     described_class.new
@@ -220,7 +218,6 @@ describe MessagePack::Factory do
     require_relative 'exttypes'
 
     it 'should be referred by MessagePack.pack and MessagePack.unpack' do
-      skip("not supported yet in JRuby implementation") if java?
       MessagePack::DefaultFactory.register_type(DummyTimeStamp1::TYPE, DummyTimeStamp1)
       MessagePack::DefaultFactory.register_type(DummyTimeStamp2::TYPE, DummyTimeStamp2, packer: :serialize, unpacker: :deserialize)
 

data/spec/jruby/{msgpack/unpacker_spec.rb → unpacker_spec.rb}

@@ -2,43 +2,35 @@
 
 require 'stringio'
 require 'tempfile'
-require 'spec_helper'
 
+require 'spec_helper'
 
-describe ::MessagePack::Unpacker do
-  def flatten(struct, results = [])
-    case struct
-    when Array
-      struct.each { |v| flatten(v, results) }
-    when Hash
-      struct.each { |k, v| flatten(v, flatten(k, results)) }
-    else
-      results << struct
-    end
-    results
+describe MessagePack::Unpacker do
+  let :unpacker do
+    MessagePack::Unpacker.new
   end
 
-  subject do
-    described_class.new
+  let :packer do
+    MessagePack::Packer.new
   end
-  
+
   let :buffer1 do
     MessagePack.pack(:foo => 'bar')
   end
-    
+
   let :buffer2 do
     MessagePack.pack(:hello => {:world => [1, 2, 3]})
   end
-    
+
   let :buffer3 do
     MessagePack.pack(:x => 'y')
   end
-  
+
   describe '#execute/#execute_limit/#finished?' do
     let :buffer do
       buffer1 + buffer2 + buffer3
     end
-    
+
     it 'extracts an object from the buffer' do
       subject.execute(buffer, 0)
       subject.data.should == {'foo' => 'bar'}
@@ -53,7 +45,7 @@ describe ::MessagePack::Unpacker do
       subject.execute_limit(buffer, buffer1.length, buffer2.length)
       subject.data.should == {'hello' => {'world' => [1, 2, 3]}}
     end
-    
+
     it 'extracts nothing if the limit cuts an object in half' do
       subject.execute_limit(buffer, buffer1.length, 3)
       subject.data.should be_nil
@@ -63,63 +55,17 @@ describe ::MessagePack::Unpacker do
       subject.execute(buffer, 0).should == buffer1.length
       subject.execute(buffer, buffer1.length).should == buffer1.length + buffer2.length
     end
-    
+
     it 'is finished if #data returns an object' do
       subject.execute_limit(buffer, buffer1.length, buffer2.length)
       subject.should be_finished
-      
+
       subject.execute_limit(buffer, buffer1.length, 3)
       subject.should_not be_finished
     end
   end
 
-  describe '#read' do
-    context 'with a buffer' do
-      it 'reads objects' do
-        objects = []
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        objects << subject.read
-        objects << subject.read
-        objects << subject.read
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-
-      it 'reads map header' do
-        subject.feed({}.to_msgpack)
-        subject.read_map_header.should == 0
-      end
-
-      it 'reads array header' do
-        subject.feed([].to_msgpack)
-        subject.read_array_header.should == 0
-      end
-    end
-  end
-  
   describe '#each' do
-    context 'with a buffer' do
-      it 'yields each object in the buffer' do
-        objects = []
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        subject.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-      
-      it 'returns an enumerator when no block is given' do
-        subject.feed(buffer1)
-        subject.feed(buffer2)
-        subject.feed(buffer3)
-        enum = subject.each
-        enum.map { |obj| obj.keys.first }.should == %w[foo hello x]
-      end
-    end
-    
     context 'with a StringIO stream' do
       it 'yields each object in the stream' do
         objects = []
@@ -130,7 +76,7 @@ describe ::MessagePack::Unpacker do
         objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
       end
     end
-    
+
     context 'with a File stream' do
       it 'yields each object in the stream' do
         objects = []
@@ -146,40 +92,8 @@ describe ::MessagePack::Unpacker do
         objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
       end
     end
-    
-    context 'with a stream passed to the constructor' do
-      it 'yields each object in the stream' do
-        objects = []
-        unpacker = described_class.new(StringIO.new(buffer1 + buffer2 + buffer3))
-        unpacker.each do |obj|
-          objects << obj
-        end
-        objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-      end
-    end
   end
-  
-  describe '#feed_each' do
-    it 'feeds the buffer then runs #each' do
-      objects = []
-      subject.feed_each(buffer1 + buffer2 + buffer3) do |obj|
-        objects << obj
-      end
-      objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-    end
 
-    it 'handles chunked data' do
-      objects = []
-      buffer = buffer1 + buffer2 + buffer3
-      buffer.chars.each do |ch|
-        subject.feed_each(ch) do |obj|
-          objects << obj
-        end
-      end
-      objects.should == [{'foo' => 'bar'}, {'hello' => {'world' => [1, 2, 3]}}, {'x' => 'y'}]
-    end
-  end
-  
   describe '#fill' do
     it 'is a no-op' do
       subject.stream = StringIO.new(buffer1 + buffer2 + buffer3)
@@ -187,22 +101,17 @@ describe ::MessagePack::Unpacker do
       subject.each { |obj| }
     end
   end
-  
-  describe '#reset' do
-    context 'with a buffer' do
-      it 'is unclear what it is supposed to do'
-    end
-    
-    context 'with a stream' do
-      it 'is unclear what it is supposed to do'
-    end
-  end
 
-  context 'regressions' do
-    it 'handles massive arrays (issue #2)' do
-      array = ['foo'] * 10_000
-      MessagePack.unpack(MessagePack.pack(array)).should have(10_000).items
+  def flatten(struct, results = [])
+    case struct
+    when Array
+      struct.each { |v| flatten(v, results) }
+    when Hash
+      struct.each { |k, v| flatten(v, flatten(k, results)) }
+    else
+      results << struct
     end
+    results
   end
 
   context 'encoding', :encodings do
@@ -229,15 +138,15 @@ describe ::MessagePack::Unpacker do
       Encoding.default_external = Encoding::ISO_8859_1
     end
 
-    it 'produces results with default internal encoding' do
+    it 'produces results with encoding as binary or string(utf8)' do
       unpacker.execute(buffer, 0)
       strings = flatten(unpacker.data).grep(String)
-      strings.map(&:encoding).uniq.should == [Encoding.default_internal]
+      strings.map(&:encoding).uniq.sort{|a,b| a.to_s <=> b.to_s}.should == [Encoding::ASCII_8BIT, Encoding::UTF_8]
     end
 
     it 'recodes to internal encoding' do
       unpacker.execute(buffer, 0)
-      unpacker.data['nested'][1].keys.should == ["sk\xC3\xA5l".force_encoding(Encoding.default_internal)]
+      unpacker.data['nested'][1].keys.should == ["sk\xC3\xA5l".force_encoding(Encoding::UTF_8)]
     end
   end
 
@@ -255,23 +164,6 @@ describe ::MessagePack::Unpacker do
         unpacker.execute(buffer, 0)
         unpacker.data.should == {:hello => 'world', :nested => ['object', {:structure => true}]}
       end
-
-      it 'can symbolize keys when using #each' do
-        objs = []
-        unpacker.feed(buffer)
-        unpacker.each do |obj|
-          objs << obj
-        end
-        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
-      end
-
-      it 'can symbolize keys when using #feed_each' do
-        objs = []
-        unpacker.feed_each(buffer) do |obj|
-          objs << obj
-        end
-        objs.should == [{:hello => 'world', :nested => ['object', {:structure => true}]}]
-      end
     end
 
     context 'encoding', :encodings do
@@ -280,35 +172,14 @@ describe ::MessagePack::Unpacker do
       end
 
       let :unpacker do
-        described_class.new(:encoding => 'UTF-8')
+        described_class.new()
       end
 
-      it 'can hardcode encoding when using #execute' do
+      it 'decode binary as ascii-8bit string when using #execute' do
         unpacker.execute(buffer, 0)
         strings = flatten(unpacker.data).grep(String)
         strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-
-      it 'can hardcode encoding when using #each' do
-        objs = []
-        unpacker.feed(buffer)
-        unpacker.each do |obj|
-          objs << obj
-        end
-        strings = flatten(objs).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
-      end
-
-      it 'can hardcode encoding when using #feed_each' do
-        objs = []
-        unpacker.feed_each(buffer) do |obj|
-          objs << obj
-        end
-        strings = flatten(objs).grep(String)
-        strings.should == %w[hello world nested object structure]
-        strings.map(&:encoding).uniq.should == [Encoding::UTF_8]
+        strings.map(&:encoding).uniq.should == [Encoding::ASCII_8BIT]
       end
     end
   end