thrift 0.24.0 → 0.25.0

data/spec/base_protocol_spec.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-require 'spec_helper'
-
-describe 'BaseProtocol' do
-  before(:each) do
-    @trans = double("MockTransport")
-    @prot = Thrift::BaseProtocol.new(@trans)
-  end
-
-  describe Thrift::BaseProtocol do
-    # most of the methods are stubs, so we can ignore them
-
-    it "should provide a reasonable to_s" do
-      expect(@trans).to receive(:to_s).once.and_return("trans")
-      expect(@prot.to_s).to eq("trans")
-    end
-
-    it "should make trans accessible" do
-      expect(@prot.trans).to eql(@trans)
-    end
-
-    it 'should write out a field nicely (deprecated write_field signature)' do
-      expect(@prot).to receive(:write_field_begin).with('field', 'type', 'fid').ordered
-      expect(@prot).to receive(:write_type).with({:name => 'field', :type => 'type'}, 'value').ordered
-      expect(@prot).to receive(:write_field_end).ordered
-      @prot.write_field('field', 'type', 'fid', 'value')
-    end
-
-    it 'should write out a field nicely' do
-      expect(@prot).to receive(:write_field_begin).with('field', 'type', 'fid').ordered
-      expect(@prot).to receive(:write_type).with({:name => 'field', :type => 'type', :binary => false}, 'value').ordered
-      expect(@prot).to receive(:write_field_end).ordered
-      @prot.write_field({:name => 'field', :type => 'type', :binary => false}, 'fid', 'value')
-    end
-
-    it 'should write out the different types (deprecated write_type signature)' do
-      expect(@prot).to receive(:write_bool).with('bool').ordered
-      expect(@prot).to receive(:write_byte).with('byte').ordered
-      expect(@prot).to receive(:write_double).with('double').ordered
-      expect(@prot).to receive(:write_i16).with('i16').ordered
-      expect(@prot).to receive(:write_i32).with('i32').ordered
-      expect(@prot).to receive(:write_i64).with('i64').ordered
-      expect(@prot).to receive(:write_string).with('string').ordered
-      struct = double('Struct')
-      expect(struct).to receive(:write).with(@prot).ordered
-      @prot.write_type(Thrift::Types::BOOL, 'bool')
-      @prot.write_type(Thrift::Types::BYTE, 'byte')
-      @prot.write_type(Thrift::Types::DOUBLE, 'double')
-      @prot.write_type(Thrift::Types::I16, 'i16')
-      @prot.write_type(Thrift::Types::I32, 'i32')
-      @prot.write_type(Thrift::Types::I64, 'i64')
-      @prot.write_type(Thrift::Types::STRING, 'string')
-      @prot.write_type(Thrift::Types::STRUCT, struct)
-      # all other types are not implemented
-      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP, Thrift::Types::SET, Thrift::Types::LIST].each do |type|
-        expect { @prot.write_type(type, type.to_s) }.to raise_error(NotImplementedError)
-      end
-    end
-
-    it 'should write out the different types' do
-      expect(@prot).to receive(:write_bool).with('bool').ordered
-      expect(@prot).to receive(:write_byte).with('byte').ordered
-      expect(@prot).to receive(:write_double).with('double').ordered
-      expect(@prot).to receive(:write_i16).with('i16').ordered
-      expect(@prot).to receive(:write_i32).with('i32').ordered
-      expect(@prot).to receive(:write_i64).with('i64').ordered
-      expect(@prot).to receive(:write_string).with('string').ordered
-      expect(@prot).to receive(:write_binary).with('binary').ordered
-      struct = double('Struct')
-      expect(struct).to receive(:write).with(@prot).ordered
-      @prot.write_type({:type => Thrift::Types::BOOL}, 'bool')
-      @prot.write_type({:type => Thrift::Types::BYTE}, 'byte')
-      @prot.write_type({:type => Thrift::Types::DOUBLE}, 'double')
-      @prot.write_type({:type => Thrift::Types::I16}, 'i16')
-      @prot.write_type({:type => Thrift::Types::I32}, 'i32')
-      @prot.write_type({:type => Thrift::Types::I64}, 'i64')
-      @prot.write_type({:type => Thrift::Types::STRING}, 'string')
-      @prot.write_type({:type => Thrift::Types::STRING, :binary => true}, 'binary')
-      @prot.write_type({:type => Thrift::Types::STRUCT}, struct)
-      # all other types are not implemented
-      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP, Thrift::Types::SET, Thrift::Types::LIST].each do |type|
-        expect { @prot.write_type({:type => type}, type.to_s) }.to raise_error(NotImplementedError)
-      end
-    end
-
-    it 'should read the different types (deprecated read_type signature)' do
-      expect(@prot).to receive(:read_bool).ordered
-      expect(@prot).to receive(:read_byte).ordered
-      expect(@prot).to receive(:read_i16).ordered
-      expect(@prot).to receive(:read_i32).ordered
-      expect(@prot).to receive(:read_i64).ordered
-      expect(@prot).to receive(:read_double).ordered
-      expect(@prot).to receive(:read_string).ordered
-      @prot.read_type(Thrift::Types::BOOL)
-      @prot.read_type(Thrift::Types::BYTE)
-      @prot.read_type(Thrift::Types::I16)
-      @prot.read_type(Thrift::Types::I32)
-      @prot.read_type(Thrift::Types::I64)
-      @prot.read_type(Thrift::Types::DOUBLE)
-      @prot.read_type(Thrift::Types::STRING)
-      # all other types are not implemented
-      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP,
-       Thrift::Types::SET, Thrift::Types::LIST, Thrift::Types::STRUCT].each do |type|
-        expect { @prot.read_type(type) }.to raise_error(NotImplementedError)
-      end
-    end
-
-    it 'should read the different types' do
-      expect(@prot).to receive(:read_bool).ordered
-      expect(@prot).to receive(:read_byte).ordered
-      expect(@prot).to receive(:read_i16).ordered
-      expect(@prot).to receive(:read_i32).ordered
-      expect(@prot).to receive(:read_i64).ordered
-      expect(@prot).to receive(:read_double).ordered
-      expect(@prot).to receive(:read_string).ordered
-      expect(@prot).to receive(:read_binary).ordered
-      @prot.read_type({:type => Thrift::Types::BOOL})
-      @prot.read_type({:type => Thrift::Types::BYTE})
-      @prot.read_type({:type => Thrift::Types::I16})
-      @prot.read_type({:type => Thrift::Types::I32})
-      @prot.read_type({:type => Thrift::Types::I64})
-      @prot.read_type({:type => Thrift::Types::DOUBLE})
-      @prot.read_type({:type => Thrift::Types::STRING})
-      @prot.read_type({:type => Thrift::Types::STRING, :binary => true})
-      # all other types are not implemented
-      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP,
-       Thrift::Types::SET, Thrift::Types::LIST, Thrift::Types::STRUCT].each do |type|
-        expect { @prot.read_type({:type => type}) }.to raise_error(NotImplementedError)
-      end
-    end
-
-    it "should skip the basic types" do
-      expect(@prot).to receive(:read_bool).ordered
-      expect(@prot).to receive(:read_byte).ordered
-      expect(@prot).to receive(:read_i16).ordered
-      expect(@prot).to receive(:read_i32).ordered
-      expect(@prot).to receive(:read_i64).ordered
-      expect(@prot).to receive(:read_double).ordered
-      expect(@prot).to receive(:read_string).ordered
-      @prot.skip(Thrift::Types::BOOL)
-      @prot.skip(Thrift::Types::BYTE)
-      @prot.skip(Thrift::Types::I16)
-      @prot.skip(Thrift::Types::I32)
-      @prot.skip(Thrift::Types::I64)
-      @prot.skip(Thrift::Types::DOUBLE)
-      @prot.skip(Thrift::Types::STRING)
-    end
-
-    it "should skip structs" do
-      real_skip = @prot.method(:skip)
-      expect(@prot).to receive(:read_struct_begin).ordered
-      expect(@prot).to receive(:read_field_begin).exactly(4).times.and_return(
-        ['field 1', Thrift::Types::STRING, 1],
-        ['field 2', Thrift::Types::I32, 2],
-        ['field 3', Thrift::Types::MAP, 3],
-        [nil, Thrift::Types::STOP, 0]
-      )
-      expect(@prot).to receive(:read_field_end).exactly(3).times
-      expect(@prot).to receive(:read_string).exactly(3).times
-      expect(@prot).to receive(:read_i32).ordered
-      expect(@prot).to receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRING, 1])
-      # @prot.should_receive(:read_string).exactly(2).times
-      expect(@prot).to receive(:read_map_end).ordered
-      expect(@prot).to receive(:read_struct_end).ordered
-      real_skip.call(Thrift::Types::STRUCT)
-    end
-
-    it "should skip maps" do
-      real_skip = @prot.method(:skip)
-      expect(@prot).to receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRUCT, 1])
-      expect(@prot).to receive(:read_string).ordered
-      expect(@prot).to receive(:read_struct_begin).ordered.and_return(["some_struct"])
-      expect(@prot).to receive(:read_field_begin).ordered.and_return([nil, Thrift::Types::STOP, nil]);
-      expect(@prot).to receive(:read_struct_end).ordered
-      expect(@prot).to receive(:read_map_end).ordered
-      real_skip.call(Thrift::Types::MAP)
-    end
-
-    it "should skip sets" do
-      real_skip = @prot.method(:skip)
-      expect(@prot).to receive(:read_set_begin).ordered.and_return([Thrift::Types::I64, 9])
-      expect(@prot).to receive(:read_i64).ordered.exactly(9).times
-      expect(@prot).to receive(:read_set_end)
-      real_skip.call(Thrift::Types::SET)
-    end
-
-    it "should skip lists" do
-      real_skip = @prot.method(:skip)
-      expect(@prot).to receive(:read_list_begin).ordered.and_return([Thrift::Types::DOUBLE, 11])
-      expect(@prot).to receive(:read_double).ordered.exactly(11).times
-      expect(@prot).to receive(:read_list_end)
-      real_skip.call(Thrift::Types::LIST)
-    end
-
-    it "should raise DEPTH_LIMIT when max_depth is exhausted" do
-      expect { @prot.skip(Thrift::Types::STRUCT, 0) }.to raise_error(Thrift::ProtocolException) do |e|
-        expect(e.type).to eq(Thrift::ProtocolException::DEPTH_LIMIT)
-      end
-    end
-
-    it "should skip at max_depth=1 without raising" do
-      expect(@prot).to receive(:read_bool).once
-      expect { @prot.skip(Thrift::Types::BOOL, 1) }.not_to raise_error
-    end
-
-    it "should reject negative container sizes while skipping" do
-      expect(@prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, -1])
-
-      expect { @prot.skip(Thrift::Types::LIST) }.to raise_error(Thrift::ProtocolException, "Negative size") do |e|
-        expect(e.type).to eq(Thrift::ProtocolException::NEGATIVE_SIZE)
-      end
-    end
-  end
-
-  describe Thrift::BaseProtocolFactory do
-    it "should raise NotImplementedError" do
-      # returning nil since Protocol is just an abstract class
-      expect { Thrift::BaseProtocolFactory.new.get_protocol(double("MockTransport")) }.to raise_error(NotImplementedError)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(Thrift::BaseProtocolFactory.new.to_s).to eq("base")
-    end
-  end
-end

data/spec/base_transport_spec.rb

@@ -1,428 +0,0 @@
-# frozen_string_literal: true
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-require 'spec_helper'
-
-describe 'BaseTransport' do
-  describe Thrift::TransportException do
-    it "should make type accessible" do
-      exc = Thrift::TransportException.new(Thrift::TransportException::ALREADY_OPEN, "msg")
-      expect(exc.type).to eq(Thrift::TransportException::ALREADY_OPEN)
-      expect(exc.message).to eq("msg")
-    end
-  end
-
-  describe Thrift::BaseTransport do
-    it "should read the specified size" do
-      transport = Thrift::BaseTransport.new
-      expect(transport).to receive(:read).with(40).ordered.and_return("10 letters")
-      expect(transport).to receive(:read).with(30).ordered.and_return("fifteen letters")
-      expect(transport).to receive(:read).with(15).ordered.and_return("more characters")
-      expect(transport.read_all(40)).to eq("10 lettersfifteen lettersmore characters")
-    end
-
-    it "should coerce reads to binary encoding" do
-      transport = Thrift::BaseTransport.new
-      expect(transport).to receive(:read).with(3).and_return(+'abc')
-
-      buf = transport.read_all(3)
-
-      expect(buf).to eq('abc')
-      expect(buf.encoding).to eq(Encoding::BINARY)
-    end
-
-    it "should reject negative read sizes" do
-      transport = Thrift::BaseTransport.new
-      expect(transport).not_to receive(:read)
-
-      expect { transport.read_all(-1) }.to raise_error(Thrift::TransportException, "Negative size") do |e|
-        expect(e.type).to eq(Thrift::TransportException::NEGATIVE_SIZE)
-      end
-    end
-
-    it "should stub out the rest of the methods" do
-      # can't test for stubbiness, so just make sure they're defined
-      [:open?, :open, :close, :read, :write, :flush].each do |sym|
-        expect(Thrift::BaseTransport.method_defined?(sym)).to be_truthy
-      end
-    end
-
-    it "should alias << to write" do
-      expect(Thrift::BaseTransport.instance_method(:<<)).to eq(Thrift::BaseTransport.instance_method(:write))
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(Thrift::BaseTransport.new.to_s).to eq("base")
-    end
-  end
-
-  describe Thrift::BaseServerTransport do
-    it "should stub out its methods" do
-      [:listen, :accept, :close].each do |sym|
-        expect(Thrift::BaseServerTransport.method_defined?(sym)).to be_truthy
-      end
-    end
-  end
-
-  describe Thrift::BaseTransportFactory do
-    it "should return the transport it's given" do
-      transport = double("Transport")
-      expect(Thrift::BaseTransportFactory.new.get_transport(transport)).to eql(transport)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(Thrift::BaseTransportFactory.new.to_s).to eq("base")
-    end
-  end
-
-  describe Thrift::BufferedTransport do
-    it "should provide a to_s that describes the encapsulation" do
-      trans = double("Transport")
-      expect(trans).to receive(:to_s).and_return("mock")
-      expect(Thrift::BufferedTransport.new(trans).to_s).to eq("buffered(mock)")
-    end
-
-    it "should pass through everything but write/flush/read" do
-      trans = double("Transport")
-      expect(trans).to receive(:open?).ordered.and_return("+ open?")
-      expect(trans).to receive(:open).ordered.and_return("+ open")
-      expect(trans).to receive(:flush).ordered # from the close
-      expect(trans).to receive(:close).ordered.and_return("+ close")
-      btrans = Thrift::BufferedTransport.new(trans)
-      expect(btrans.open?).to eq("+ open?")
-      expect(btrans.open).to eq("+ open")
-      expect(btrans.close).to eq("+ close")
-    end
-
-    it "should buffer reads in chunks of #{Thrift::BufferedTransport::DEFAULT_BUFFER}" do
-      trans = double("Transport")
-      expect(trans).to receive(:read).with(Thrift::BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
-      btrans = Thrift::BufferedTransport.new(trans)
-      expect(btrans.read(6)).to eq("lorum ")
-      expect(btrans.read(6)).to eq("ipsum ")
-      expect(btrans.read(6)).to eq("dolor ")
-      expect(btrans.read(6)).to eq("emet")
-    end
-
-    it "should buffer writes and send them on flush" do
-      trans = double("Transport")
-      btrans = Thrift::BufferedTransport.new(trans)
-      btrans.write("one/")
-      btrans.write("two/")
-      btrans.write("three/")
-      expect(trans).to receive(:write).with("one/two/three/").ordered
-      expect(trans).to receive(:flush).ordered
-      btrans.flush
-    end
-
-    it "should only send buffered data once" do
-      trans = double("Transport")
-      btrans = Thrift::BufferedTransport.new(trans)
-      btrans.write("one/")
-      btrans.write("two/")
-      btrans.write("three/")
-      expect(trans).to receive(:write).with("one/two/three/")
-      allow(trans).to receive(:flush)
-      btrans.flush
-      # Nothing to flush with no data
-      btrans.flush
-    end
-
-    it "should flush on close" do
-      trans = double("Transport")
-      expect(trans).to receive(:close)
-      btrans = Thrift::BufferedTransport.new(trans)
-      expect(btrans).to receive(:flush)
-      btrans.close
-    end
-
-    it "should not write to socket if there's no data" do
-      trans = double("Transport")
-      expect(trans).to receive(:flush)
-      btrans = Thrift::BufferedTransport.new(trans)
-      btrans.flush
-    end
-  end
-
-  describe Thrift::BufferedTransportFactory do
-    it "should wrap the given transport in a BufferedTransport" do
-      trans = double("Transport")
-      btrans = double("BufferedTransport")
-      expect(Thrift::BufferedTransport).to receive(:new).with(trans).and_return(btrans)
-      expect(Thrift::BufferedTransportFactory.new.get_transport(trans)).to eq(btrans)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(Thrift::BufferedTransportFactory.new.to_s).to eq("buffered")
-    end
-  end
-
-  describe Thrift::FramedTransport do
-    before(:each) do
-      @trans = double("Transport")
-    end
-
-    it "should provide a to_s that describes the encapsulation" do
-      trans = double("Transport")
-      expect(trans).to receive(:to_s).and_return("mock")
-      expect(Thrift::FramedTransport.new(trans).to_s).to eq("framed(mock)")
-    end
-
-    it "should pass through open?/open/close" do
-      ftrans = Thrift::FramedTransport.new(@trans)
-      expect(@trans).to receive(:open?).ordered.and_return("+ open?")
-      expect(@trans).to receive(:open).ordered.and_return("+ open")
-      expect(@trans).to receive(:close).ordered.and_return("+ close")
-      expect(ftrans.open?).to eq("+ open?")
-      expect(ftrans.open).to eq("+ open")
-      expect(ftrans.close).to eq("+ close")
-    end
-
-    it "should pass through read when read is turned off" do
-      ftrans = Thrift::FramedTransport.new(@trans, false, true)
-      expect(@trans).to receive(:read).with(17).ordered.and_return("+ read")
-      expect(ftrans.read(17)).to eq("+ read")
-    end
-
-    it "should pass through write/flush when write is turned off" do
-      ftrans = Thrift::FramedTransport.new(@trans, true, false)
-      expect(@trans).to receive(:write).with("foo").ordered.and_return("+ write")
-      expect(@trans).to receive(:flush).ordered.and_return("+ flush")
-      expect(ftrans.write("foo")).to eq("+ write")
-      expect(ftrans.flush).to eq("+ flush")
-    end
-
-    it "should return a full frame if asked for >= the frame's length" do
-      frame = "this is a frame"
-      expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017")
-      expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
-      expect(Thrift::FramedTransport.new(@trans).read(frame.length + 10)).to eq(frame)
-    end
-
-    it "should return slices of the frame when asked for < the frame's length" do
-      frame = "this is a frame"
-      expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017")
-      expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
-      ftrans = Thrift::FramedTransport.new(@trans)
-      expect(ftrans.read(4)).to eq("this")
-      expect(ftrans.read(4)).to eq(" is ")
-      expect(ftrans.read(16)).to eq("a frame")
-    end
-
-    it "should return nothing if asked for <= 0" do
-      expect(Thrift::FramedTransport.new(@trans).read(-2)).to eq("")
-    end
-
-    it "should pull a new frame when the first is exhausted" do
-      frame = "this is a frame"
-      frame2 = "yet another frame"
-      expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
-      expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
-      expect(@trans).to receive(:read_all).with(frame2.length).and_return(frame2)
-      ftrans = Thrift::FramedTransport.new(@trans)
-      expect(ftrans.read(4)).to eq("this")
-      expect(ftrans.read(8)).to eq(" is a fr")
-      expect(ftrans.read(6)).to eq("ame")
-      expect(ftrans.read(4)).to eq("yet ")
-      expect(ftrans.read(16)).to eq("another frame")
-    end
-
-    it "should buffer writes" do
-      ftrans = Thrift::FramedTransport.new(@trans)
-      expect(@trans).not_to receive(:write)
-      ftrans.write("foo")
-      ftrans.write("bar")
-      ftrans.write("this is a frame")
-    end
-
-    it "should write slices of the buffer" do
-      ftrans = Thrift::FramedTransport.new(@trans)
-      ftrans.write("foobar", 3)
-      ftrans.write("barfoo", 1)
-      allow(@trans).to receive(:flush)
-      expect(@trans).to receive(:write).with("\000\000\000\004foob")
-      ftrans.flush
-    end
-
-    it "should flush frames with a 4-byte header" do
-      ftrans = Thrift::FramedTransport.new(@trans)
-      expect(@trans).to receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
-      expect(@trans).to receive(:flush).ordered
-      ftrans.write("one/")
-      ftrans.write("two/")
-      ftrans.write("three/")
-      ftrans.write("this is a frame")
-      ftrans.flush
-    end
-
-    it "should not flush the same buffered data twice" do
-      ftrans = Thrift::FramedTransport.new(@trans)
-      expect(@trans).to receive(:write).with("\000\000\000\007foo/bar")
-      allow(@trans).to receive(:flush)
-      ftrans.write("foo")
-      ftrans.write("/bar")
-      ftrans.flush
-      expect(@trans).to receive(:write).with("\000\000\000\000")
-      ftrans.flush
-    end
-  end
-
-  describe Thrift::FramedTransportFactory do
-    it "should wrap the given transport in a FramedTransport" do
-      trans = double("Transport")
-      expect(Thrift::FramedTransport).to receive(:new).with(trans)
-      Thrift::FramedTransportFactory.new.get_transport(trans)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(Thrift::FramedTransportFactory.new.to_s).to eq("framed")
-    end
-  end
-
-  describe Thrift::MemoryBufferTransport do
-    before(:each) do
-      @buffer = Thrift::MemoryBufferTransport.new
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@buffer.to_s).to eq("memory")
-    end
-
-    it "should accept a buffer on input and use it directly" do
-      s = +"this is a test"
-      @buffer = Thrift::MemoryBufferTransport.new(s)
-      expect(@buffer.read(4)).to eq("this")
-      s.slice!(-4..-1)
-      expect(@buffer.read(@buffer.available)).to eq(" is a ")
-    end
-
-    it "should always remain open" do
-      expect(@buffer).to be_open
-      @buffer.close
-      expect(@buffer).to be_open
-    end
-
-    it "should respond to peek and available" do
-      @buffer.write "some data"
-      expect(@buffer.peek).to be_truthy
-      expect(@buffer.available).to eq(9)
-      @buffer.read(4)
-      expect(@buffer.peek).to be_truthy
-      expect(@buffer.available).to eq(5)
-      @buffer.read(5)
-      expect(@buffer.peek).to be_falsey
-      expect(@buffer.available).to eq(0)
-    end
-
-    it "should be able to reset the buffer" do
-      @buffer.write "test data"
-      @buffer.reset_buffer("foobar")
-      expect(@buffer.available).to eq(6)
-      expect(@buffer.read(@buffer.available)).to eq("foobar")
-      @buffer.reset_buffer
-      expect(@buffer.available).to eq(0)
-    end
-
-    it "should copy the given string when resetting the buffer" do
-      s = "this is a test"
-      @buffer.reset_buffer(s)
-      expect(@buffer.available).to eq(14)
-      @buffer.read(10)
-      expect(@buffer.available).to eq(4)
-      expect(s).to eq("this is a test")
-    end
-
-    it "should return from read what was given in write" do
-      @buffer.write "test data"
-      expect(@buffer.read(4)).to eq("test")
-      expect(@buffer.read(@buffer.available)).to eq(" data")
-      @buffer.write "foo"
-      @buffer.write " bar"
-      expect(@buffer.read(@buffer.available)).to eq("foo bar")
-    end
-
-    it "should force mutable write buffers into binary in place" do
-      s = "abc \u20AC".encode("UTF-8")
-      @buffer.write(s)
-      expect(s.encoding).to eq(Encoding::BINARY)
-      expect(@buffer.read(@buffer.available)).to eq("abc \u20AC".encode("UTF-8").b)
-    end
-
-    it "should not mutate frozen write buffers while forcing binary encoding" do
-      s = "abc \u20AC".encode("UTF-8").freeze
-      @buffer.write(s)
-      expect(s.encoding).to eq(Encoding::UTF_8)
-      expect(s).to be_frozen
-      expect(@buffer.read(@buffer.available)).to eq("abc \u20AC".encode("UTF-8").b)
-    end
-
-    it "should throw an EOFError when there isn't enough data in the buffer" do
-      @buffer.reset_buffer("")
-      expect{ @buffer.read(1) }.to raise_error(EOFError)
-
-      @buffer.reset_buffer("1234")
-      expect{ @buffer.read(5) }.to raise_error(EOFError)
-    end
-
-    it "should reject negative read_all sizes" do
-      expect { @buffer.read_all(-1) }.to raise_error(Thrift::TransportException, "Negative size") do |e|
-        expect(e.type).to eq(Thrift::TransportException::NEGATIVE_SIZE)
-      end
-    end
-  end
-
-  describe Thrift::IOStreamTransport do
-    before(:each) do
-      @input = double("Input", :closed? => false)
-      @output = double("Output", :closed? => false)
-      @trans = Thrift::IOStreamTransport.new(@input, @output)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@input).to receive(:to_s).and_return("mock_input")
-      expect(@output).to receive(:to_s).and_return("mock_output")
-      expect(@trans.to_s).to eq("iostream(input=mock_input,output=mock_output)")
-    end
-
-    it "should be open as long as both input or output are open" do
-      expect(@trans).to be_open
-      allow(@input).to receive(:closed?).and_return(true)
-      expect(@trans).to be_open
-      allow(@input).to receive(:closed?).and_return(false)
-      allow(@output).to receive(:closed?).and_return(true)
-      expect(@trans).to be_open
-      allow(@input).to receive(:closed?).and_return(true)
-      expect(@trans).not_to be_open
-    end
-
-    it "should pass through read/write to input/output" do
-      expect(@input).to receive(:read).with(17).and_return("+ read")
-      expect(@output).to receive(:write).with("foobar").and_return("+ write")
-      expect(@trans.read(17)).to eq("+ read")
-      expect(@trans.write("foobar")).to eq("+ write")
-    end
-
-    it "should close both input and output when closed" do
-      expect(@input).to receive(:close)
-      expect(@output).to receive(:close)
-      @trans.close
-    end
-  end
-end