trema 0.3.3 → 0.3.4

data/spec/trema/echo-request_spec.rb

@@ -29,7 +29,7 @@ shared_examples_for "echo reply message" do
     }.run( EchoReplyController ) {
       controller( "EchoReplyController" ).send_message( 0xabc, subject )
       sleep 2 # FIXME: wait to send_message
-      IO.read( File.join( Trema.log, "openflowd.echo.log" ) ).should include( "OFPT_ECHO_REPLY" )
+      expect( IO.read( File.join( Trema.log, "openflowd.echo.log" ) ) ).to include( "OFPT_ECHO_REPLY" )
     }
   end
 end

data/spec/trema/enqueue_spec.rb

@@ -32,7 +32,7 @@ end
 
 describe Enqueue, ".new( :port_number => number, :queue_id => 1 )" do
   subject { Enqueue.new :port_number => port_number, :queue_id => 1 }
-  it_validates "option range", :port_number, 0..( 2 ** 16 - 1 )
+  it_validates "option is within range", :port_number, 0..( 2 ** 16 - 1 )
 
   context "when :port_number == 1" do
     let( :port_number ) { 1 }
@@ -43,7 +43,7 @@ end
 
 describe Enqueue, ".new( :port_number => 1, :queue_id => number )" do
   subject { Enqueue.new :port_number => 1, :queue_id => queue_id }
-  it_validates "option range", :queue_id, 0..( 2 ** 32 - 1 )
+  it_validates "option is within range", :queue_id, 0..( 2 ** 32 - 1 )
 
   context "when :queue_id == 256" do
     let( :queue_id ) { 256 }
@@ -61,8 +61,8 @@ describe Enqueue, ".new( VALID OPTIONS )" do
       }.run( FlowModAddController ) {
         controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => Enqueue.new( :port_number => 1, :queue_id => 123 ) )
         sleep 2 # FIXME: wait to send_flow_mod
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /enqueue:1q123/ )
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[0].actions ).to match( /enqueue:1q123/ )
       }
     end
   end

data/spec/trema/features-reply_spec.rb

@@ -47,7 +47,7 @@ module Trema
     its( :n_tables ) { should == 2 }
     its( :capabilities ) { should == 135 }
     its( :actions ) { should == 2047 }
-    its( :ports ) { subject.size.should == 3 }
+    its( "ports.size" ) { should == 3 }
   end
 
 

data/spec/trema/features-request_spec.rb

@@ -29,7 +29,7 @@ shared_examples_for "features request message" do
     }.run( FeaturesRequestController ) {
       controller( "FeaturesRequestController" ).send_message( 0xabc, subject )
       sleep 2 # FIXME: wait to send_message
-      IO.read( File.join( Trema.log, "openflowd.features-request.log" ) ).should include( "OFPT_FEATURES_REQUEST" )
+      expect( IO.read( File.join( Trema.log, "openflowd.features-request.log" ) ) ).to include( "OFPT_FEATURES_REQUEST" )
     }
   end
 end

data/spec/trema/flow-removed_spec.rb

@@ -105,25 +105,25 @@ describe Trema::FlowRemoved, ".new( VALID OPTIONS )" do
         vswitch { datapath_id 0xabc }
       }.run( FlowRemovedController ) {
         controller( "FlowRemovedController" ).should_receive( :flow_removed ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.match.in_port.should == 1
-          message.match.dl_src.to_s.should == "00:00:00:00:00:01"
-          message.match.dl_dst.to_s.should == "00:00:00:00:00:02"
-          message.match.dl_type.should == 0x800
-          message.match.dl_vlan.should == 65535
-          message.match.dl_vlan_pcp.should == 0
-          message.match.nw_tos.should == 0
-          message.match.nw_proto.should == 17
-          Trema::IP.new( message.match.nw_src ).to_s.should == "192.168.0.1"
-          Trema::IP.new( message.match.nw_dst ).to_s.should == "192.168.0.2"
-          message.match.tp_src.should == 1
-          message.match.tp_dst.should == 1
-          message.cookie.should == 123456789
-          message.idle_timeout.should == 1
-          message.reason.should == 0
-          message.duration_sec.should >= 1
-          message.packet_count.should == 0
-          message.byte_count.should == 0
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.match.in_port ).to eq( 1 )
+          expect( message.match.dl_src.to_s ).to eq( "00:00:00:00:00:01" )
+          expect( message.match.dl_dst.to_s ).to eq( "00:00:00:00:00:02" )
+          expect( message.match.dl_type ).to eq( 0x800 )
+          expect( message.match.dl_vlan ).to eq( 65535 )
+          expect( message.match.dl_vlan_pcp ).to eq( 0 )
+          expect( message.match.nw_tos ).to eq( 0 )
+          expect( message.match.nw_proto ).to eq( 17 )
+          expect( Trema::IP.new( message.match.nw_src ).to_s ).to eq( "192.168.0.1" )
+          expect( Trema::IP.new( message.match.nw_dst ).to_s ).to eq( "192.168.0.2" )
+          expect( message.match.tp_src ).to eq( 1 )
+          expect( message.match.tp_dst ).to eq( 1 )
+          expect( message.cookie ).to eq( 123456789 )
+          expect( message.idle_timeout ).to eq( 1 )
+          expect( message.reason ).to eq( 0 )
+          expect( message.duration_sec ).to be >= 1
+          expect( message.packet_count ).to eq( 0 )
+          expect( message.byte_count ).to eq( 0 )
         end
         controller( "FlowRemovedController" ).send_flow_mod_add(
           0xabc,

data/spec/trema/get-config-request_spec.rb

@@ -29,7 +29,7 @@ shared_examples_for "get config request message" do
     }.run( GetConfigRequestController ) {
       controller( "GetConfigRequestController" ).send_message( 0xabc, subject )
       sleep 2 # FIXME: wait to send_message
-      IO.read( File.join( Trema.log, "openflowd.get-config-request.log" ) ).should include( "OFPT_GET_CONFIG_REQUEST" )
+      expect( IO.read( File.join( Trema.log, "openflowd.get-config-request.log" ) ) ).to include( "OFPT_GET_CONFIG_REQUEST" )
     }
   end
 end

data/spec/trema/hardware-switch_spec.rb

@@ -33,17 +33,17 @@ module Trema
 
 
     it "should return its name" do
-      @switch.name.should == "0xabc"
+      expect( @switch.name ).to eq( "0xabc" )
     end
 
 
     it "should return dpid in long format" do
-      @switch.dpid_long.should == "0000000000000abc"
+      expect( @switch.dpid_long ).to eq( "0000000000000abc" )
     end
 
 
     it "should return dpid in short format" do
-      @switch.dpid_short.should == "0xabc"
+      expect( @switch.dpid_short ).to eq( "0xabc" )
     end
   end
 end

data/spec/trema/host_spec.rb

@@ -166,7 +166,7 @@ module Trema
           it "should get tx stats" do
             @cli.should_receive( :tx_stats ).and_return( @stats )
 
-            @host.tx_stats.should == @stats
+            expect( @host.tx_stats ).to eq( @stats )
           end
         end
       end
@@ -177,7 +177,7 @@ module Trema
           it "should get rx stats" do
             @cli.should_receive( :rx_stats ).and_return( @stats )
 
-            @host.rx_stats.should == @stats
+            expect( @host.rx_stats ).to eq( @stats )
           end
         end
       end

data/spec/trema/list-switches-reply_spec.rb

@@ -32,7 +32,7 @@ describe Controller do
         vswitch { datapath_id 0x3 }
       }.run( ListSwitchesController ) {
         controller( "ListSwitchesController" ).should_receive( :list_switches_reply ) do | dpids |
-          dpids.should == [ 0x1, 0x2, 0x3 ]
+          expect( dpids ).to eq( [ 0x1, 0x2, 0x3 ] )
         end
         controller( "ListSwitchesController" ).send_list_switches_request
       }

data/spec/trema/mac_spec.rb

@@ -86,7 +86,7 @@ module Trema
       it "can be used for Hash keys" do
         fdb = {}
         fdb[ Mac.new( "00:00:00:00:00:01" ) ] = "Port #1"
-        fdb[ Mac.new( "00:00:00:00:00:01" ) ].should == "Port #1"
+        expect( fdb[ Mac.new( "00:00:00:00:00:01" ) ] ).to eq( "Port #1" )
       end
     end
   end

data/spec/trema/match_spec.rb

@@ -40,17 +40,17 @@ describe Match, ".new" do
     )
   }
   its( :in_port ) { should == 1 }
-  its( :dl_src ) { subject.to_s.should == "00:00:00:00:00:01" }
-  its( :dl_dst ) { subject.to_s.should == "00:00:00:00:00:02" }
+  its( "dl_src.to_s" ) { should == "00:00:00:00:00:01" }
+  its( "dl_dst.to_s" ) { should == "00:00:00:00:00:02" }
   its( :dl_vlan ) { should == 65535 }
   its( :dl_vlan_pcp ) { should == 0 }
   its( :dl_type ) { should == 0x800 }
   its( :nw_tos ) { should == 0 }
   its( :nw_proto ) { should == 17 }
-  its( :nw_src ) { subject.to_s.should == "192.168.0.1" }
-  its( :nw_src ) { subject.prefixlen.should == 32 }
-  its( :nw_dst ) { subject.to_s.should == "192.168.0.0" }
-  its( :nw_dst ) { subject.prefixlen.should == 24 }
+  its( "nw_src.to_s" ) { should == "192.168.0.1" }
+  its( "nw_src.prefixlen" ) { should == 32 }
+  its( "nw_dst.to_s" ) { should == "192.168.0.0" }
+  its( "nw_dst.prefixlen" ) { should == 24 }
   its( :tp_src ) { should == 10 }
   its( :tp_dst ) { should == 20 }
   its( :to_s ) { should == "wildcards = 0x20000(nw_dst(8)), in_port = 1, dl_src = 00:00:00:00:00:01, dl_dst = 00:00:00:00:00:02, dl_vlan = 0xffff, dl_vlan_pcp = 0, dl_type = 0x800, nw_tos = 0, nw_proto = 17, nw_src = 192.168.0.1/32, nw_dst = 192.168.0.0/24, tp_src = 10, tp_dst = 20" }
@@ -78,7 +78,7 @@ describe Match, ".compare" do
       :nw_src => "192.168.0.0/24",
       :nw_dst => "192.168.0.0/24"
     )
-    pattern.compare( tester ).should == true
+    expect( pattern.compare( tester ) ).to be_true
   end
 
   it "Should not match" do
@@ -101,7 +101,7 @@ describe Match, ".compare" do
       :nw_src => "10.0.0.0/8",
       :nw_dst => "10.0.0.0/8"
     )
-    pattern.compare( tester ).should == false
+    expect( pattern.compare( tester ) ).to be_false
   end
 end
 

data/spec/trema/open-vswitch_spec.rb

@@ -38,10 +38,10 @@ module Trema
       OpenVswitch.new mock( "stanza 1", :name => "vswitch 1", :validate => true )
       OpenVswitch.new mock( "stanza 2", :name => "vswitch 2", :validate => true )
 
-      OpenflowSwitch.should have( 3 ).vswitches
-      OpenflowSwitch[ "vswitch 0" ].should_not be_nil
-      OpenflowSwitch[ "vswitch 1" ].should_not be_nil
-      OpenflowSwitch[ "vswitch 2" ].should_not be_nil
+      expect( OpenflowSwitch ).to have( 3 ).vswitches
+      expect( OpenflowSwitch[ "vswitch 0" ] ).not_to be_nil
+      expect( OpenflowSwitch[ "vswitch 1" ] ).not_to be_nil
+      expect( OpenflowSwitch[ "vswitch 2" ] ).not_to be_nil
     end
   end
 
@@ -94,7 +94,7 @@ module Trema
 
       it "should execute ovs openflowd" do
         subject.should_receive( :sh ).with do | command |
-          command.should include( Executables.ovs_openflowd )
+          expect( command ).to include( Executables.ovs_openflowd )
         end
 
         subject.run!
@@ -106,7 +106,7 @@ module Trema
         subject << "VirtualInterface2"
 
         subject.should_receive( :sh ).with do | command |
-          command.should include( "--ports=VirtualInterface0,VirtualInterface1,VirtualInterface2" )
+          expect( command ).to include( "--ports=VirtualInterface0,VirtualInterface1,VirtualInterface2" )
         end
 
         subject.run!

data/spec/trema/openflow-error_spec.rb

@@ -34,9 +34,9 @@ describe Trema::OpenflowError, "new" do
           :advertise => 0
         )
         controller( "OpenflowErrorController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == Error::OFPET_PORT_MOD_FAILED
-          message.code.should == Error::OFPPMFC_BAD_PORT
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( Error::OFPET_PORT_MOD_FAILED )
+          expect( message.code ).to eq( Error::OFPPMFC_BAD_PORT )
         end
         controller( "OpenflowErrorController" ).send_message( 0xabc, port_mod )
         sleep 2 # FIXME: wait to send_message
@@ -62,9 +62,9 @@ describe Trema::OpenflowError, "new" do
           :advertise => 0
         )
         controller( "OpenflowErrorController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == Error::OFPET_PORT_MOD_FAILED
-          message.code.should == Error::OFPPMFC_BAD_HW_ADDR
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( Error::OFPET_PORT_MOD_FAILED )
+          expect( message.code ).to eq( Error::OFPPMFC_BAD_HW_ADDR )
         end
         controller( "OpenflowErrorController" ).send_message( 0xabc, port_mod )
         sleep 2 # FIXME: wait to send_message
@@ -84,9 +84,9 @@ describe Trema::OpenflowError, "new" do
         link "host2", "error-port"
       }.run( OpenflowErrorController ) {
         controller( "OpenflowErrorController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == Error::OFPET_BAD_ACTION
-          message.code.should == Error::OFPBAC_BAD_OUT_PORT
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( Error::OFPET_BAD_ACTION )
+          expect( message.code ).to eq( Error::OFPBAC_BAD_OUT_PORT )
         end
         controller( "OpenflowErrorController" ).send_flow_mod_add( 0xabc, :actions => ActionOutput.new( :port => 0x5555 ) )
         sleep 2 # FIXME: wait to send_flow_mod_add
@@ -103,23 +103,23 @@ describe Trema::OpenflowError, "new" do
       }.run( OpenflowController ) {
         queue_get_config_request = Trema::QueueGetConfigRequest.new( :port => 1 )
         controller( "OpenflowController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          message.datapath_id.should == 0xabc
-          message.type.should satisfy { | n |
+          expect( message.datapath_id ).to eq( 0xabc )
+          expect( message.type ).to satisfy { | n |
             n >= 0 && n <= 5
           }
           case message.type
           when 0,4
-            message.code.should include 0,1
+            expect( message.code ).to include( 0,1 )
           when 1,2
-            message.code.should satisfy { | n |
+            expect( message.code ).to satisfy { | n |
               n >= 0 && n <= 8
             }
           when 3
-            message.code.should satisfy { | n |
+            expect( message.code ).to satisfy { | n |
               n >= 0 && n <= 5
             }
           when 5
-            message.code.should satisfy { |n|
+            expect( message.code ).to satisfy { |n|
               n >= 0 && n <= 3
             }
           end

data/spec/trema/packet-in_spec.rb

@@ -1,4 +1,3 @@
-
 # Author: Nick Karanatsios <nickkaranatsios@gmail.com>
 #
 # Copyright (C) 2008-2012 NEC Corporation
@@ -56,9 +55,9 @@ describe Trema::PacketIn do
         link "test", "host2"
       }.run( PacketInController ) {
         controller( "PacketInController" ).should_receive( :packet_in ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.datapath_id.should == 0xabc
-          message.in_port.should > 0
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.datapath_id ).to eq( 0xabc )
+          expect( message.in_port ).to be > 0
         end
         send_and_wait
       }
@@ -77,22 +76,22 @@ describe Trema::PacketIn do
       }.run( PacketInController ) {
         controller( "PacketInController" ).should_receive( :packet_in ) do | datapath_id, message |
            # packet_in expected to have data portion.
-          message.total_len.should > 20
-          message.data.should be_instance_of( String )
-          message.buffered?.should be_false
-
-          message.macsa.should be_instance_of( Trema::Mac )
-          message.macsa.to_s.should == "00:00:00:00:00:01"
-          message.macda.should be_instance_of( Trema::Mac )
-          message.macda.to_s.should == "00:00:00:00:00:02"
-
-          message.eth_type.should == 0x0800
-          message.ipv4?.should == true
-          message.ipv4_version.should == 4
-          message.ipv4_saddr.should be_instance_of( Trema::IP )
-          message.ipv4_saddr.to_s.should == "192.168.1.1"
-          message.ipv4_daddr.should be_instance_of( Trema::IP )
-          message.ipv4_daddr.to_s.should == "192.168.1.2"
+          expect( message.total_len ).to be  > 20
+          expect( message.data ).to be_instance_of( String )
+          expect( message.buffered? ).to be_false
+
+          expect( message.macsa ).to be_instance_of( Trema::Mac )
+          expect( message.macsa.to_s ).to eq( "00:00:00:00:00:01" )
+          expect( message.macda ).to be_instance_of( Trema::Mac )
+          expect( message.macda.to_s ).to eq( "00:00:00:00:00:02" )
+
+          expect( message.eth_type ).to eq( 0x0800 )
+          expect( message.ipv4? ).to be_true
+          expect( message.ipv4_version ).to eq( 4 )
+          expect( message.ipv4_saddr ).to be_instance_of( Trema::IP )
+          expect( message.ipv4_saddr.to_s ).to eq( "192.168.1.1" )
+          expect( message.ipv4_daddr ).to be_instance_of( Trema::IP )
+          expect( message.ipv4_daddr.to_s ).to eq( "192.168.1.2" )
         end
         send_and_wait
       }
@@ -130,66 +129,66 @@ describe Trema::PacketIn do
           0x00, 0x00
         ].pack( "C*" )
         controller( "PacketInSendController" ).should_receive( :packet_in ) do | datapath_id, message |
-          message.in_port.should > 0
-          message.vtag?.should be_false
-          message.arp?.should be_true
-          message.ipv4?.should be_false
-          message.tcp?.should be_false
-          message.udp?.should be_false
-          message.icmpv4?.should be_false
-          message.igmp?.should be_false
-
-          message.arp_oper.should == 2
-          message.arp_sha.to_s.should == "00:00:00:00:00:01"
-          message.arp_spa.to_s.should == "192.168.0.1"
-          message.arp_tha.to_s.should == "00:00:00:00:00:02"
-          message.arp_tpa.to_s.should == "192.168.0.2"
-          message.arp_request?.should be_false
-          message.arp_reply?.should be_true
-
-          message.vlan_tpid.should be_nil
-          message.vlan_tci.should be_nil
-          message.vlan_prio.should be_nil
-          message.vlan_cfi.should be_nil
-          message.vlan_vid.should be_nil
-
-          message.ipv4_version.should be_nil
-          message.ipv4_ihl.should be_nil
-          message.ipv4_tos.should be_nil
-          message.ipv4_tot_len.should be_nil
-          message.ipv4_id.should be_nil
-          message.ipv4_frag_off.should be_nil
-          message.ipv4_ttl.should be_nil
-          message.ipv4_protocol.should be_nil
-          message.ipv4_checksum.should be_nil
-          message.ipv4_saddr.should be_nil
-          message.ipv4_daddr.should be_nil
-
-          message.icmpv4_type.should be_nil
-          message.icmpv4_code.should be_nil
-          message.icmpv4_checksum.should be_nil
-          message.icmpv4_id.should be_nil
-          message.icmpv4_seq.should be_nil
-          message.icmpv4_gateway.should be_nil
-
-          message.igmp_type.should be_nil
-          message.igmp_checksum.should be_nil
-          message.igmp_group.should be_nil
-
-          message.tcp_src_port.should be_nil
-          message.tcp_dst_port.should be_nil
-          message.tcp_seq_no.should be_nil
-          message.tcp_ack_no.should be_nil
-          message.tcp_offset.should be_nil
-          message.tcp_flags.should be_nil
-          message.tcp_window.should be_nil
-          message.tcp_checksum.should be_nil
-          message.tcp_urgent.should be_nil
-
-          message.udp_src_port.should be_nil
-          message.udp_dst_port.should be_nil
-          message.udp_checksum.should be_nil
-          message.udp_len.should be_nil
+          expect( message.in_port ).to be > 0
+          expect( message.vtag? ).to be_false
+          expect( message.arp? ).to be_true
+          expect( message.ipv4? ).to be_false
+          expect( message.tcp? ).to be_false
+          expect( message.udp? ).to be_false
+          expect( message.icmpv4? ).to be_false
+          expect( message.igmp? ).to be_false
+
+          expect( message.arp_oper ).to eq( 2 )
+          expect( message.arp_sha.to_s ).to eq( "00:00:00:00:00:01" )
+          expect( message.arp_spa.to_s ).to eq( "192.168.0.1" )
+          expect( message.arp_tha.to_s ).to eq( "00:00:00:00:00:02" )
+          expect( message.arp_tpa.to_s ).to eq( "192.168.0.2" )
+          expect( message.arp_request? ).to be_false
+          expect( message.arp_reply? ).to be_true
+
+          expect( message.vlan_tpid ).to be_nil
+          expect( message.vlan_tci ).to be_nil
+          expect( message.vlan_prio ).to be_nil
+          expect( message.vlan_cfi ).to be_nil
+          expect( message.vlan_vid ).to be_nil
+
+          expect( message.ipv4_version ).to be_nil
+          expect( message.ipv4_ihl ).to be_nil
+          expect( message.ipv4_tos ).to be_nil
+          expect( message.ipv4_tot_len ).to be_nil
+          expect( message.ipv4_id ).to be_nil
+          expect( message.ipv4_frag_off ).to be_nil
+          expect( message.ipv4_ttl ).to be_nil
+          expect( message.ipv4_protocol ).to be_nil
+          expect( message.ipv4_checksum ).to be_nil
+          expect( message.ipv4_saddr ).to be_nil
+          expect( message.ipv4_daddr ).to be_nil
+
+          expect( message.icmpv4_type ).to be_nil
+          expect( message.icmpv4_code ).to be_nil
+          expect( message.icmpv4_checksum ).to be_nil
+          expect( message.icmpv4_id ).to be_nil
+          expect( message.icmpv4_seq ).to be_nil
+          expect( message.icmpv4_gateway ).to be_nil
+
+          expect( message.igmp_type ).to be_nil
+          expect( message.igmp_checksum ).to be_nil
+          expect( message.igmp_group ).to be_nil
+
+          expect( message.tcp_src_port ).to be_nil
+          expect( message.tcp_dst_port ).to be_nil
+          expect( message.tcp_seq_no ).to be_nil
+          expect( message.tcp_ack_no ).to be_nil
+          expect( message.tcp_offset ).to be_nil
+          expect( message.tcp_flags ).to be_nil
+          expect( message.tcp_window ).to be_nil
+          expect( message.tcp_checksum ).to be_nil
+          expect( message.tcp_urgent ).to be_nil
+
+          expect( message.udp_src_port ).to be_nil
+          expect( message.udp_dst_port ).to be_nil
+          expect( message.udp_checksum ).to be_nil
+          expect( message.udp_len ).to be_nil
         end
 
         controller( "PacketInSendController" ).send_packet_out(
@@ -240,42 +239,42 @@ describe Trema::PacketIn do
           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
         ].pack( "C*" )
         controller( "PacketInSendController" ).should_receive( :packet_in ) do | datapath_id, message |
-          message.in_port.should > 0
-          message.vtag?.should be_false
-          message.arp?.should be_false
-          message.ipv4?.should be_true
-          message.udp?.should be_false
-          message.tcp?.should be_true
-          message.icmpv4?.should be_false
-          message.igmp?.should be_false
-
-          message.ipv4_version.should == 4
-          message.ipv4_ihl.should == 5
-          message.ipv4_tos.should == 0
-          message.ipv4_tot_len.should == 0x28
-          message.ipv4_id.should == 0
-          message.ipv4_frag_off.should == 0
-          message.ipv4_ttl.should == 0
-          message.ipv4_protocol.should == 6
-          message.ipv4_checksum.should == 0x397d
-          message.ipv4_saddr.to_s.should == "192.168.0.1"
-          message.ipv4_daddr.to_s.should == "192.168.0.2"
-
-          message.tcp_src_port.should == 1
-          message.tcp_dst_port.should == 2
-          message.tcp_seq_no.should == 0
-          message.tcp_ack_no.should == 0
-          message.tcp_offset.should == 5
-          message.tcp_flags.should == 0
-          message.tcp_window.should == 0
-          message.tcp_checksum.should == 11910 # 0x2e86
-          message.tcp_urgent.should == 0
-
-          message.arp_oper.should be_nil
-          message.arp_sha.should be_nil
-          message.arp_spa.should be_nil
-          message.arp_tha.should be_nil
-          message.arp_tpa.should be_nil
+          expect( message.in_port ).to be > 0
+          expect( message.vtag? ).to be_false
+          expect( message.arp? ).to be_false
+          expect( message.ipv4? ).to be_true
+          expect( message.udp? ).to be_false
+          expect( message.tcp? ).to be_true
+          expect( message.icmpv4? ).to be_false
+          expect( message.igmp? ).to be_false
+
+          expect( message.ipv4_version ).to eq( 4 )
+          expect( message.ipv4_ihl ).to eq( 5 )
+          expect( message.ipv4_tos ).to eq( 0 )
+          expect( message.ipv4_tot_len ).to eq( 0x28 )
+          expect( message.ipv4_id ).to eq( 0 )
+          expect( message.ipv4_frag_off ).to eq( 0 )
+          expect( message.ipv4_ttl ).to eq( 0 )
+          expect( message.ipv4_protocol ).to eq( 6 )
+          expect( message.ipv4_checksum ).to eq( 0x397d )
+          expect( message.ipv4_saddr.to_s ).to eq( "192.168.0.1" )
+          expect( message.ipv4_daddr.to_s ).to eq( "192.168.0.2" )
+
+          expect( message.tcp_src_port ).to eq( 1 )
+          expect( message.tcp_dst_port ).to eq( 2 )
+          expect( message.tcp_seq_no ).to eq( 0 )
+          expect( message.tcp_ack_no ).to eq( 0 )
+          expect( message.tcp_offset ).to eq( 5 )
+          expect( message.tcp_flags ).to eq( 0 )
+          expect( message.tcp_window ).to eq( 0 )
+          expect( message.tcp_checksum ).to eq( 11910 ) # 0x2e86
+          expect( message.tcp_urgent ).to eq( 0 )
+
+          expect( message.arp_oper ).to be_nil
+          expect( message.arp_sha ).to be_nil
+          expect( message.arp_spa ).to be_nil
+          expect( message.arp_tha ).to be_nil
+          expect( message.arp_tpa ).to be_nil
         end
 
         controller( "PacketInSendController" ).send_packet_out(
@@ -323,31 +322,32 @@ describe Trema::PacketIn do
           0x00, 0x00, 0x00, 0x00, 0x00, 0x00
         ].pack( "C*" )
         controller( "PacketInSendController" ).should_receive( :packet_in ) do | datapath_id, message |
-          message.in_port.should > 0
-          message.vtag?.should be_false
-          message.arp?.should be_false
-          message.ipv4?.should be_true
-          message.tcp?.should be_false
-          message.udp?.should be_true
-          message.icmpv4?.should be_false
-          message.igmp?.should be_false
-
-          message.ipv4_version.should == 4
-          message.ipv4_ihl.should == 5
-          message.ipv4_tos.should == 0
-          message.ipv4_tot_len.should == 0x32
-          message.ipv4_id.should == 0
-          message.ipv4_frag_off.should == 0
-          message.ipv4_ttl.should == 0x40
-          message.ipv4_protocol.should == 17
-          message.ipv4_checksum.should == 0xf968
-          message.ipv4_saddr.to_s.should == "192.168.0.1"
-          message.ipv4_daddr.to_s.should == "192.168.0.2"
-
-          message.udp_src_port.should == 1
-          message.udp_dst_port.should == 2
-          message.udp_checksum.should == 0
-          message.udp_len.should == 0x1e
+          expect( message.in_port ).to be > 0
+          expect( message.vtag? ).to be_false
+          expect( message.arp? ).to be_false
+          expect( message.ipv4? ).to be_true
+          expect( message.tcp? ).to be_false
+          expect( message.udp? ).to be_true
+          expect( message.icmpv4? ).to be_false
+          expect( message.igmp? ).to be_false
+
+
+          expect( message.ipv4_version ).to eq( 4 )
+          expect( message.ipv4_ihl ).to eq( 5 )
+          expect( message.ipv4_tos ).to eq( 0 )
+          expect( message.ipv4_tot_len ).to eq( 0x32 )
+          expect( message.ipv4_id ).to eq( 0 )
+          expect( message.ipv4_frag_off ).to eq( 0 )
+          expect( message.ipv4_ttl ).to eq( 0x40 )
+          expect( message.ipv4_protocol ).to eq( 17 )
+          expect( message.ipv4_checksum ).to eq( 0xf968 )
+          expect( message.ipv4_saddr.to_s ).to eq( "192.168.0.1" )
+          expect( message.ipv4_daddr.to_s ).to eq( "192.168.0.2" )
+
+          expect( message.udp_src_port ).to eq( 1 )
+          expect( message.udp_dst_port ).to eq( 2 )
+          expect( message.udp_checksum ).to eq( 0 )
+          expect( message.udp_len ).to eq( 0x1e )
         end
 
         controller( "PacketInSendController" ).send_packet_out(
@@ -375,6 +375,8 @@ describe Trema::PacketIn do
           0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # dst
           0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # src
           # vlan tag
+
+
           0x81, 0x00, # tpid
           0x0f, 0x9f, # tci
           0x08, 0x00, # ether type
@@ -400,44 +402,44 @@ describe Trema::PacketIn do
           0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69
         ].pack( "C*" )
         controller( "PacketInSendController" ).should_receive( :packet_in ) do | datapath_id, message |
-          message.in_port.should > 0
-          message.vtag?.should be_true
-          message.arp?.should be_false
-          message.ipv4?.should be_true
-          message.udp?.should be_false
-          message.tcp?.should be_false
-          message.icmpv4?.should be_true
-          message.igmp?.should be_false
-
-          message.vlan_tpid.should == 0x8100
-          message.vlan_tci.should == 0x0f9f
-          message.vlan_prio.should == 0
-          message.vlan_cfi.should == 0
-          message.vlan_vid.should == 0xf9f
-          message.eth_type.should == 0x0800
-
-          message.ipv4_version.should == 4
-          message.ipv4_ihl.should == 5
-          message.ipv4_tos.should == 0
-          message.ipv4_tot_len.should == 0x003c
-          message.ipv4_id.should == 0x8c1b
-          message.ipv4_frag_off.should == 0
-          message.ipv4_ttl.should == 0x80
-          message.ipv4_protocol.should == 1
-          message.ipv4_checksum.should == 0xed09
-          message.ipv4_saddr.to_s.should == "192.168.32.74"
-          message.ipv4_daddr.to_s.should == "192.168.32.1"
-
-          message.icmpv4_type.should == 8
-          message.icmpv4_code.should == 0
-          message.icmpv4_checksum.should == 0xe95b
-          message.icmpv4_id.should == 0x0400
-          message.icmpv4_seq.should == 0x6000
-
-          message.icmpv4_echo_reply?.should be_false
-          message.icmpv4_dst_unreach?.should be_false
-          message.icmpv4_redirect?.should be_false
-          message.icmpv4_echo_request?.should be_true
+          expect( message.in_port ).to be > 0
+          expect( message.vtag? ).to be_true
+          expect( message.arp? ).to be_false
+          expect( message.ipv4? ).to be_true
+          expect( message.udp? ).to be_false
+          expect( message.tcp? ).to be_false
+          expect( message.icmpv4? ).to be_true
+          expect( message.igmp? ).to be_false
+
+          expect( message.vlan_tpid ).to eq( 0x8100 )
+          expect( message.vlan_tci ).to eq( 0x0f9f )
+          expect( message.vlan_prio ).to eq( 0 )
+          expect( message.vlan_cfi ).to eq( 0 )
+          expect( message.vlan_vid ).to eq( 0xf9f )
+          expect( message.eth_type ).to eq( 0x0800 )
+
+          expect( message.ipv4_version ).to eq( 4 )
+          expect( message.ipv4_ihl ).to eq( 5 )
+          expect( message.ipv4_tos ).to eq( 0 )
+          expect( message.ipv4_tot_len ).to eq( 0x003c )
+          expect( message.ipv4_id ).to eq( 0x8c1b )
+          expect( message.ipv4_frag_off ).to eq( 0 )
+          expect( message.ipv4_ttl ).to eq( 0x80 )
+          expect( message.ipv4_protocol ).to eq( 1 )
+          expect( message.ipv4_checksum ).to eq( 0xed09 )
+          expect( message.ipv4_saddr.to_s ).to eq( "192.168.32.74" )
+          expect( message.ipv4_daddr.to_s ).to eq( "192.168.32.1" )
+
+          expect( message.icmpv4_type ).to eq( 8 )
+          expect( message.icmpv4_code ).to eq( 0 )
+          expect( message.icmpv4_checksum ).to eq( 0xe95b )
+          expect( message.icmpv4_id ).to eq( 0x0400 )
+          expect( message.icmpv4_seq ).to eq( 0x6000 )
+
+          expect( message.icmpv4_echo_reply? ).to be_false
+          expect( message.icmpv4_dst_unreach? ).to be_false
+          expect( message.icmpv4_redirect? ).to be_false
+          expect( message.icmpv4_echo_request? ).to be_true
         end
 
         controller( "PacketInSendController" ).send_packet_out(
@@ -483,35 +485,35 @@ describe Trema::PacketIn do
           0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69
         ].pack( "C*" )
         controller( "PacketInSendController" ).should_receive( :packet_in ) do | datapath_id, message |
-          message.in_port.should > 0
-          message.vtag?.should be_false
-          message.arp?.should be_false
-          message.ipv4?.should be_true
-          message.udp?.should be_false
-          message.tcp?.should be_false
-          message.icmpv4?.should be_false
-          message.igmp?.should be_true
-
-          message.igmp_membership_query?.should be_true
-          message.igmp_v1_membership_report?.should be_false
-          message.igmp_v2_membership_report?.should be_false
-          message.igmp_v2_leave_group?.should be_false
-          message.igmp_v3_membership_report?.should be_false
-
-          message.ipv4_version.should == 4
-          message.ipv4_ihl.should == 6
-          message.ipv4_tos.should == 0xc0
-          message.ipv4_tot_len.should == 0x0020
-          message.ipv4_id.should == 0x3aea
-          message.ipv4_frag_off.should == 0
-          message.ipv4_ttl.should == 1
-          message.ipv4_protocol.should == 2
-          message.ipv4_checksum.should == 0xe458
-          message.ipv4_saddr.to_s.should == "192.168.100.43"
-          message.ipv4_daddr.to_s.should == "224.0.0.1"
-
-          message.igmp_type.should == 0x11
-          message.igmp_checksum.should == 0xee9b
+          expect( message.in_port ).to be > 0
+          expect( message.vtag? ).to be_false
+          expect( message.arp? ).to be_false
+          expect( message.ipv4? ).to be_true
+          expect( message.udp? ).to be_false
+          expect( message.tcp? ).to be_false
+          expect( message.icmpv4? ).to be_false
+          expect( message.igmp? ).to be_true
+
+          expect( message.igmp_membership_query? ).to be_true
+          expect( message.igmp_v1_membership_report? ).to be_false
+          expect( message.igmp_v2_membership_report? ).to be_false
+          expect( message.igmp_v2_leave_group? ).to be_false
+          expect( message.igmp_v3_membership_report? ).to be_false
+
+          expect( message.ipv4_version ).to eq( 4 )
+          expect( message.ipv4_ihl ).to eq( 6 )
+          expect( message.ipv4_tos ).to eq( 0xc0 )
+          expect( message.ipv4_tot_len ).to eq( 0x0020 )
+          expect( message.ipv4_id ).to eq( 0x3aea )
+          expect( message.ipv4_frag_off ).to eq( 0 )
+          expect( message.ipv4_ttl ).to eq( 1 )
+          expect( message.ipv4_protocol ).to eq( 2 )
+          expect( message.ipv4_checksum ).to eq( 0xe458 )
+          expect( message.ipv4_saddr.to_s ).to eq( "192.168.100.43" )
+          expect( message.ipv4_daddr.to_s ).to eq( "224.0.0.1" )
+
+          expect( message.igmp_type ).to eq( 0x11 )
+          expect( message.igmp_checksum ).to eq( 0xee9b )
         end
 
         controller( "PacketInSendController" ).send_packet_out(