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

data/spec/msgpack_spec.rb

@@ -116,7 +116,7 @@ describe MessagePack do
     end
 
     it 'rasies an error on #unpack with garbage' do
-      skip "???"
+      skip "but nothing was raised. why?"
       expect { MessagePack.unpack('asdka;sd') }.to raise_error(MessagePack::UnpackError)
     end
   end

data/spec/packer_spec.rb

@@ -1,6 +1,141 @@
+# encoding: ascii-8bit
 require 'spec_helper'
 
+require 'stringio'
+if defined?(Encoding)
+  Encoding.default_external = 'ASCII-8BIT'
+end
+
 describe MessagePack::Packer do
+  let :packer do
+    MessagePack::Packer.new
+  end
+
+  it 'initialize' do
+    MessagePack::Packer.new
+    MessagePack::Packer.new(nil)
+    MessagePack::Packer.new(StringIO.new)
+    MessagePack::Packer.new({})
+    MessagePack::Packer.new(StringIO.new, {})
+  end
+
+  it 'gets options to specify how to pack values' do
+    u1 = MessagePack::Packer.new
+    u1.compatibility_mode?.should == false
+
+    u2 = MessagePack::Packer.new(compatibility_mode: true)
+    u2.compatibility_mode?.should == true
+  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 = MessagePack::Packer.new(io)
+    pk.write_nil
+    pk.flush
+    pk.to_s.should == ''
+    io.string.should == "\xc0"
+  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
+
+  context 'in compatibility mode' do
+    it 'does not use the bin types' do
+      packed = MessagePack.pack('hello'.force_encoding(Encoding::BINARY), compatibility_mode: true)
+      packed.should eq("\xA5hello")
+      packed = MessagePack.pack(('hello' * 100).force_encoding(Encoding::BINARY), compatibility_mode: true)
+      packed.should start_with("\xDA\x01\xF4")
+
+      packer = MessagePack::Packer.new(compatibility_mode: 1)
+      packed = packer.pack(('hello' * 100).force_encoding(Encoding::BINARY))
+      packed.to_str.should start_with("\xDA\x01\xF4")
+    end
+
+    it 'does not use the str8 type' do
+      packed = MessagePack.pack('x' * 32, compatibility_mode: true)
+      packed.should start_with("\xDA\x00\x20")
+    end
+  end
+
   class ValueOne
     def initialize(num)
       @num = num
@@ -33,14 +168,12 @@ describe MessagePack::Packer do
 
   describe '#type_registered?' do
     it 'receive Class or Integer, and return bool' do
-      skip("not supported yet in JRuby implementation") if java?
       expect(subject.type_registered?(0x00)).to be_falsy
       expect(subject.type_registered?(0x01)).to be_falsy
       expect(subject.type_registered?(::ValueOne)).to be_falsy
     end
 
     it 'returns true if specified type or class is already registered' do
-      skip("not supported yet in JRuby implementation") if java?
       subject.register_type(0x30, ::ValueOne, :to_msgpack_ext)
       subject.register_type(0x31, ::ValueTwo, :to_msgpack_ext)
 
@@ -56,7 +189,6 @@ describe MessagePack::Packer do
 
   describe '#register_type' do
     it 'get type and class mapping for packing' do
-      skip("not supported yet in JRuby implementation") if java?
       packer = MessagePack::Packer.new
       packer.register_type(0x01, ValueOne){|obj| obj.to_msgpack_ext }
       packer.register_type(0x02, ValueTwo){|obj| obj.to_msgpack_ext }
@@ -71,7 +203,6 @@ describe MessagePack::Packer do
     end
 
     it 'returns a Hash which contains map of Class and type' do
-      skip("not supported yet in JRuby implementation") if java?
       packer = MessagePack::Packer.new
       packer.register_type(0x01, ValueOne, :to_msgpack_ext)
       packer.register_type(0x02, ValueTwo, :to_msgpack_ext)

data/spec/unpacker_spec.rb

@@ -1,6 +1,265 @@
+# encoding: ascii-8bit
+
+require 'stringio'
+require 'tempfile'
+
 require 'spec_helper'
 
 describe MessagePack::Unpacker do
+  let :unpacker do
+    MessagePack::Unpacker.new
+  end
+
+  let :packer do
+    MessagePack::Packer.new
+  end
+
+  it 'gets options to specify how to unpack values' do
+    u1 = MessagePack::Unpacker.new
+    u1.symbolize_keys?.should == false
+    u1.allow_unknown_ext?.should == false
+
+    u2 = MessagePack::Unpacker.new(symbolize_keys: true, allow_unknown_ext: true)
+    u2.symbolize_keys?.should == true
+    u2.allow_unknown_ext?.should == true
+  end
+
+  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 = MessagePack::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 = MessagePack::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 'read raises EOFError before feeding' do
+    lambda {
+      unpacker.read
+    }.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
+
+    enum = unpacker.feed_each(raw)
+    enum.should be_instance_of(Enumerator)
+    enum.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 invalid byte error' do
+    unpacker.feed("\xc1")
+    lambda {
+      unpacker.read
+    }.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 = MessagePack::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
+
   class ValueOne
     attr_reader :num
     def initialize(num)
@@ -41,14 +300,12 @@ describe MessagePack::Unpacker do
 
   describe '#type_registered?' do
     it 'receive Class or Integer, and return bool' do
-      skip("not supported yet in JRuby implementation") if java?
       expect(subject.type_registered?(0x00)).to be_falsy
       expect(subject.type_registered?(0x01)).to be_falsy
       expect(subject.type_registered?(::ValueOne)).to be_falsy
     end
 
     it 'returns true if specified type or class is already registered' do
-      skip("not supported yet in JRuby implementation") if java?
       subject.register_type(0x30, ::ValueOne, :from_msgpack_ext)
       subject.register_type(0x31, ::ValueTwo, :from_msgpack_ext)
 
@@ -62,7 +319,6 @@ describe MessagePack::Unpacker do
     end
 
     it 'cannot detect unpack rule with block, not method' do
-      skip("not supported yet in JRuby implementation") if java?
       subject.register_type(0x40){|data| ValueOne.from_msgpack_ext(data) }
 
       expect(subject.type_registered?(0x40)).to be_truthy
@@ -72,7 +328,6 @@ describe MessagePack::Unpacker do
 
   context 'with ext definitions' do
     it 'get type and class mapping for packing' do
-      skip("not supported yet in JRuby implementation") if java?
       unpacker = MessagePack::Unpacker.new
       unpacker.register_type(0x01){|data| ValueOne.from_msgpack_ext }
       unpacker.register_type(0x02){|data| ValueTwo.from_msgpack_ext(data) }
@@ -83,7 +338,6 @@ describe MessagePack::Unpacker do
     end
 
     it 'returns a Array of Hash which contains :type, :class and :unpacker' do
-      skip("not supported yet in JRuby implementation") if java?
       unpacker = MessagePack::Unpacker.new
       unpacker.register_type(0x02, ValueTwo, :from_msgpack_ext)
       unpacker.register_type(0x01, ValueOne, :from_msgpack_ext)
@@ -107,7 +361,6 @@ describe MessagePack::Unpacker do
     end
 
     it 'returns a Array of Hash, which contains nil for class if block unpacker specified' do
-      skip("not supported yet in JRuby implementation") if java?
       unpacker = MessagePack::Unpacker.new
       unpacker.register_type(0x01){|data| ValueOne.from_msgpack_ext }
       unpacker.register_type(0x02, &ValueTwo.method(:from_msgpack_ext))
@@ -130,4 +383,210 @@ describe MessagePack::Unpacker do
       expect(two[:unpacker]).to be_instance_of(Proc)
     end
   end
+
+  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
+
+  subject do
+    described_class.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 '#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 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
+
+  context 'regressions' do
+    it 'handles massive arrays (issue #2)' do
+      array = ['foo'] * 10_000
+      MessagePack.unpack(MessagePack.pack(array)).size.should == 10_000
+    end
+  end
+
+  context 'extensions' do
+    context 'symbolized keys' do
+      let :buffer do
+        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
+      end
+
+      let :unpacker do
+        described_class.new(:symbolize_keys => 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 'binary encoding', :encodings do
+      let :buffer do
+        MessagePack.pack({'hello' => 'world', 'nested' => ['object', {'structure' => true}]})
+      end
+
+      let :unpacker do
+        described_class.new()
+      end
+
+      it 'decodes binary as ascii-8bit when using #feed' 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::ASCII_8BIT]
+      end
+
+      it 'decodes binary as ascii-8bit 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::ASCII_8BIT]
+      end
+    end
+
+    context 'string encoding', :encodings do
+      let :buffer do
+        MessagePack.pack({'hello'.force_encoding(Encoding::UTF_8) => 'world'.force_encoding(Encoding::UTF_8), 'nested'.force_encoding(Encoding::UTF_8) => ['object'.force_encoding(Encoding::UTF_8), {'structure'.force_encoding(Encoding::UTF_8) => true}]})
+      end
+
+      let :unpacker do
+        described_class.new()
+      end
+
+      it 'decodes string as utf-8 when using #feed' 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 'decodes binary as ascii-8bit 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]
+      end
+    end
+  end
 end