amq-protocol 1.9.2 → 2.0.0

data/spec/amq/protocol/confirm_spec.rb

@@ -12,7 +12,7 @@ module AMQ
             Select.decode("\x01")
           end
           
-          its(:nowait) { should be_true }
+          its(:nowait) { should be_truthy }
         end
         
         describe '.encode' do
@@ -20,8 +20,8 @@ module AMQ
             channel = 1
             nowait = true
             method_frame = Select.encode(channel, nowait)
-            method_frame.payload.should == "\x00U\x00\n\x01"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00U\x00\n\x01")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -34,8 +34,8 @@ module AMQ
           it 'encodes the parameters into a MethodFrame' do
             channel = 1
             method_frame = SelectOk.encode(channel)
-            method_frame.payload.should == "\000U\000\v"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\000U\000\v")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end

data/spec/amq/protocol/connection_spec.rb

@@ -29,13 +29,13 @@ module AMQ
             locale = 'en_GB'
             method_frame = StartOk.encode(client_properties, mechanism, response, locale)
             # the order of the table parts isn't deterministic in Ruby 1.8
-            method_frame.payload[0, 8].should == "\x00\n\x00\v\x00\x00\x00x"
-            method_frame.payload.should include("\bplatformS\x00\x00\x00\nRuby 1.9.2")
-            method_frame.payload.should include("\aproductS\x00\x00\x00\nAMQ Client")
-            method_frame.payload.should include("\vinformationS\x00\x00\x00&http://github.com/ruby-amqp/amq-client")
-            method_frame.payload.should include("\aversionS\x00\x00\x00\x050.2.0")
-            method_frame.payload[-28, 28].should == "\x05PLAIN\x00\x00\x00\f\x00guest\x00guest\x05en_GB"
-            method_frame.payload.length.should == 156
+            expect(method_frame.payload[0, 8]).to eq("\x00\n\x00\v\x00\x00\x00x")
+            expect(method_frame.payload).to include("\bplatformS\x00\x00\x00\nRuby 1.9.2")
+            expect(method_frame.payload).to include("\aproductS\x00\x00\x00\nAMQ Client")
+            expect(method_frame.payload).to include("\vinformationS\x00\x00\x00&http://github.com/ruby-amqp/amq-client")
+            expect(method_frame.payload).to include("\aversionS\x00\x00\x00\x050.2.0")
+            expect(method_frame.payload[-28, 28]).to eq("\x05PLAIN\x00\x00\x00\f\x00guest\x00guest\x05en_GB")
+            expect(method_frame.payload.length).to eq(156)
           end
         end
       end
@@ -46,7 +46,7 @@ module AMQ
             Secure.decode("\x00\x00\x00\x03foo")
           end
           
-          its(:challenge) { should == 'foo' }
+          its(:challenge) { should eq('foo') }
         end
       end
     
@@ -55,7 +55,7 @@ module AMQ
           it 'encodes the parameters as a MethodFrame' do
             response = 'bar'
             method_frame = SecureOk.encode(response)
-            method_frame.payload.should == "\x00\x0a\x00\x15\x00\x00\x00\x03bar"
+            expect(method_frame.payload).to eq("\x00\x0a\x00\x15\x00\x00\x00\x03bar")
           end
         end
       end
@@ -66,9 +66,9 @@ module AMQ
             Tune.decode("\x00\x00\x00\x02\x00\x00\x00\x00")
           end
 
-          its(:channel_max) { should == 0 }
-          its(:frame_max) { should == 131072 }
-          its(:heartbeat) { should == 0}
+          its(:channel_max) { should eq(0) }
+          its(:frame_max) { should eq(131072) }
+          its(:heartbeat) { should eq(0) }
         end
       end
 
@@ -79,7 +79,7 @@ module AMQ
             frame_max = 65536
             heartbeat = 1
             method_frame = TuneOk.encode(channel_max, frame_max, heartbeat)
-            method_frame.payload.should == "\x00\n\x00\x1F\x00\x00\x00\x01\x00\x00\x00\x01"
+            expect(method_frame.payload).to eq("\x00\n\x00\x1F\x00\x00\x00\x01\x00\x00\x00\x01")
           end
         end
       end
@@ -89,7 +89,7 @@ module AMQ
           it 'encodes the parameters into a MethodFrame' do
             vhost = '/test'
             method_frame = Open.encode(vhost)
-            method_frame.payload.should == "\x00\n\x00(\x05/test\x00\x00"
+            expect(method_frame.payload).to eq("\x00\n\x00(\x05/test\x00\x00")
           end
         end
       end
@@ -100,7 +100,7 @@ module AMQ
             OpenOk.decode("\x00")
           end
           
-          its(:known_hosts) { should == '' }
+          its(:known_hosts) { should eq('') }
         end
       end
       
@@ -111,10 +111,10 @@ module AMQ
               Close.decode("\x00\xc8\x07KTHXBAI\x00\x05\x00\x06")
             end
           
-            its(:reply_code) { should == 200 }
-            its(:reply_text) { should == 'KTHXBAI' }
-            its(:class_id) { should == 5 }
-            its(:method_id) { should == 6 }
+            its(:reply_code) { should eq(200) }
+            its(:reply_text) { should eq('KTHXBAI') }
+            its(:class_id) { should eq(5) }
+            its(:method_id) { should eq(6) }
           end
           
           context 'with an error code' do
@@ -131,7 +131,7 @@ module AMQ
             class_id = 0
             method_id = 0
             method_frame = Close.encode(reply_code, reply_text, class_id, method_id)
-            method_frame.payload.should == "\x00\x0a\x002\x02\x1c\x0fNOT_IMPLEMENTED\x00\x00\x00\x00"
+            expect(method_frame.payload).to eq("\x00\x0a\x002\x02\x1c\x0fNOT_IMPLEMENTED\x00\x00\x00\x00")
           end
         end
       end
@@ -140,7 +140,7 @@ module AMQ
         describe '.encode' do
           it 'encodes a MethodFrame' do
             method_frame = CloseOk.encode
-            method_frame.payload.should == "\x00\n\x003"
+            expect(method_frame.payload).to eq("\x00\n\x003")
           end
         end
       end

data/spec/amq/protocol/constants_spec.rb

@@ -2,13 +2,13 @@
 
 require File.expand_path('../../../spec_helper', __FILE__)
 
-describe "(Some)", AMQ::Protocol, "constants" do
+describe "(Some) AMQ::Protocol constants" do
   it "include regular port" do
-    AMQ::Protocol::DEFAULT_PORT.should == 5672
+    expect(AMQ::Protocol::DEFAULT_PORT).to eq(5672)
   end
 
   it "provides TLS/SSL port" do
-    AMQ::Protocol::TLS_PORT.should == 5671
-    AMQ::Protocol::SSL_PORT.should == 5671
+    expect(AMQ::Protocol::TLS_PORT).to eq(5671)
+    expect(AMQ::Protocol::SSL_PORT).to eq(5671)
   end
 end

data/spec/amq/protocol/exchange_spec.rb

@@ -19,8 +19,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Declare.encode(channel, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
-            method_frame.payload.should == "\x00(\x00\n\x00\x00\x1Famqclient.adapters.em.exchange1\x06fanout\x00\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00(\x00\n\x00\x00\x1Famqclient.adapters.em.exchange1\x06fanout\x00\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -38,8 +38,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Declare.encode(channel, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
-            method_frame.payload.should == "\x00(\x00\n\x00\x00\texchange2\x06fanout\x00\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00(\x00\n\x00\x00\texchange2\x06fanout\x00\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -52,8 +52,8 @@ module AMQ
             if_unused = false
             nowait = false
             method_frame = Delete.encode(channel, exchange, if_unused, nowait)
-            method_frame.payload.should == "\x00(\x00\x14\x00\x00\x1Eamqclient.adapters.em.exchange\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00(\x00\x14\x00\x00\x1Eamqclient.adapters.em.exchange\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -73,8 +73,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Bind.encode(channel, destination, source, routing_key, nowait, arguments)
-            method_frame.payload.should == "\x00(\x00\x1E\x00\x00\x03foo\x03bar\x03xyz\x00\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00(\x00\x1E\x00\x00\x03foo\x03bar\x03xyz\x00\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -94,8 +94,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Unbind.encode(channel, destination, source, routing_key, nowait, arguments)
-            method_frame.payload.should == "\x00(\x00(\x00\x00\x03foo\x03bar\x03xyz\x00\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x00(\x00(\x00\x00\x03foo\x03bar\x03xyz\x00\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end

data/spec/amq/protocol/frame_spec.rb

@@ -1,4 +1,4 @@
-# encoding: binary
+# encoding: utf-8
 
 require File.expand_path('../../../spec_helper', __FILE__)
 
@@ -8,7 +8,7 @@ module AMQ
     describe Frame do
       describe ".encode" do
         it "should raise FrameTypeError if type isn't one of: [:method, :header, :body, :heartbeat]" do
-          lambda { Frame.encode(nil, "", 0) }.should raise_error(FrameTypeError)
+          expect { Frame.encode(nil, "", 0) }.to raise_error(FrameTypeError)
         end
 
         it "should raise FrameTypeError if type isn't valid (when type is a symbol)" do
@@ -20,35 +20,35 @@ module AMQ
         end
 
         it "should raise RuntimeError if channel isn't 0 or an integer in range 1..65535" do
-          lambda { Frame.encode(:method, "", -1) }.should raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
-          lambda { Frame.encode(:method, "", 65536) }.should raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
-          lambda { Frame.encode(:method, "", 65535) }.should_not raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
-          lambda { Frame.encode(:method, "", 0) }.should_not raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
-          lambda { Frame.encode(:method, "", 1) }.should_not raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
+          expect { Frame.encode(:method, "", -1) }.to raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
+          expect { Frame.encode(:method, "", 65536) }.to raise_error(RuntimeError, /^Channel has to be 0 or an integer in range 1\.\.65535/)
+          expect { Frame.encode(:method, "", 65535) }.not_to raise_error
+          expect { Frame.encode(:method, "", 0) }.not_to raise_error
+          expect { Frame.encode(:method, "", 1) }.not_to raise_error
         end
 
         it "should raise RuntimeError if payload is nil" do
-          lambda { Frame.encode(:method, nil, 0) }.should raise_error(RuntimeError, "Payload can't be nil")
+          expect { Frame.encode(:method, nil, 0) }.to raise_error(RuntimeError, "Payload can't be nil")
         end
 
         it "should encode type" do
-          Frame.encode(:body, "", 0).unpack("c").first.should eql(3)
+          expect(Frame.encode(:body, "", 0).unpack("c").first).to eql(3)
         end
 
         it "should encode channel" do
-          Frame.encode(:body, "", 12).unpack("cn").last.should eql(12)
+          expect(Frame.encode(:body, "", 12).unpack("cn").last).to eql(12)
         end
 
         it "should encode size" do
-          Frame.encode(:body, "test", 12).unpack("cnN").last.should eql(4)
+          expect(Frame.encode(:body, "test", 12).unpack("cnN").last).to eql(4)
         end
 
         it "should include payload" do
-          Frame.encode(:body, "test", 12)[7..-2].should eql("test")
+          expect(Frame.encode(:body, "test", 12)[7..-2]).to eql("test")
         end
 
         it "should include final octet" do
-          Frame.encode(:body, "test", 12).should =~ /\xCE$/
+          expect(Frame.encode(:body, "test", 12).each_byte.to_a.last).to eq("CE".hex)
         end
 
         it "should encode unicode strings" do
@@ -76,20 +76,20 @@ module AMQ
         subject { HeaderFrame.new("\x00<\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x98\x00\x18application/octet-stream\x02\x00", nil) }
 
         it "should decode body_size from payload" do
-          subject.body_size.should == 10
+          expect(subject.body_size).to eq(10)
         end
 
         it "should decode klass_id from payload" do
-          subject.klass_id.should == 60
+          expect(subject.klass_id).to eq(60)
         end
 
         it "should decode weight from payload" do
-          subject.weight.should == 0
+          expect(subject.weight).to eq(0)
         end
 
         it "should decode properties from payload" do
-          subject.properties[:delivery_mode].should == 2
-          subject.properties[:priority].should == 0
+          expect(subject.properties[:delivery_mode]).to eq(2)
+          expect(subject.properties[:priority]).to eq(0)
         end
       end
     end

data/spec/amq/protocol/method_spec.rb

@@ -10,8 +10,8 @@ module AMQ
         it 'splits user defined headers into properties and headers' do
           input = {:delivery_mode => 2, :content_type => 'application/octet-stream', :foo => 'bar'}
           properties, headers = Method.split_headers(input)
-          properties.should == {:delivery_mode => 2, :content_type => 'application/octet-stream'}
-          headers.should == {:foo => 'bar'}
+          expect(properties).to eq({:delivery_mode => 2, :content_type => 'application/octet-stream'})
+          expect(headers).to eq({:foo => 'bar'})
         end
       end
       
@@ -19,9 +19,9 @@ module AMQ
         context 'when the body fits in a single frame' do
           it 'encodes a body into a BodyFrame' do
             body_frames = Method.encode_body('Hello world', 1, 131072)
-            body_frames.first.payload.should == 'Hello world'
-            body_frames.first.channel.should == 1
-            body_frames.should have(1).item
+            expect(body_frames.first.payload).to eq('Hello world')
+            expect(body_frames.first.channel).to eq(1)
+            expect(body_frames.size).to eq(1)
           end
         end
 
@@ -31,15 +31,15 @@ module AMQ
             frame_size = 100
             expected_payload_size = 92
             body_frames = Method.encode_body(lipsum, 1, frame_size)
-            body_frames.map(&:payload).should == lipsum.split('').each_slice(expected_payload_size).map(&:join)
+            expect(body_frames.map(&:payload)).to eq(lipsum.split('').each_slice(expected_payload_size).map(&:join))
           end
         end
 
         context 'when the body fits perfectly in a single frame' do
           it 'encodes a body into a single BodyFrame' do
             body_frames = Method.encode_body('*' * 131064, 1, 131072)
-            body_frames.first.payload.should == '*' * 131064
-            body_frames.should have(1).item
+            expect(body_frames.first.payload).to eq('*' * 131064)
+            expect(body_frames.size).to eq(1)
           end
         end
       end

data/spec/amq/protocol/queue_spec.rb

@@ -18,8 +18,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Declare.encode(channel, queue, passive, durable, exclusive, auto_delete, nowait, arguments)
-            method_frame.payload.should == "\x002\x00\n\x00\x00\vhello.world\x0E\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x002\x00\n\x00\x00\vhello.world\x0E\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -30,9 +30,9 @@ module AMQ
             DeclareOk.decode(" amq.gen-KduGSqQrpeUo1otnU0TWSA==\x00\x00\x00\x00\x00\x00\x00\x00")
           end
           
-          its(:queue) { should == 'amq.gen-KduGSqQrpeUo1otnU0TWSA==' }
-          its(:message_count) { should == 0 }
-          its(:consumer_count) { should == 0 }
+          its(:queue) { should eq('amq.gen-KduGSqQrpeUo1otnU0TWSA==') }
+          its(:message_count) { should eq(0) }
+          its(:consumer_count) { should eq(0) }
         end
       end
 
@@ -46,8 +46,8 @@ module AMQ
             nowait = false
             arguments = nil
             method_frame = Bind.encode(channel, queue, exchange, routing_key, nowait, arguments)
-            method_frame.payload.should == "\x002\x00\x14\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x002\x00\x14\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -64,8 +64,8 @@ module AMQ
             queue = 'hello.world'
             nowait = false
             method_frame = Purge.encode(channel, queue, nowait)
-            method_frame.payload.should == "\x002\x00\x1E\x00\x00\vhello.world\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x002\x00\x1E\x00\x00\vhello.world\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -76,7 +76,7 @@ module AMQ
             PurgeOk.decode("\x00\x00\x00\x02")
           end
           
-          its(:message_count) { should == 2 }
+          its(:message_count) { should eq(2) }
         end
       end
 
@@ -89,8 +89,8 @@ module AMQ
             if_empty = false
             nowait = false
             method_frame = Delete.encode(channel, queue, if_unused, if_empty, nowait)
-            method_frame.payload.should == "\x002\x00(\x00\x00\vhello.world\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x002\x00(\x00\x00\vhello.world\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end
@@ -101,7 +101,7 @@ module AMQ
             DeleteOk.decode("\x00\x00\x00\x02")
           end
           
-          its(:message_count) { should == 2 }
+          its(:message_count) { should eq(2) }
         end
       end
 
@@ -114,8 +114,8 @@ module AMQ
             routing_key = 'xyz'
             arguments = nil
             method_frame = Unbind.encode(channel, queue, exchange, routing_key, arguments)
-            method_frame.payload.should == "\x002\x002\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00"
-            method_frame.channel.should == 1
+            expect(method_frame.payload).to eq("\x002\x002\x00\x00\vhello.world\afoo.bar\x03xyz\x00\x00\x00\x00")
+            expect(method_frame.channel).to eq(1)
           end
         end
       end

data/spec/amq/protocol/table_spec.rb

@@ -1,4 +1,4 @@
-# encoding: binary
+# -*- coding: utf-8 -*-
 
 require File.expand_path('../../../spec_helper', __FILE__)
 require 'bigdecimal'
@@ -11,63 +11,49 @@ module AMQ
       timestamp    = Time.utc(2010, 12, 31, 23, 58, 59)
       bigdecimal_1 = BigDecimal.new("1.0")
       bigdecimal_2 = BigDecimal.new("5E-3")
-      bigdecimal_3 = BigDecimal.new("-0.01")
-
-
-      DATA = if one_point_eight?
-        {
-          {}                       => "\000\000\000\000",
-          {"test" => 1}            => "\000\000\000\n\004testI\000\000\000\001",
-          {"float" => 1.87}        => "\000\000\000\017\005floatd?\375\353\205\036\270Q\354",
-          {"test" => "string"}     => "\000\000\000\020\004testS\000\000\000\006string",
-          {"test" => {}}           => "\000\000\000\n\004testF\000\000\000\000",
-          {"test" => bigdecimal_1} => "\000\000\000\v\004testD\000\000\000\000\001",
-          {"test" => bigdecimal_2} => "\000\000\000\v\004testD\003\000\000\000\005",
-          {"test" => timestamp}    => "\000\000\000\016\004testT\000\000\000\000M\036nC"
-        }
-      else
-        {
+
+
+      DATA = {
           {}                       => "\x00\x00\x00\x00",
-          {"test" => 1}            => "\x00\x00\x00\n\x04testI\x00\x00\x00\x01",
+          {"test" => 1}            => "\x00\x00\x00\x0E\x04testl\x00\x00\x00\x00\x00\x00\x00\x01",
           {"float" => 1.92}        => "\x00\x00\x00\x0F\x05floatd?\xFE\xB8Q\xEB\x85\x1E\xB8",
           {"test" => "string"}     => "\x00\x00\x00\x10\x04testS\x00\x00\x00\x06string",
           {"test" => {}}           => "\x00\x00\x00\n\x04testF\x00\x00\x00\x00",
           {"test" => bigdecimal_1} => "\x00\x00\x00\v\x04testD\x00\x00\x00\x00\x01",
           {"test" => bigdecimal_2} => "\x00\x00\x00\v\x04testD\x03\x00\x00\x00\x05",
           {"test" => timestamp}    => "\x00\x00\x00\x0e\x04testT\x00\x00\x00\x00M\x1enC"
-        }
-      end
+      }
 
       describe ".encode" do
         it "should return \"\x00\x00\x00\x00\" for nil" do
-          encoded_value = if one_point_eight?
-                            "\000\000\000\000"
-                          else
-                            "\x00\x00\x00\x00"
-                          end
+          encoded_value = "\x00\x00\x00\x00"
 
-          Table.encode(nil).should eql(encoded_value)
+          expect(Table.encode(nil)).to eql(encoded_value)
         end
 
         it "should serialize { :test => true }" do
-          Table.encode(:test => true).should eql("\x00\x00\x00\a\x04testt\x01")
+          expect(Table.encode(:test => true)).
+            to eql("\x00\x00\x00\a\x04testt\x01".force_encoding(Encoding::ASCII_8BIT))
         end
 
         it "should serialize { :test => false }" do
-          Table.encode(:test => false).should eql("\x00\x00\x00\a\x04testt\x00")
+          expect(Table.encode(:test => false)).
+            to eql("\x00\x00\x00\a\x04testt\x00".force_encoding(Encoding::ASCII_8BIT))
         end
 
         it "should serialize { :coordinates => { :latitude  => 59.35 } }" do
-          Table.encode(:coordinates => { :latitude  => 59.35 }).should eql("\x00\x00\x00#\vcoordinatesF\x00\x00\x00\x12\blatituded@M\xAC\xCC\xCC\xCC\xCC\xCD")
+          expect(Table.encode(:coordinates => { :latitude  => 59.35 })).
+            to eql("\x00\x00\x00#\vcoordinatesF\x00\x00\x00\x12\blatituded@M\xAC\xCC\xCC\xCC\xCC\xCD".force_encoding(Encoding::ASCII_8BIT))
         end
 
         it "should serialize { :coordinates => { :longitude => 18.066667 } }" do
-          Table.encode(:coordinates => { :longitude => 18.066667 }).should eql("\x00\x00\x00$\vcoordinatesF\x00\x00\x00\x13\tlongituded@2\x11\x11\x16\xA8\xB8\xF1")
+          expect(Table.encode(:coordinates => { :longitude => 18.066667 })).
+            to eql("\x00\x00\x00$\vcoordinatesF\x00\x00\x00\x13\tlongituded@2\x11\x11\x16\xA8\xB8\xF1".force_encoding(Encoding::ASCII_8BIT))
         end
 
         DATA.each do |data, encoded|
           it "should return #{encoded.inspect} for #{data.inspect}" do
-            Table.encode(data).should eql(encoded)
+            expect(Table.encode(data)).to eql(encoded.force_encoding(Encoding::ASCII_8BIT))
           end
         end
       end
@@ -75,114 +61,121 @@ module AMQ
       describe ".decode" do
         DATA.each do |data, encoded|
           it "should return #{data.inspect} for #{encoded.inspect}" do
-            Table.decode(encoded).should eql(data)
+            expect(Table.decode(encoded)).to eql(data)
           end
 
           it "is capable of decoding what it encodes" do
-            Table.decode(Table.encode(data)).should == data
+            expect(Table.decode(Table.encode(data))).to eq(data)
           end
         end # DATA.each
 
 
         it "is capable of decoding boolean table values" do
           input1   = { "boolval" => true }
-          Table.decode(Table.encode(input1)).should == input1
+          expect(Table.decode(Table.encode(input1))).to eq(input1)
 
 
           input2   = { "boolval" => false }
-          Table.decode(Table.encode(input2)).should == input2
+          expect(Table.decode(Table.encode(input2))).to eq(input2)
         end
 
 
         it "is capable of decoding nil table values" do
           input   = { "nilval" => nil }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
         it "is capable of decoding nil table in nested hash/map values" do
           input   = { "hash" => {"nil" => nil} }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
         it "is capable of decoding string table values" do
           input   = { "stringvalue" => "string" }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
         it "is capable of decoding string table values with UTF-8 characters" do
-          input   = { "строка" => "значение" }
-          Table.decode(Table.encode(input)).should == input
+          input   = {
+            "строка".force_encoding(::Encoding::ASCII_8BIT) => "значение".force_encoding(::Encoding::ASCII_8BIT)
+          }
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
         it "is capable of decoding integer table values" do
           input   = { "intvalue" => 10 }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
+        it "is capable of decoding signed integer table values" do
+          input   = { "intvalue" => -10 }
+          expect(Table.decode(Table.encode(input))).to eq(input)
+        end
+
 
         it "is capable of decoding long table values" do
           input   = { "longvalue" => 912598613 }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
 
         it "is capable of decoding float table values" do
           input   = { "floatvalue" => 100.0 }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
 
         it "is capable of decoding time table values" do
           input   = { "intvalue" => Time.parse("2011-07-14 01:17:46 +0400") }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
 
         it "is capable of decoding empty hash table values" do
           input   = { "hashvalue" => Hash.new }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
 
         it "is capable of decoding empty array table values" do
           input   = { "arrayvalue" => Array.new }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
         it "is capable of decoding single string value array table values" do
           input   = { "arrayvalue" => ["amq-protocol"] }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
 
         it "is capable of decoding simple nested hash table values" do
           input   = { "hashvalue" => { "a" => "b" } }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
 
         it "is capable of decoding nil table values" do
           input   = { "nil" => nil }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
         it 'is capable of decoding 8bit signed integers' do
           output = TableValueDecoder.decode_byte("\xC0",0).first
-          output.should == 192
+          expect(output).to eq(192)
         end
 
         it 'is capable of decoding 16bit signed integers' do
           output = TableValueDecoder.decode_short("\x06\x8D", 0).first
-          output.should == 1677
+          expect(output).to eq(1677)
         end
 
         it "is capable of decoding tables" do
@@ -195,7 +188,7 @@ module AMQ
             "longval"      => 912598613,
             "hashval"      => { "protocol" => "AMQP091", "true" => true, "false" => false, "nil" => nil }
           }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
@@ -210,7 +203,7 @@ module AMQ
                 "rev"   => 1.0,
                 "spec"  => {
                   "url"  => "http://bit.ly/hw2ELX",
-                  "utf8" => "à bientôt"
+                  "utf8" => "à bientôt".force_encoding(::Encoding::ASCII_8BIT)
                 }
               },
               "true"     => true,
@@ -218,7 +211,7 @@ module AMQ
               "nil"      => nil
             }
           }
-          Table.decode(Table.encode(input)).should == input
+          expect(Table.decode(Table.encode(input))).to eq(input)
         end
 
 
@@ -228,7 +221,7 @@ module AMQ
             "arrayval1" => [198, 3, 77, 8.0, ["inner", "array", { "oh" => "well", "it" => "should work", "3" => 6 }], "two", { "a" => "value", "is" => nil }],
             "arrayval2" => [198, 3, 77, "two", { "a" => "value", "is" => nil }, 8.0, ["inner", "array", { "oh" => "well", "it" => "should work", "3" => 6 }]]
           }
-          Table.decode(Table.encode(input1)).should == input1
+          expect(Table.decode(Table.encode(input1))).to eq(input1)
 
           now = Time.now
           input2 = {
@@ -244,10 +237,10 @@ module AMQ
                        "ary_field"    => ["one", 2.0, 3]
                      }
 
-          Table.decode(Table.encode(input2)).should == input2
+          expect(Table.decode(Table.encode(input2))).to eq(input2)
 
           input3 = { "timely" => { "now" => now } }
-          Table.decode(Table.encode(input3))["timely"]["now"].to_i.should == now.to_i
+          expect(Table.decode(Table.encode(input3))["timely"]["now"].to_i).to eq(now.to_i)
         end
 
       end # describe