poolparty 1.3.15 → 1.4.0

data/vendor/gems/thrift/spec/ThriftSpec.thrift

@@ -1,84 +0,0 @@
-/*
- * 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.
- */
-
-#
-# 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.
-#
-
-namespace rb SpecNamespace
-
-struct Hello {
-  1: string greeting = "hello world"
-}
-
-struct Foo {
-  1: i32 simple = 53,
-  2: string words = "words",
-  3: Hello hello = {'greeting' : "hello, world!"},
-  4: list<i32> ints = [1, 2, 2, 3],
-  5: map<i32, map<string, double>> complex,
-  6: set<i16> shorts = [5, 17, 239],
-  7: optional string opt_string
-}
-
-struct BoolStruct {
-  1: bool yesno = 1
-}
-
-struct SimpleList {
-  1: list<bool> bools,
-  2: list<byte> bytes,
-  3: list<i16> i16s,
-  4: list<i32> i32s,
-  5: list<i64> i64s,
-  6: list<double> doubles,
-  7: list<string> strings,
-  8: list<map<i16, i16>> maps,
-  9: list<list<i16>> lists,
-  10: list<set<i16>> sets,
-  11: list<Hello> hellos
-}
-
-exception Xception {
-  1: string message,
-  2: i32 code = 1
-}
-
-service NonblockingService {
-  Hello greeting(1:bool english)
-  bool block()
-  oneway void unblock(1:i32 n)
-  oneway void shutdown()
-  void sleep(1:double seconds)
-}

data/vendor/gems/thrift/spec/base_protocol_spec.rb

@@ -1,160 +0,0 @@
-#
-# 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 File.dirname(__FILE__) + '/spec_helper'
-
-class ThriftBaseProtocolSpec < Spec::ExampleGroup
-  include Thrift
-
-  before(:each) do
-    @trans = mock("MockTransport")
-    @prot = BaseProtocol.new(@trans)
-  end
-
-  describe BaseProtocol do
-    # most of the methods are stubs, so we can ignore them
-
-    it "should make trans accessible" do
-      @prot.trans.should eql(@trans)
-    end
-
-    it "should write out a field nicely" do
-      @prot.should_receive(:write_field_begin).with('field', 'type', 'fid').ordered
-      @prot.should_receive(:write_type).with('type', 'value').ordered
-      @prot.should_receive(:write_field_end).ordered
-      @prot.write_field('field', 'type', 'fid', 'value')
-    end
-
-    it "should write out the different types" do
-      @prot.should_receive(:write_bool).with('bool').ordered
-      @prot.should_receive(:write_byte).with('byte').ordered
-      @prot.should_receive(:write_double).with('double').ordered
-      @prot.should_receive(:write_i16).with('i16').ordered
-      @prot.should_receive(:write_i32).with('i32').ordered
-      @prot.should_receive(:write_i64).with('i64').ordered
-      @prot.should_receive(:write_string).with('string').ordered
-      struct = mock('Struct')
-      struct.should_receive(:write).with(@prot).ordered
-      @prot.write_type(Types::BOOL, 'bool')
-      @prot.write_type(Types::BYTE, 'byte')
-      @prot.write_type(Types::DOUBLE, 'double')
-      @prot.write_type(Types::I16, 'i16')
-      @prot.write_type(Types::I32, 'i32')
-      @prot.write_type(Types::I64, 'i64')
-      @prot.write_type(Types::STRING, 'string')
-      @prot.write_type(Types::STRUCT, struct)
-      # all other types are not implemented
-      [Types::STOP, Types::VOID, Types::MAP, Types::SET, Types::LIST].each do |type|
-        lambda { @prot.write_type(type, type.to_s) }.should raise_error(NotImplementedError)
-      end
-    end
-
-    it "should read the different types" do
-      @prot.should_receive(:read_bool).ordered
-      @prot.should_receive(:read_byte).ordered
-      @prot.should_receive(:read_i16).ordered
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_i64).ordered
-      @prot.should_receive(:read_double).ordered
-      @prot.should_receive(:read_string).ordered
-      @prot.read_type(Types::BOOL)
-      @prot.read_type(Types::BYTE)
-      @prot.read_type(Types::I16)
-      @prot.read_type(Types::I32)
-      @prot.read_type(Types::I64)
-      @prot.read_type(Types::DOUBLE)
-      @prot.read_type(Types::STRING)
-      # all other types are not implemented
-      [Types::STOP, Types::VOID, Types::MAP, Types::SET, Types::LIST].each do |type|
-        lambda { @prot.read_type(type) }.should raise_error(NotImplementedError)
-      end
-    end
-
-    it "should skip the basic types" do
-      @prot.should_receive(:read_bool).ordered
-      @prot.should_receive(:read_byte).ordered
-      @prot.should_receive(:read_i16).ordered
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_i64).ordered
-      @prot.should_receive(:read_double).ordered
-      @prot.should_receive(:read_string).ordered
-      @prot.skip(Types::BOOL)
-      @prot.skip(Types::BYTE)
-      @prot.skip(Types::I16)
-      @prot.skip(Types::I32)
-      @prot.skip(Types::I64)
-      @prot.skip(Types::DOUBLE)
-      @prot.skip(Types::STRING)
-      @prot.skip(Types::STOP) # should do absolutely nothing
-    end
-
-    it "should skip structs" do
-      real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_struct_begin).ordered
-      @prot.should_receive(:read_field_begin).exactly(4).times.and_return(
-        ['field 1', Types::STRING, 1],
-        ['field 2', Types::I32, 2],
-        ['field 3', Types::MAP, 3],
-        [nil, Types::STOP, 0]
-      )
-      @prot.should_receive(:read_field_end).exactly(3).times
-      @prot.should_receive(:read_string).exactly(3).times
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_map_begin).ordered.and_return([Types::STRING, Types::STRING, 1])
-      # @prot.should_receive(:read_string).exactly(2).times
-      @prot.should_receive(:read_map_end).ordered
-      @prot.should_receive(:read_struct_end).ordered
-      real_skip.call(Types::STRUCT)
-    end
-
-    it "should skip maps" do
-      real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_map_begin).ordered.and_return([Types::STRING, Types::STRUCT, 1])
-      @prot.should_receive(:read_string).ordered
-      @prot.should_receive(:read_struct_begin).ordered.and_return(["some_struct"])
-      @prot.should_receive(:read_field_begin).ordered.and_return([nil, Types::STOP, nil]);
-      @prot.should_receive(:read_struct_end).ordered
-      @prot.should_receive(:read_map_end).ordered
-      real_skip.call(Types::MAP)
-    end
-
-    it "should skip sets" do
-      real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_set_begin).ordered.and_return([Types::I64, 9])
-      @prot.should_receive(:read_i64).ordered.exactly(9).times
-      @prot.should_receive(:read_set_end)
-      real_skip.call(Types::SET)
-    end
-
-    it "should skip lists" do
-      real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_list_begin).ordered.and_return([Types::DOUBLE, 11])
-      @prot.should_receive(:read_double).ordered.exactly(11).times
-      @prot.should_receive(:read_list_end)
-      real_skip.call(Types::LIST)
-    end
-  end
-
-  describe BaseProtocolFactory do
-    it "should raise NotImplementedError" do
-      # returning nil since Protocol is just an abstract class
-      lambda {BaseProtocolFactory.new.get_protocol(mock("MockTransport"))}.should raise_error(NotImplementedError)
-    end
-  end
-end

data/vendor/gems/thrift/spec/base_transport_spec.rb

@@ -1,351 +0,0 @@
-#
-# 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 File.dirname(__FILE__) + '/spec_helper'
-
-class ThriftBaseTransportSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe TransportException do
-    it "should make type accessible" do
-      exc = TransportException.new(TransportException::ALREADY_OPEN, "msg")
-      exc.type.should == TransportException::ALREADY_OPEN
-      exc.message.should == "msg"
-    end
-  end
-
-  describe BaseTransport do
-    it "should read the specified size" do
-      transport = BaseTransport.new
-      transport.should_receive(:read).with(40).ordered.and_return("10 letters")
-      transport.should_receive(:read).with(30).ordered.and_return("fifteen letters")
-      transport.should_receive(:read).with(15).ordered.and_return("more characters")
-      transport.read_all(40).should == "10 lettersfifteen lettersmore characters"
-    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|
-        BaseTransport.method_defined?(sym).should be_true
-      end
-    end
-
-    it "should alias << to write" do
-      BaseTransport.instance_method(:<<).should == BaseTransport.instance_method(:write)
-    end
-  end
-
-  describe BaseServerTransport do
-    it "should stub out its methods" do
-      [:listen, :accept, :close].each do |sym|
-        BaseServerTransport.method_defined?(sym).should be_true
-      end
-    end
-  end
-
-  describe BaseTransportFactory do
-    it "should return the transport it's given" do
-      transport = mock("Transport")
-      BaseTransportFactory.new.get_transport(transport).should eql(transport)
-    end
-  end
-
-  describe BufferedTransport do
-    it "should pass through everything but write/flush/read" do
-      trans = mock("Transport")
-      trans.should_receive(:open?).ordered.and_return("+ open?")
-      trans.should_receive(:open).ordered.and_return("+ open")
-      trans.should_receive(:flush).ordered # from the close
-      trans.should_receive(:close).ordered.and_return("+ close")
-      btrans = BufferedTransport.new(trans)
-      btrans.open?.should == "+ open?"
-      btrans.open.should == "+ open"
-      btrans.close.should == "+ close"
-    end
-    
-    it "should buffer reads in chunks of #{BufferedTransport::DEFAULT_BUFFER}" do
-      trans = mock("Transport")
-      trans.should_receive(:read).with(BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
-      btrans = BufferedTransport.new(trans)
-      btrans.read(6).should == "lorum "
-      btrans.read(6).should == "ipsum "
-      btrans.read(6).should == "dolor "
-      btrans.read(6).should == "emet"
-    end
-
-    it "should buffer writes and send them on flush" do
-      trans = mock("Transport")
-      btrans = BufferedTransport.new(trans)
-      btrans.write("one/")
-      btrans.write("two/")
-      btrans.write("three/")
-      trans.should_receive(:write).with("one/two/three/").ordered
-      trans.should_receive(:flush).ordered
-      btrans.flush
-    end
-
-    it "should only send buffered data once" do
-      trans = mock("Transport")
-      btrans = BufferedTransport.new(trans)
-      btrans.write("one/")
-      btrans.write("two/")
-      btrans.write("three/")
-      trans.should_receive(:write).with("one/two/three/")
-      trans.stub!(:flush)
-      btrans.flush
-      # Nothing to flush with no data
-      btrans.flush
-    end
-    
-    it "should flush on close" do
-      trans = mock("Transport")
-      trans.should_receive(:close)
-      btrans = BufferedTransport.new(trans)
-      btrans.should_receive(:flush)
-      btrans.close
-    end
-    
-    it "should not write to socket if there's no data" do
-      trans = mock("Transport")
-      trans.should_receive(:flush)
-      btrans = BufferedTransport.new(trans)
-      btrans.flush
-    end
-  end
-
-  describe BufferedTransportFactory do
-    it "should wrap the given transport in a BufferedTransport" do
-      trans = mock("Transport")
-      btrans = mock("BufferedTransport")
-      BufferedTransport.should_receive(:new).with(trans).and_return(btrans)
-      BufferedTransportFactory.new.get_transport(trans).should == btrans
-    end
-  end
-
-  describe FramedTransport do
-    before(:each) do
-      @trans = mock("Transport")
-    end
-
-    it "should pass through open?/open/close" do
-      ftrans = FramedTransport.new(@trans)
-      @trans.should_receive(:open?).ordered.and_return("+ open?")
-      @trans.should_receive(:open).ordered.and_return("+ open")
-      @trans.should_receive(:close).ordered.and_return("+ close")
-      ftrans.open?.should == "+ open?"
-      ftrans.open.should == "+ open"
-      ftrans.close.should == "+ close"
-    end
-
-    it "should pass through read when read is turned off" do
-      ftrans = FramedTransport.new(@trans, false, true)
-      @trans.should_receive(:read).with(17).ordered.and_return("+ read")
-      ftrans.read(17).should == "+ read"
-    end
-
-    it "should pass through write/flush when write is turned off" do
-      ftrans = FramedTransport.new(@trans, true, false)
-      @trans.should_receive(:write).with("foo").ordered.and_return("+ write")
-      @trans.should_receive(:flush).ordered.and_return("+ flush")
-      ftrans.write("foo").should == "+ write"
-      ftrans.flush.should == "+ flush"
-    end
-
-    it "should return a full frame if asked for >= the frame's length" do
-      frame = "this is a frame"
-      @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
-      @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      FramedTransport.new(@trans).read(frame.length + 10).should == frame
-    end
-
-    it "should return slices of the frame when asked for < the frame's length" do
-      frame = "this is a frame"
-      @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
-      @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      ftrans = FramedTransport.new(@trans)
-      ftrans.read(4).should == "this"
-      ftrans.read(4).should == " is "
-      ftrans.read(16).should == "a frame"
-    end
-
-    it "should return nothing if asked for <= 0" do
-      FramedTransport.new(@trans).read(-2).should == ""
-    end
-
-    it "should pull a new frame when the first is exhausted" do
-      frame = "this is a frame"
-      frame2 = "yet another frame"
-      @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
-      @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      @trans.should_receive(:read_all).with(frame2.length).and_return(frame2)
-      ftrans = FramedTransport.new(@trans)
-      ftrans.read(4).should == "this"
-      ftrans.read(8).should == " is a fr"
-      ftrans.read(6).should == "ame"
-      ftrans.read(4).should == "yet "
-      ftrans.read(16).should == "another frame"
-    end
-
-    it "should buffer writes" do
-      ftrans = FramedTransport.new(@trans)
-      @trans.should_not_receive(:write)
-      ftrans.write("foo")
-      ftrans.write("bar")
-      ftrans.write("this is a frame")
-    end
-
-    it "should write slices of the buffer" do
-      ftrans = FramedTransport.new(@trans)
-      ftrans.write("foobar", 3)
-      ftrans.write("barfoo", 1)
-      @trans.stub!(:flush)
-      @trans.should_receive(:write).with("\000\000\000\004foob")
-      ftrans.flush
-    end
-
-    it "should flush frames with a 4-byte header" do
-      ftrans = FramedTransport.new(@trans)
-      @trans.should_receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
-      @trans.should_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 = FramedTransport.new(@trans)
-      @trans.should_receive(:write).with("\000\000\000\007foo/bar")
-      @trans.stub!(:flush)
-      ftrans.write("foo")
-      ftrans.write("/bar")
-      ftrans.flush
-      @trans.should_receive(:write).with("\000\000\000\000")
-      ftrans.flush
-    end
-  end
-
-  describe FramedTransportFactory do
-    it "should wrap the given transport in a FramedTransport" do
-      trans = mock("Transport")
-      FramedTransport.should_receive(:new).with(trans)
-      FramedTransportFactory.new.get_transport(trans)
-    end
-  end
-
-  describe MemoryBufferTransport do
-    before(:each) do
-      @buffer = MemoryBufferTransport.new
-    end
-
-    it "should accept a buffer on input and use it directly" do
-      s = "this is a test"
-      @buffer = MemoryBufferTransport.new(s)
-      @buffer.read(4).should == "this"
-      s.slice!(-4..-1)
-      @buffer.read(@buffer.available).should == " is a "
-    end
-
-    it "should always remain open" do
-      @buffer.should be_open
-      @buffer.close
-      @buffer.should be_open
-    end
-
-    it "should respond to peek and available" do
-      @buffer.write "some data"
-      @buffer.peek.should be_true
-      @buffer.available.should == 9
-      @buffer.read(4)
-      @buffer.peek.should be_true
-      @buffer.available.should == 5
-      @buffer.read(5)
-      @buffer.peek.should be_false
-      @buffer.available.should == 0
-    end
-
-    it "should be able to reset the buffer" do
-      @buffer.write "test data"
-      @buffer.reset_buffer("foobar")
-      @buffer.available.should == 6
-      @buffer.read(@buffer.available).should == "foobar"
-      @buffer.reset_buffer
-      @buffer.available.should == 0
-    end
-
-    it "should copy the given string when resetting the buffer" do
-      s = "this is a test"
-      @buffer.reset_buffer(s)
-      @buffer.available.should == 14
-      @buffer.read(10)
-      @buffer.available.should == 4
-      s.should == "this is a test"
-    end
-
-    it "should return from read what was given in write" do
-      @buffer.write "test data"
-      @buffer.read(4).should == "test"
-      @buffer.read(@buffer.available).should == " data"
-      @buffer.write "foo"
-      @buffer.write " bar"
-      @buffer.read(@buffer.available).should == "foo bar"
-    end
-    
-    it "should throw an EOFError when there isn't enough data in the buffer" do
-      @buffer.reset_buffer("")
-      lambda{@buffer.read(1)}.should raise_error(EOFError)
-
-      @buffer.reset_buffer("1234")
-      lambda{@buffer.read(5)}.should raise_error(EOFError)
-    end
-  end
-
-  describe IOStreamTransport do
-    before(:each) do
-      @input = mock("Input", :closed? => false)
-      @output = mock("Output", :closed? => false)
-      @trans = IOStreamTransport.new(@input, @output)
-    end
-
-    it "should be open as long as both input or output are open" do
-      @trans.should be_open
-      @input.stub!(:closed?).and_return(true)
-      @trans.should be_open
-      @input.stub!(:closed?).and_return(false)
-      @output.stub!(:closed?).and_return(true)
-      @trans.should be_open
-      @input.stub!(:closed?).and_return(true)
-      @trans.should_not be_open
-    end
-
-    it "should pass through read/write to input/output" do
-      @input.should_receive(:read).with(17).and_return("+ read")
-      @output.should_receive(:write).with("foobar").and_return("+ write")
-      @trans.read(17).should == "+ read"
-      @trans.write("foobar").should == "+ write"
-    end
-
-    it "should close both input and output when closed" do
-      @input.should_receive(:close)
-      @output.should_receive(:close)
-      @trans.close
-    end
-  end
-end

data/vendor/gems/thrift/spec/binary_protocol_accelerated_spec.rb

@@ -1,41 +0,0 @@
-#
-# 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 File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/binary_protocol_spec_shared'
-
-class ThriftBinaryProtocolAcceleratedSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe Thrift::BinaryProtocolAccelerated do
-    # since BinaryProtocolAccelerated should be directly equivalent to 
-    # BinaryProtocol, we don't need any custom specs!
-    it_should_behave_like 'a binary protocol'
-
-    def protocol_class
-      BinaryProtocolAccelerated
-    end
-  end
-
-  describe BinaryProtocolAcceleratedFactory do
-    it "should create a BinaryProtocolAccelerated" do
-      BinaryProtocolAcceleratedFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(BinaryProtocolAccelerated)
-    end
-  end
-end

data/vendor/gems/thrift/spec/binary_protocol_spec.rb

@@ -1,63 +0,0 @@
-#
-# 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 File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/binary_protocol_spec_shared'
-
-class ThriftBinaryProtocolSpec < Spec::ExampleGroup
-  include Thrift
-
-  describe BinaryProtocol do
-    it_should_behave_like 'a binary protocol'
-
-    def protocol_class
-      BinaryProtocol
-    end
-
-    it "should read a message header" do
-      @trans.should_receive(:read_all).exactly(2).times.and_return(
-        [protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::REPLY].pack('N'),
-        [42].pack('N')
-      )      
-      @prot.should_receive(:read_string).and_return('testMessage')
-      @prot.read_message_begin.should == ['testMessage', Thrift::MessageTypes::REPLY, 42]
-    end
-
-    it "should raise an exception if the message header has the wrong version" do
-      @prot.should_receive(:read_i32).and_return(-1)
-      lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'Missing version identifier') do |e|
-        e.type == Thrift::ProtocolException::BAD_VERSION
-      end
-    end
-
-    it "should raise an exception if the message header does not exist and strict_read is enabled" do
-      @prot.should_receive(:read_i32).and_return(42)
-      @prot.should_receive(:strict_read).and_return(true)
-      lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'No version identifier, old protocol client?') do |e|        
-        e.type == Thrift::ProtocolException::BAD_VERSION
-      end
-    end
-  end
-
-  describe BinaryProtocolFactory do
-    it "should create a BinaryProtocol" do
-      BinaryProtocolFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(BinaryProtocol)
-    end
-  end
-end