trema 0.4.7 → 0.4.8

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

@@ -1,46 +0,0 @@
-#
-# Copyright (C) 2008-2013 NEC Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License, version 2, as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-
-
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-require 'trema'
-
-
-describe Controller do
-  context 'when #list_switches_request is sent' do
-    it 'should receive #list_switches_reply' do
-      class ListSwitchesController < Controller; end
-      network do
-        vswitch { datapath_id 0x1 }
-        vswitch { datapath_id 0x2 }
-        vswitch { datapath_id 0x3 }
-      end.run(ListSwitchesController) do
-        controller('ListSwitchesController').should_receive(:list_switches_reply) do | dpids |
-          expect(dpids).to eq([0x1, 0x2, 0x3])
-        end
-        controller('ListSwitchesController').send_list_switches_request
-      end
-    end
-  end
-end
-
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End:

data/spec/trema/match_spec.rb

@@ -1,111 +0,0 @@
-#
-# Copyright (C) 2008-2011 NEC Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License, version 2, as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-
-
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-require 'trema'
-
-
-describe Match, '.new' do
-  subject do
-    Match.new(
-      :in_port => 1,
-      :dl_src => '00:00:00:00:00:01',
-      :dl_dst => '00:00:00:00:00:02',
-      :dl_vlan => 65535,
-      :dl_vlan_pcp => 0,
-      :dl_type => 0x800,
-      :nw_tos => 0,
-      :nw_proto => 17,
-      :nw_src => '192.168.0.1',
-      :nw_dst => '192.168.0.0/24',
-      :tp_src => 10,
-      :tp_dst => 20
-    )
-  end
-  its(:in_port) { should == 1 }
-  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.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' }
-end
-
-
-describe Match, '.compare' do
-  it 'Should match' do
-    tester = Match.new(
-      :in_port => 1,
-      :dl_src => '00:00:00:00:00:01',
-      :dl_dst => '00:00:00:00:00:02',
-      :dl_vlan => 65535,
-      :dl_vlan_pcp => 0,
-      :dl_type => 0x800,
-      :nw_tos => 0,
-      :nw_proto => 17,
-      :nw_src => '192.168.0.1',
-      :nw_dst => '192.168.0.2',
-      :tp_src => 10,
-      :tp_dst => 20
-    )
-    pattern = Match.new(
-      :in_port => 1,
-      :nw_src => '192.168.0.0/24',
-      :nw_dst => '192.168.0.0/24'
-    )
-    expect(pattern.compare(tester)).to be_true
-  end
-
-  it 'Should not match' do
-    tester = Match.new(
-      :in_port => 1,
-      :dl_src => '00:00:00:00:00:01',
-      :dl_dst => '00:00:00:00:00:02',
-      :dl_vlan => 65535,
-      :dl_vlan_pcp => 0,
-      :dl_type => 0x800,
-      :nw_tos => 0,
-      :nw_proto => 17,
-      :nw_src => '192.168.0.1',
-      :nw_dst => '192.168.0.2',
-      :tp_src => 10,
-      :tp_dst => 20
-    )
-    pattern = Match.new(
-      :in_port => 1,
-      :nw_src => '10.0.0.0/8',
-      :nw_dst => '10.0.0.0/8'
-    )
-    expect(pattern.compare(tester)).to be_false
-  end
-end
-
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End:

data/spec/trema/open-vswitch_spec.rb

@@ -1,121 +0,0 @@
-#
-# Copyright (C) 2008-2013 NEC Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License, version 2, as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-
-
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-require 'trema/open-vswitch'
-
-
-module Trema
-  describe OpenflowSwitch do
-    around do | example |
-      begin
-        OpenflowSwitch.clear
-        example.run
-      ensure
-        OpenflowSwitch.clear
-      end
-    end
-
-    it 'should keep a list of vswitches' do
-      OpenVswitch.new mock('stanza 0', :name => 'vswitch 0', :validate => true)
-      OpenVswitch.new mock('stanza 1', :name => 'vswitch 1', :validate => true)
-      OpenVswitch.new mock('stanza 2', :name => 'vswitch 2', :validate => true)
-
-      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
-
-
-  describe OpenVswitch, 'dpid = 0xabc' do
-    subject do
-      stanza = { :dpid_short => '0xabc', :dpid_long => '0000000000000abc', :ip => '127.0.0.1' }
-      stanza.stub!(:validate)
-      stanza.stub!(:name).and_return(name)
-      OpenVswitch.new stanza
-    end
-
-
-    context 'when its name is not set' do
-      let(:name) { '0xabc' }
-
-      its(:name) { should == '0xabc' }
-      its(:dpid_short) { should == '0xabc' }
-      its(:dpid_long) { should == '0000000000000abc' }
-      its(:network_device) { should == 'vsw_0xabc' }
-    end
-
-
-    context 'when its name is set' do
-      let(:name) { 'Otosan Switch' }
-
-      its(:name) { should == 'Otosan Switch' }
-      its(:dpid_short) { should == '0xabc' }
-      its(:dpid_long) { should == '0000000000000abc' }
-      its(:network_device) { should == 'vsw_0xabc' }
-    end
-
-
-    context 'when getting its flows' do
-      let(:name) { '0xabc' }
-
-      it 'should execute ofctl to get the flows' do
-        ofctl = mock('ofctl')
-        Ofctl.stub!(:new).and_return(ofctl)
-
-        ofctl.should_receive(:users_flows).with(subject).once
-
-        subject.flows
-      end
-    end
-
-
-    context 'when running it' do
-      let(:name) { '0xabc' }
-
-      it 'should execute ovs openflowd' do
-        subject.should_receive(:sh).with do | command |
-          expect(command).to include(Executables.ovs_openflowd)
-        end
-
-        subject.run!
-      end
-
-      it 'should be connected to virtual ports' do
-        subject << 'VirtualInterface0'
-        subject << 'VirtualInterface1'
-        subject << 'VirtualInterface2'
-
-        subject.should_receive(:sh).with do | command |
-          expect(command).to include('--ports=VirtualInterface0,VirtualInterface1,VirtualInterface2')
-        end
-
-        subject.run!
-      end
-    end
-  end
-end
-
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End:

data/spec/trema/openflow-error_spec.rb

@@ -1,141 +0,0 @@
-#
-# Copyright (C) 2008-2013 NEC Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License, version 2, as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-
-
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-require 'trema'
-
-
-describe Trema::OpenflowError, 'new' do
-  context 'when #port_mod with an invalid(port_no) is sent' do
-    it 'should receive #error(type=Error::OFPET_PORT_MOD_FAILED,code=Error::OFPPMFC_BAD_PORT)' do
-      class OpenflowErrorController < Controller; end
-      network do
-        vswitch('error-port') { datapath_id 0xabc }
-      end.run(OpenflowErrorController) do
-        port_mod = Trema::PortMod.new(
-          :port_no => 2,
-          :hw_addr => Trema::Mac.new('11:22:33:44:55:66'),
-          :config => 1,
-          :mask => 1,
-          :advertise => 0
-        )
-        controller('OpenflowErrorController').should_receive(:openflow_error) do | datapath_id, message |
-          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
-      end
-    end
-  end
-
-
-  context 'when #port_mod with an invalid(hw_addr) is sent' do
-    it 'should receive #error(type=Error::OFPET_PORT_MOD_FAILED,code=Error::OFPPMFC_BAD_HW_ADDR)' do
-      class OpenflowErrorController < Controller; end
-      network do
-        vswitch('error-hw-addr') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost 'host2'
-        link 'host1', 'error-hw-addr'
-        link 'host2', 'error-hw-addr'
-      end.run(OpenflowErrorController) do
-        port_mod = Trema::PortMod.new(
-          :port_no => 1,
-          :hw_addr => Trema::Mac.new('11:22:33:44:55:66'),
-          :config => 1,
-          :mask => 1,
-          :advertise => 0
-        )
-        controller('OpenflowErrorController').should_receive(:openflow_error) do | datapath_id, message |
-          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
-      end
-    end
-  end
-
-
-  context 'when #flow_mod(add) message with an invalid(action_port) is sent' do
-    it 'should receive #error(type=Error::OFPET_BAD_ACTION,code=Error::OFPBAC_BAD_OUT_PORT)' do
-      class OpenflowErrorController < Controller; end
-      network do
-        vswitch('error-out-port') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost 'host2'
-        link 'host1', 'error-port'
-        link 'host2', 'error-port'
-      end.run(OpenflowErrorController) do
-        controller('OpenflowErrorController').should_receive(:openflow_error) do | datapath_id, message |
-          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
-      end
-    end
-  end
-
-
-  context 'when an unsupported message is sent' do
-    it 'should receive an openflow error with valid attributes' do
-      class OpenflowController < Controller; end
-      network do
-        vswitch('error-request') { datapath_id 0xabc }
-      end.run(OpenflowController) do
-        queue_get_config_request = Trema::QueueGetConfigRequest.new(:port => 1)
-        controller('OpenflowController').should_receive(:openflow_error) do | datapath_id, message |
-          expect(message.datapath_id).to eq(0xabc)
-          expect(message.type).to satisfy { | n |
-            n >= 0 && n <= 5
-          }
-          case message.type
-          when 0, 4
-            expect(message.code).to include(0, 1)
-          when 1, 2
-            expect(message.code).to satisfy { | n |
-              n >= 0 && n <= 8
-            }
-          when 3
-            expect(message.code).to satisfy { | n |
-              n >= 0 && n <= 5
-            }
-          when 5
-            expect(message.code).to satisfy { |n|
-              n >= 0 && n <= 3
-            }
-          end
-        end
-        controller('OpenflowController').send_message(0xabc, queue_get_config_request)
-        sleep 2 # FIXME: wait to send_message
-      end
-    end
-  end
-end
-
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End:

data/spec/trema/packet-in_spec.rb

@@ -1,717 +0,0 @@
-# Copyright (C) 2008-2013 NEC Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License, version 2, as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-
-
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-require 'trema'
-
-
-describe Trema::PacketIn do
-  def send_and_wait
-    send_packets 'host1', 'host2'
-    sleep 2
-  end
-
-
-  class PacketInController < Controller; end
-
-  class PacketInSendController < Controller
-    def packet_in(datapath_id, message)
-      send_flow_mod_add(
-                        datapath_id,
-                        :match => Match.from(message),
-                        :actions => Trema::ActionOutput.new(:port => 2)
-                        )
-      send_packet_out(
-                      datapath_id,
-                      :packet_in => message,
-                      :actions => Trema::ActionOutput.new(:port => 2)
-                      )
-    end
-  end
-
-  context 'when instance is created' do
-    it 'should have valid datapath_id and in_port' do
-      network do
-        vswitch('test') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost 'host2'
-        link 'test', 'host1'
-        link 'test', 'host2'
-      end.run(PacketInController) do
-        controller('PacketInController').should_receive(:packet_in) do | datapath_id, message |
-          expect(datapath_id).to eq(0xabc)
-          expect(message.datapath_id).to eq(0xabc)
-          expect(message.in_port).to be > 0
-        end
-        send_and_wait
-      end
-    end
-
-
-    it 'should have vaild user data' do
-      network do
-        vswitch('test') { datapath_id 0xabc }
-        vhost('host1') do
-          mac '00:00:00:00:00:01'
-          ip '192.168.1.1'
-        end
-        vhost('host2') do
-          mac '00:00:00:00:00:02'
-          ip '192.168.1.2'
-        end
-        link 'test', 'host1'
-        link 'test', 'host2'
-      end.run(PacketInController) do
-        controller('PacketInController').should_receive(:packet_in) do | datapath_id, message |
-           # packet_in expected to have data portion.
-          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(Pio::Mac)
-          expect(message.macsa.to_s).to eq('00:00:00:00:00:01')
-          expect(message.macda).to be_instance_of(Pio::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(Pio::IPv4Address)
-          expect(message.ipv4_saddr.to_s).to eq('192.168.1.1')
-          expect(message.ipv4_daddr).to be_instance_of(Pio::IPv4Address)
-          expect(message.ipv4_daddr.to_s).to eq('192.168.1.2')
-        end
-        send_and_wait
-      end
-    end
-  end
-
-  context 'when reading packet content' do
-    it 'should have correct ARP packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost ( 'host2') { mac '00:00:00:00:00:02' }
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # dst
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # src
-          0x08, 0x06, # ether type
-          # arp
-          0x00, 0x01, # hardware type
-          0x08, 0x00, # protocol type
-          0x06, # hardware address length
-          0x04, # protocol address length
-          0x00, 0x02, # operation
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # sender hardware address
-          0xc0, 0xa8, 0x00, 0x01, # sender protocol address
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # target hardware address
-          0xc0, 0xa8, 0x00, 0x02, # target protocol address
-          # padding to 64 bytes
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_false
-          expect(message.arp?).to be_true
-          expect(message.rarp?).to be_false
-          expect(message.ipv4?).to be_false
-          expect(message.lldp?).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.rarp_oper).to be_nil
-          expect(message.rarp_sha).to be_nil
-          expect(message.rarp_spa).to be_nil
-          expect(message.rarp_tha).to be_nil
-          expect(message.rarp_tpa).to be_nil
-          expect(message.rarp_request?).to be_false
-          expect(message.rarp_reply?).to be_false
-
-          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(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-
-    it 'should have correct RARP packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost ( 'host2') { mac '00:00:00:00:00:02' }
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # dst
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # src
-          0x80, 0x35, # ether type
-          # rarp
-          0x00, 0x01, # hardware type
-          0x08, 0x00, # protocol type
-          0x06, # hardware address length
-          0x04, # protocol address length
-          0x00, 0x03, # operation
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # sender hardware address
-          0xc0, 0xa8, 0x00, 0x01, # sender protocol address
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # target hardware address
-          0x00, 0x00, 0x00, 0x00, # target protocol address
-          # padding to 64 bytes
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_false
-          expect(message.arp?).to be_false
-          expect(message.rarp?).to be_true
-          expect(message.ipv4?).to be_false
-          expect(message.lldp?).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 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
-          expect(message.arp_request?).to be_false
-          expect(message.arp_reply?).to be_false
-
-          expect(message.rarp_oper).to eq(3)
-          expect(message.rarp_sha.to_s).to eq('00:00:00:00:00:01')
-          expect(message.rarp_spa.to_s).to eq('192.168.0.1')
-          expect(message.rarp_tha.to_s).to eq('00:00:00:00:00:02')
-          expect(message.rarp_tpa.to_s).to eq('0.0.0.0')
-          expect(message.rarp_request?).to be_true
-          expect(message.rarp_reply?).to be_false
-
-          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(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-
-    it 'should have correct TCP packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost ( 'host2') do
-          ip '192.168.0.2'
-          netmask '255.255.0.0'
-          mac '00:00:00:00:00:02'
-        end
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # dst
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # src
-          0x08, 0x00, # ether type
-          # ipv4
-          0x45, 0x00, # version
-          0x00, 0x28, # length
-          0x00, 0x00,
-          0x00, 0x00,
-          0x00,       # ttl
-          0x06,       # protocol
-          0x39, 0x7d, # checksum
-          0xc0, 0xa8, 0x00, 0x01, # src
-          0xc0, 0xa8, 0x00, 0x02, # dst
-          # tcp
-          0x00, 0x01, # src port
-          0x00, 0x02, # dst port
-          0x00, 0x00, 0x00, 0x00, # sequence number
-          0x00, 0x00, 0x00, 0x00, # acknowledgement number
-          0x50, # data offset,
-          0x00, # flags
-          0x00, 0x00, # window size
-          0x2e, 0x86, # checksum
-          0x00, 0x00, # urgent pointer
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_false
-          expect(message.arp?).to be_false
-          expect(message.rarp?).to be_false
-          expect(message.ipv4?).to be_true
-          expect(message.lldp?).to be_false
-          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
-
-          expect(message.rarp_oper).to be_nil
-          expect(message.rarp_sha).to be_nil
-          expect(message.rarp_spa).to be_nil
-          expect(message.rarp_tha).to be_nil
-          expect(message.rarp_tpa).to be_nil
-        end
-
-        controller('PacketInSendController').send_packet_out(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-
-    it 'should have correct UDP packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost ( 'host2') do
-          ip '192.168.0.2'
-          netmask '255.255.0.0'
-          mac '00:00:00:00:00:02'
-        end
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # dst
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # src
-          0x08, 0x00, # ether type
-          # ipv4
-          0x45, 0x00, # version
-          0x00, 0x32, # length
-          0x00, 0x00,
-          0x00, 0x00,
-          0x40,       # ttl
-          0x11,       # protocol
-          0xf9, 0x68, # checksum
-          0xc0, 0xa8, 0x00, 0x01, # src
-          0xc0, 0xa8, 0x00, 0x02, # dst
-          # udp
-          0x00, 0x01, # src port
-          0x00, 0x02, # dst port
-          0x00, 0x1e, # length
-          0x00, 0x00, # checksum
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_false
-          expect(message.arp?).to be_false
-          expect(message.rarp?).to be_false
-          expect(message.ipv4?).to be_true
-          expect(message.lldp?).to be_false
-          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(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-
-    it 'should have correct VLAN and ICMPv4 packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost ( 'host2') do
-          ip '192.168.32.1'
-          netmask '255.255.255.0'
-          mac '00:00:00:00:00:02'
-        end
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          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
-          # ipv4
-          0x45, 0x00, # version
-          0x00, 0x3c, # length
-          0x8c, 0x1b,
-          0x00, 0x00,
-          0x80,       # ttl
-          0x01,       # protocol
-          0xed, 0x09, # checksum
-          0xc0, 0xa8, 0x20, 0x4a, # src
-          0xc0, 0xa8, 0x20, 0x01, # dst
-          # icmp
-          0x08, # type
-          0x00, # code
-          0xe9, 0x5b, # checksum
-          0x04, 0x00, # id
-          0x60, 0x00, # seq
-          0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-          0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
-          0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x61,
-          0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_true
-          expect(message.arp?).to be_false
-          expect(message.rarp?).to be_false
-          expect(message.ipv4?).to be_true
-          expect(message.lldp?).to be_false
-          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(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-
-    it 'should have correct IGMP packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost 'host2'
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          0x01, 0x00, 0x5e, 0x00, 0x00, 0x01, # dst
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x01, # src
-          0x08, 0x00, # ether type
-          # ipv4
-          0x46, 0xc0, # version
-          0x00, 0x20, # length
-          0x3a, 0xea,
-          0x00, 0x00,
-          0x01,       # ttl
-          0x02,       # protocol
-          0xe4, 0x58, # checksum
-          0xc0, 0xa8, 0x64, 0x2b, # src
-          0xe0, 0x00, 0x00, 0x01, # dst
-          0x94, 0x04, 0x00, 0x00,
-          # igmp
-          0x11, # type
-          0x64, # code
-          0xee, 0x9b, # checksum
-          0x00, 0x00, 0x00, 0x00,
-          0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-          0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
-          0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x61,
-          0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_false
-          expect(message.arp?).to be_false
-          expect(message.rarp?).to be_false
-          expect(message.ipv4?).to be_true
-          expect(message.lldp?).to be_false
-          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(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-
-    it 'should have correct LLDP packet fields' do
-      network do
-        vswitch('packet-in') { datapath_id 0xabc }
-        vhost 'host1'
-        vhost 'host2'
-        link 'host1', 'packet-in'
-        link 'host2', 'packet-in'
-      end.run(PacketInSendController) do
-        data = [
-          0x01, 0x80, 0xC2, 0x00, 0x00, 0x0E, # dst
-          0x00, 0x00, 0x00, 0x00, 0x00, 0x02, # src
-          0x88, 0xcc, # ether type
-          0x02, 0x05, 0x07, 0x30, 0x78, 0x65, 0x31, # Chasis ID
-          0x04, 0x02, 0x07, 0x31, # Port ID
-          0x06, 0x02, 0x00, 0xb4, # TTL
-          0x00, 0x00, # EOF
-          0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-          0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-          0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-          0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-          0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
-          0xa5, 0xa5, 0xa5, 0xa5, 0xa5
-        ].pack('C*')
-        controller('PacketInSendController').should_receive(:packet_in) do | datapath_id, message |
-          expect(message.in_port).to be > 0
-          expect(message.vtag?).to be_false
-          expect(message.arp?).to be_false
-          expect(message.rarp?).to be_false
-          expect(message.ipv4?).to be_false
-          expect(message.lldp?).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_false
-        end
-
-        controller('PacketInSendController').send_packet_out(
-          0xabc,
-          :data => data,
-          :actions => Trema::ActionOutput.new(:port => Controller::OFPP_CONTROLLER)
-        )
-        sleep 2
-      end
-    end
-  end
-end
-
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End: