openflow15_test.go

package libOpenflow

import (
	"bytes"
	"encoding/hex"
	"fmt"
	"log"
	"net"
	"os"
	"os/exec"
	"testing"

	"antrea.io/libOpenflow/common"
	"antrea.io/libOpenflow/openflow15"
	"antrea.io/libOpenflow/util"
)

var eth_arp_payload string = "fffffffffffff26626a37d0c08060001" +
	"080006040001f26626a37d0c410a0a6a" +
	"000000000000410a14a4000000000000" +
	"000000000000000000000000"

var prog_started bool = true

type MyError struct {
	s string
}

func (e MyError) Error() string {
	return e.s
}

var f *os.File

func validateOpenflowMessage(m util.Message, n util.Message) error {
	b, err := m.MarshalBinary()
	if err != nil {
		return err
	}

	if prog_started {
		prog_started = false
		os.Remove("/tmp/p1.pcap")
		os.Remove("/tmp/p1.txt")
		var err error
		f, err = os.OpenFile("/tmp/p1.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
		if err != nil {
			var myErr MyError
			myErr.s = "Unable to open /tmp/p1.txt file"
			return myErr
		}
	}

	_, err = f.Write([]byte(hex.Dump(b)))
	if err != nil {
		log.Fatal(err)
	}
	s := "    \n"
	f.Write([]byte(s))

	cmdExists := false
	_, e := exec.LookPath("text2pcap")
	if e == nil {
		cmdExists = true
		// -e 0x800 -i 6 -T 6653,6653 to generate dummy ethernet/ip/tcp headers
		cmd := exec.Command("text2pcap", "-e 0x800", "-i 6", "-T 6653,6653", "/tmp/p1.txt", "/tmp/p1.pcap")
		err = cmd.Run()
		if err != nil {
			fmt.Printf("text2pcap did not run successfully, error code: %v", err)
			return err
		}
	}

	/* Now Unmarshal the byte slice generated by "m.MarshalBinary()"
	 * It should yield the original constructed message.
	 * Then Marshal again and compare the resulting byte slices
	 */
	err = n.UnmarshalBinary(b)
	if err != nil {
		fmt.Printf("UnmarshalBinary failed with error code: %v", err)
		return err
	}

	x, err := n.MarshalBinary()
	if err != nil {
		fmt.Printf("MarshalBinary failed with error code: %v", err)
		return err
	}

	// Debug block
	if false { // set to true if you want to write second pass message to be
		// written to the pcap file as well.
		_, err = f.Write([]byte(hex.Dump(x)))
		if err != nil {
			fmt.Printf("Write to file /tmp/p1.txt failed, err code: %v", err)
			return err
		}
		s = "    \n"
		f.Write([]byte(s))
		if cmdExists {
			cmd := exec.Command("text2pcap", "-e 0x800", "-i 6", "-T 6653,6653", "/tmp/p1.txt", "/tmp/p1.pcap")
			err = cmd.Run()
			if err != nil {
				fmt.Printf("text2pcap did not run successfully, error code: %v", err)
				return err
			}
		}
	}

	if bytes.Equal(b, x) == false {
		var myErr MyError
		myErr.s = "MarshalBinary bytes don't match with original"
		return myErr
	}
	return nil
}

func Test_PacketOut(t *testing.T) {
	pktOut := openflow15.NewPacketOut()

	/* Match fields */
	ofMatch := openflow15.NewMatch()

	pktOut.Match = *ofMatch
	_, err := pktOut.Match.MarshalBinary()
	if err != nil {
		t.Errorf("pktOut Match MarshalBinary failed with error code: %v", err)
	}

	/* Action */
	aOut := openflow15.NewActionOutput(30)
	pktOut.AddAction(aOut)

	/* Data */
	var b []byte
	b, err = hex.DecodeString(eth_arp_payload)
	if err != nil {
		t.Errorf("hex DecodeString failed with error code: %v", err)
	}
	dataARP := util.NewBuffer(b)
	pktOut.Data = dataARP

	n := openflow15.NewPacketOut()
	err = validateOpenflowMessage(pktOut, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_PacketIn(t *testing.T) {
	pktIn := openflow15.NewPacketIn()
	pktIn.TotalLen = (uint16)(len(eth_arp_payload) / 2)
	pktIn.Reason = openflow15.R_INVALID_TTL
	pktIn.TableId = 100
	pktIn.Cookie = 0x08090a0b0c0d0e0f

	/* Data */
	a, _ := hex.DecodeString(eth_arp_payload)
	dataARP := util.NewBuffer(a)
	pktIn.Data = dataARP

	n := openflow15.NewPacketIn()
	err := validateOpenflowMessage(pktIn, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_GetConfigRequest(t *testing.T) {
	getSCReq := openflow15.NewConfigRequest()
	n := openflow15.NewConfigRequest()
	err := validateOpenflowMessage(getSCReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_GetConfigReply(t *testing.T) {
	getCReply := openflow15.NewGetConfigReply()
	getCReply.Flags = 2
	getCReply.MissSendLen = 60
	n := openflow15.NewGetConfigReply()
	err := validateOpenflowMessage(getCReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_SetConfig(t *testing.T) {
	setConfig := openflow15.NewSetConfig()
	setConfig.Flags = 3
	setConfig.MissSendLen = 40
	n := openflow15.NewSetConfig()
	err := validateOpenflowMessage(setConfig, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_EchoRequest(t *testing.T) {
	echoReq := openflow15.NewEchoRequest()
	n := new(common.Header)
	err := validateOpenflowMessage(echoReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_EchoReply(t *testing.T) {
	echoReply := openflow15.NewEchoReply()
	n := new(common.Header)
	err := validateOpenflowMessage(echoReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_Hello(t *testing.T) {
	hello, err := common.NewHello(6)
	if err != nil {
		t.Errorf("NewHello failed with error code: %v", err)
	}
	n := new(common.Hello)
	err = validateOpenflowMessage(hello, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_FeaturesRequest(t *testing.T) {
	feauturesReq := openflow15.NewFeaturesRequest()
	n := new(common.Header)
	err := validateOpenflowMessage(feauturesReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_FeaturesReply(t *testing.T) {
	var err error
	feauturesReply := openflow15.NewFeaturesReply()
	feauturesReply.DPID, err = net.ParseMAC("01:02:03:04:05:06:07:08")
	if err != nil {
		t.Errorf("ParseMAC failed with error code: %v", err)
	}
	feauturesReply.Buffers = 1024
	feauturesReply.NumTables = 100
	feauturesReply.AuxilaryId = 10
	feauturesReply.Capabilities = openflow15.C_FLOW_STATS |
		openflow15.C_TABLE_STATS |
		openflow15.C_PORT_STATS |
		openflow15.C_BUNDLES |
		openflow15.C_FLOW_MONITORING

	n := openflow15.NewFeaturesReply()
	err = validateOpenflowMessage(feauturesReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_BarrierRequest(t *testing.T) {
	barrierReq := openflow15.NewBarrierRequest()
	n := new(common.Header)
	err := validateOpenflowMessage(barrierReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_BarrierReply(t *testing.T) {
	barrierReply := openflow15.NewBarrierReply()
	n := new(common.Header)
	err := validateOpenflowMessage(barrierReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_Error(t *testing.T) {
	e := openflow15.NewErrorMsg()
	e.Type = openflow15.ET_FLOW_MONITOR_FAILED
	e.Code = openflow15.MOFC_MONITOR_EXISTS

	n := openflow15.NewErrorMsg()
	err := validateOpenflowMessage(e, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_FlowRemoved(t *testing.T) {
	flowRem := openflow15.NewFlowRemoved()
	flowRem.TableId = 100
	flowRem.Reason = openflow15.RR_DELETE
	flowRem.Priority = 200
	flowRem.IdleTimeout = 5000
	flowRem.HardTimeout = 50000
	flowRem.Cookie = 0x0c0000000000000e

	statFieldDuration := openflow15.NewDurationStatField()
	statFieldDuration.Sec = 1000
	statFieldDuration.NSec = 2000
	flowRem.Stats.Fields = append(flowRem.Stats.Fields, statFieldDuration)

	statFieldIdle := openflow15.NewIdleTimeStatField()
	statFieldIdle.Sec = 300
	statFieldIdle.NSec = 400
	flowRem.Stats.Fields = append(flowRem.Stats.Fields, statFieldIdle)

	statFieldPacketCount := openflow15.NewPacketCountStatField()
	statFieldPacketCount.Count = 500
	flowRem.Stats.Fields = append(flowRem.Stats.Fields, statFieldPacketCount)

	statFieldByteCount := openflow15.NewByteCountStatField()
	statFieldByteCount.Count = 500 * 8
	flowRem.Stats.Fields = append(flowRem.Stats.Fields, statFieldByteCount)

	n := openflow15.NewFlowRemoved()
	err := validateOpenflowMessage(flowRem, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_RoleRequest(t *testing.T) {
	roleReq := openflow15.NewRoleRequest()
	roleReq.Role = openflow15.CR_ROLE_MASTER
	roleReq.Shortid = 10
	roleReq.GenerationId = 1020304050

	n := openflow15.NewRoleRequest()
	err := validateOpenflowMessage(roleReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_RoleReply(t *testing.T) {
	roleReply := openflow15.NewRoleReply()
	roleReply.Role = openflow15.CR_ROLE_SLAVE
	roleReply.Shortid = 10
	roleReply.GenerationId = 1020304050

	n := openflow15.NewRoleReply()
	err := validateOpenflowMessage(roleReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_GetAsyncReq(t *testing.T) {
	getAsyncReq := openflow15.NewGetAsyncRequest()
	n := openflow15.NewGetAsyncRequest()
	err := validateOpenflowMessage(getAsyncReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_GetAsyncReply(t *testing.T) {
	getAsyncReply := openflow15.NewGetAsyncReply()
	p := new(openflow15.AsyncConfigPropReasons)
	p.Header.Type = openflow15.ACPT_FLOW_REMOVED_MASTER
	p.Mask = 4
	getAsyncReply.Properties = append(getAsyncReply.Properties, p)
	n := openflow15.NewGetAsyncReply()
	err := validateOpenflowMessage(getAsyncReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_SetAsync(t *testing.T) {
	setAsync := openflow15.NewSetAsync()

	p := new(openflow15.AsyncConfigPropReasons)
	p.Header.Type = openflow15.ACPT_FLOW_REMOVED_SLAVE
	p.Mask = 4
	setAsync.Properties = append(setAsync.Properties, p)

	n := openflow15.NewSetAsync()
	err := validateOpenflowMessage(setAsync, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_RoleStatus(t *testing.T) {
	roleStatus := openflow15.NewRoleStatus()
	roleStatus.Role = openflow15.CR_ROLE_MASTER
	roleStatus.Reason = openflow15.CRR_CONFIG
	roleStatus.GenerationId = 0x0102030405060708

	p := new(openflow15.PropExperimenter)
	p.Header.Type = openflow15.RPT_EXPERIMENTER
	p.Experimenter = 0x01010101
	p.ExpType = 0x09090909
	b := uint32(0x0e0e0e0e)
	p.Data = append(p.Data, b)
	roleStatus.Properties = append(roleStatus.Properties, p)

	n := openflow15.NewRoleStatus()
	err := validateOpenflowMessage(roleStatus, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_TableStatus(t *testing.T) {
	tableStatus := openflow15.NewTableStatus()
	tableStatus.Reason = openflow15.TR_VACANCY_DOWN
	tableStatus.Table.TableId = 100
	tableStatus.Table.Config = openflow15.TC_EVICTION

	p := openflow15.NewTableModPropEviction()
	p.Flags = openflow15.TMPEF_IMPORTANCE
	tableStatus.Table.Properties = append(tableStatus.Table.Properties, p)

	n := openflow15.NewTableStatus()
	err := validateOpenflowMessage(tableStatus, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_RequestForward(t *testing.T) {
	reqFwd := openflow15.NewRequestForward()
	reqFwd.Request = openflow15.NewOfp15Header()
	reqFwd.Request.Type = openflow15.Type_FlowMod
	reqFwd.Request.Length = 8
	reqFwd.Request.Xid = 0x12345678

	n := openflow15.NewRequestForward()
	err := validateOpenflowMessage(reqFwd, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_BundleCtrl(t *testing.T) {
	bundleCtrl := openflow15.NewBundleCtrl(0, 0, 0)
	bundleCtrl.BundleId = 10
	bundleCtrl.Type = openflow15.BCT_COMMIT_REQUEST
	bundleCtrl.Flags = openflow15.BF_ORDERED |
		openflow15.BF_TIME | openflow15.BF_ATOMIC

	p := new(openflow15.BundlePropTime)
	p.Header.Type = openflow15.BPT_TIME
	p.SchedTime.Seconds = 20
	p.SchedTime.NanoSeconds = 30000
	bundleCtrl.Properties = append(bundleCtrl.Properties, p)

	n := openflow15.NewBundleCtrl(0, 0, 0)
	err := validateOpenflowMessage(bundleCtrl, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_BundleAdd(t *testing.T) {
	bundleAdd := openflow15.NewBndleAdd(0x01020304, openflow15.BF_ORDERED)
	//bundleAdd.BundleId = 0x01020304
	//bundleAdd.Flags = openflow15.BF_ORDERED
	bundleAdd.Message = openflow15.NewFeaturesRequest()

	p := new(openflow15.BundlePropTime)
	p.Header.Type = openflow15.BPT_TIME
	p.SchedTime.Seconds = 20
	p.SchedTime.NanoSeconds = 30000
	bundleAdd.Properties = append(bundleAdd.Properties, p)

	n := openflow15.NewBndleAdd(0, 0)
	err := validateOpenflowMessage(bundleAdd, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_ControllerStatus(t *testing.T) {
	ctrlStatus := openflow15.NewControllerStatusHeader()
	ctrlStatus.Status.ShortId = 5
	ctrlStatus.Status.Role = openflow15.CR_ROLE_EQUAL
	ctrlStatus.Status.Reason = openflow15.CSR_CHANNEL_STATUS
	ctrlStatus.Status.ChannelStatus = openflow15.CT_STATUS_DOWN

	p := new(openflow15.ControllerStatusPropUri)
	s := "tls:192.168.34.23:6653"
	p.Uri = append(p.Uri, s...)
	ctrlStatus.Status.Properties = append(ctrlStatus.Status.Properties, p)

	n := openflow15.NewControllerStatusHeader()
	err := validateOpenflowMessage(ctrlStatus, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_FlowMod(t *testing.T) {
	flowMod := openflow15.NewFlowMod()
	flowMod.Cookie = 0x0102030405060708
	flowMod.CookieMask = 0xffffffffffffffff
	flowMod.TableId = 100

	f := openflow15.NewInPortField(5)
	flowMod.Match.AddField(*f)

	i := openflow15.NewInstrApplyActions()
	a := openflow15.NewActionOutput(10)
	i.AddAction(a, false)
	flowMod.AddInstruction(i)

	n := openflow15.NewFlowMod()
	err := validateOpenflowMessage(flowMod, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_GroupMod(t *testing.T) {
	groupMod := openflow15.NewGroupMod()
	groupMod.GroupId = 5
	groupMod.CommandBucketId = 4

	bkt := openflow15.NewBucket(1)
	a := openflow15.NewActionOutput(10)
	bkt.AddAction(a)

	prop := openflow15.NewGroupBucketPropWeight(20)
	bkt.AddProperty(prop)

	groupMod.AddBucket(*bkt)

	n := openflow15.NewGroupMod()
	err := validateOpenflowMessage(groupMod, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_PortMod(t *testing.T) {
	portMod := openflow15.NewPortMod(14)
	portMod.HWAddr = []byte{0x00, 0x50, 0x56, 0x04, 0x05, 0x06}
	portMod.Config = openflow15.PC_NO_RECV
	portMod.Mask = openflow15.PC_NO_RECV

	prop := openflow15.NewPortModPropEthernet(openflow15.PF_100MB_HD)
	portMod.Properties = append(portMod.Properties, prop)

	n := openflow15.NewPortMod(14)
	err := validateOpenflowMessage(portMod, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_PortStatus(t *testing.T) {
	portStatus := openflow15.NewPortStatus()
	portStatus.Reason = openflow15.PR_ADD

	portStatus.Desc = *openflow15.NewPort(15)
	var err error
	portStatus.Desc.HWAddr, err = net.ParseMAC("00:50:56:04:05:06")
	if err != nil {
		t.Errorf("ParseMAC failed with error code: %v", err)
	}
	copy(portStatus.Desc.Name, []byte("eth1"))
	portStatus.Desc.Config = openflow15.PC_PORT_DOWN
	portStatus.Desc.State = openflow15.PS_BLOCKED

	ethProp := openflow15.NewPortDescPropEthernet()
	ethProp.Curr = openflow15.PF_100MB_HD
	ethProp.Advertised = openflow15.PF_1GB_HD
	ethProp.Supported = openflow15.PF_100MB_FD | openflow15.PF_1GB_HD | openflow15.PF_40GB_FD
	ethProp.Peer = openflow15.PF_100MB_FD
	ethProp.CurrSpeed = 10000000
	ethProp.MaxSpeed = 10000000

	portStatus.Desc.Properties = append(portStatus.Desc.Properties, ethProp)

	n := openflow15.NewPortStatus()
	err = validateOpenflowMessage(portStatus, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_TableMod(t *testing.T) {
	tableMod := openflow15.NewTableMod()
	tableMod.TableId = 10
	tableMod.Config = openflow15.TC_EVICTION

	p := openflow15.NewTableModPropEviction()
	p.Flags = openflow15.TMPEF_IMPORTANCE
	tableMod.Properties = append(tableMod.Properties, p)

	n := openflow15.NewTableMod()
	err := validateOpenflowMessage(tableMod, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MeterMod(t *testing.T) {
	meterMod := openflow15.NewMeterMod()
	meterMod.Command = openflow15.MC_ADD
	meterMod.Flags = openflow15.MF_PKTPS
	meterMod.MeterId = 5

	drop := openflow15.NewMeterBandDrop()
	meterMod.MeterBands = append(meterMod.MeterBands, drop)

	n := openflow15.NewMeterMod()
	err := validateOpenflowMessage(meterMod, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartDescRequest(t *testing.T) {
	mpDescReq := openflow15.NewMpRequest(openflow15.MultipartType_Desc)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartDescReply(t *testing.T) {
	mpDescReply := openflow15.NewMpReply(openflow15.MultipartType_Desc)

	desc := openflow15.NewDescStats()
	copy(desc.MfrDesc, []byte("Open vSwitch"))
	copy(desc.HWDesc, []byte("Open vSwitch HW"))
	copy(desc.SWDesc, []byte("Open vSwitch SW"))
	copy(desc.SerialNum, []byte("0000-0000-0000"))
	copy(desc.DPDesc, []byte("OVS Data Path"))
	mpDescReply.Body = append(mpDescReply.Body, desc)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartFlowDescRequest(t *testing.T) {
	mpFlowDescReq := openflow15.NewMpRequest(openflow15.MultipartType_FlowDesc)

	flowStatsReq := openflow15.NewFlowStatsRequest()
	flowStatsReq.TableId = 10
	flowStatsReq.OutPort = 20
	f := openflow15.NewInPortField(5)
	flowStatsReq.Match.AddField(*f)
	mpFlowDescReq.Body = append(mpFlowDescReq.Body, flowStatsReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpFlowDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartFlowDescReply(t *testing.T) {
	mpFlowDescReply := openflow15.NewMpReply(openflow15.MultipartType_FlowDesc)

	flowDesc := openflow15.NewFlowDesc()
	flowDesc.TableId = 10
	flowDesc.Priority = 5000
	flowDesc.IdleTimeout = 2000
	flowDesc.HardTimeout = 5000
	flowDesc.Flags = openflow15.FF_SEND_FLOW_REM
	flowDesc.Importance = 100

	durStatField := openflow15.NewDurationStatField()
	durStatField.Sec = 100
	durStatField.NSec = 200
	flowDesc.Stats.AddField(durStatField)

	i := openflow15.NewInstrApplyActions()
	a := openflow15.NewActionOutput(10)
	i.AddAction(a, false)
	flowDesc.AddInstruction(i)

	mpFlowDescReply.Body = append(mpFlowDescReply.Body, flowDesc)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpFlowDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartAggregateStatsRequest(t *testing.T) {
	mpAggStatsReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_AggregateStats)

	aggStatsReq := openflow15.NewAggregateStatsRequest()
	aggStatsReq.TableId = 10
	aggStatsReq.OutPort = 20
	aggStatsReq.Cookie = 0x0102030405060708
	aggStatsReq.CookieMask = 0xffffffffffffffff

	f := openflow15.NewInPortField(5)
	aggStatsReq.Match.AddField(*f)

	mpAggStatsReq.Body = append(mpAggStatsReq.Body, aggStatsReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpAggStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartAggregateStatsReply(t *testing.T) {
	mpAggStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_AggregateStats)

	aggStatsReply := openflow15.NewAggregateStatsReply()
	idleStatField := openflow15.NewIdleTimeStatField()
	idleStatField.Sec = 100
	idleStatField.NSec = 200
	aggStatsReply.Stats.AddField(idleStatField)

	mpAggStatsReply.Body = append(mpAggStatsReply.Body, aggStatsReply)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpAggStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartTableStatsRequest(t *testing.T) {
	mpTableStatsReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_TableStats)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpTableStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartTableStatsReply(t *testing.T) {
	mpTableStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_TableStats)

	tableStats := openflow15.NewTableStats()
	tableStats.TableId = 10
	tableStats.ActiveCount = 2000
	tableStats.LookupCount = 1000
	tableStats.MatchedCount = 500
	mpTableStatsReply.Body = append(mpTableStatsReply.Body, tableStats)

	tableStats = openflow15.NewTableStats()
	tableStats.TableId = 20
	tableStats.ActiveCount = 5000
	tableStats.LookupCount = 4000
	tableStats.MatchedCount = 900
	mpTableStatsReply.Body = append(mpTableStatsReply.Body, tableStats)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpTableStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartPortStatsRequest(t *testing.T) {
	mpPortStatsReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_Port)

	portStatsReq := openflow15.NewPortStatsRequest(1)
	mpPortStatsReq.Body = append(mpPortStatsReq.Body, portStatsReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpPortStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartPortStatsReply(t *testing.T) {
	mpPortStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_Port)

	portStats := openflow15.NewPortStats(1)
	portStats.DurationSec = 1000
	portStats.RxPackets = 1234
	portStats.TxPackets = 4321
	portStats.RxBytes = 12340
	portStats.TxBytes = 43210
	portStats.RxDropped = 100
	portStats.TxDropped = 200
	portStats.RxErrors = 300
	portStats.TxErrors = 400

	ethProp := openflow15.NewPortStatsPropEthernet()
	ethProp.RxFrameErr = 100
	ethProp.RxOverErr = 200
	ethProp.RxCrcErr = 10
	ethProp.Collisions = 20

	portStats.Properties = append(portStats.Properties, ethProp)
	mpPortStatsReply.Body = append(mpPortStatsReply.Body, portStats)

	portStats = openflow15.NewPortStats(2)
	portStats.DurationSec = 2000
	portStats.RxPackets = 1234
	portStats.TxPackets = 4321
	portStats.RxBytes = 12340
	portStats.TxBytes = 43210
	portStats.RxDropped = 100
	portStats.TxDropped = 200
	portStats.RxErrors = 300
	portStats.TxErrors = 400

	opticalProp := openflow15.NewPortStatsPropOptical()
	opticalProp.Flags = openflow15.OSF_RX_TUNE | openflow15.OSF_TX_TUNE |
		openflow15.OSF_TX_PWR | openflow15.OSF_RX_PWR
	opticalProp.TxFreqLmda = 200
	opticalProp.TxOffset = 10
	opticalProp.TxGridSpan = 20
	opticalProp.RxFreqLmda = 300
	opticalProp.RxOffset = 60
	opticalProp.RxGridSpan = 70
	opticalProp.TxPwr = 10
	opticalProp.RxPwr = 20
	opticalProp.BiasCurrent = 10
	opticalProp.Temperature = 60

	portStats.Properties = append(portStats.Properties, opticalProp)
	mpPortStatsReply.Body = append(mpPortStatsReply.Body, portStats)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpPortStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartQueueStatsRequest(t *testing.T) {
	mpQueueStatsReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_QueueStats)

	queueStatsReq := openflow15.NewQueueStatsRequest()
	queueStatsReq.PortNo = 10
	queueStatsReq.QueueId = 20
	mpQueueStatsReq.Body = append(mpQueueStatsReq.Body, queueStatsReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpQueueStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartQueueStatsReply(t *testing.T) {
	mpQueueStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_QueueStats)

	queueStats := openflow15.NewQueueStats()
	queueStats.PortNo = 10
	queueStats.QueueId = 20
	queueStats.TxBytes = 20000
	queueStats.TxPackets = 30000
	queueStats.TxErrors = 100
	queueStats.DurationSec = 5000
	queueStats.DurationNSec = 50
	mpQueueStatsReply.Body = append(mpQueueStatsReply.Body, queueStats)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpQueueStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartGroupStatsRequest(t *testing.T) {
	mpGroupStatsReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_GroupStats)

	groupMPReq := openflow15.NewGroupMultipartRequest(4)
	mpGroupStatsReq.Body = append(mpGroupStatsReq.Body, groupMPReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpGroupStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartGroupStatsReply(t *testing.T) {
	mpGroupStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_GroupStats)

	groupStats := openflow15.NewGroupStats()
	groupStats.GroupId = 4
	groupStats.RefCount = 2
	groupStats.PacketCount = 2000
	groupStats.ByteCount = 160000
	groupStats.DurationSec = 500
	groupStats.DurationNSec = 100
	mpGroupStatsReply.Body = append(mpGroupStatsReply.Body, groupStats)

	groupStats = openflow15.NewGroupStats()
	groupStats.GroupId = 5
	groupStats.RefCount = 5
	groupStats.PacketCount = 1234
	groupStats.ByteCount = 1234 * 8
	groupStats.DurationSec = 1000
	groupStats.DurationNSec = 200
	mpGroupStatsReply.Body = append(mpGroupStatsReply.Body, groupStats)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpGroupStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartGroupDescRequest(t *testing.T) {
	mpGroupDescReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_GroupDesc)

	groupMPReq := openflow15.NewGroupMultipartRequest(4)
	mpGroupDescReq.Body = append(mpGroupDescReq.Body, groupMPReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpGroupDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartGroupDescReply(t *testing.T) {
	mpGroupDescReply :=
		openflow15.NewMpReply(openflow15.MultipartType_GroupDesc)

	groupDesc := openflow15.NewGroupDesc()
	groupDesc.Type = openflow15.GT_SELECT
	groupDesc.GroupId = 7

	bkt := openflow15.NewBucket(1)
	a := openflow15.NewActionOutput(10)
	bkt.AddAction(a)
	prop := openflow15.NewGroupBucketPropWeight(20)
	bkt.AddProperty(prop)

	groupDesc.AddBucket(*bkt)
	mpGroupDescReply.Body = append(mpGroupDescReply.Body, groupDesc)

	groupDesc = openflow15.NewGroupDesc()
	groupDesc.Type = openflow15.GT_SELECT
	groupDesc.GroupId = 8
	mpGroupDescReply.Body = append(mpGroupDescReply.Body, groupDesc)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpGroupDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartGroupFeaturesRequest(t *testing.T) {
	mpGroupFeaturesReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_GroupFeatures)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpGroupFeaturesReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartGroupFeaturesReply(t *testing.T) {
	mpGroupFeaturesReply :=
		openflow15.NewMpReply(openflow15.MultipartType_GroupFeatures)

	groupFeatures := openflow15.NewGroupFeatures()
	groupFeatures.Capabilities = openflow15.GFC_SELECT_LIVENESS
	groupFeatures.MaxGroups[0] = 1
	groupFeatures.MaxGroups[1] = 2
	groupFeatures.MaxGroups[2] = 3
	groupFeatures.MaxGroups[3] = 4
	groupFeatures.Actions[0] = 0x00000001
	groupFeatures.Actions[1] = 0x00000002
	groupFeatures.Actions[2] = 0x00000004
	groupFeatures.Actions[3] = 0x0000000f

	mpGroupFeaturesReply.Body = append(mpGroupFeaturesReply.Body, groupFeatures)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpGroupFeaturesReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartMeterStatsRequest(t *testing.T) {
	mpMeterStatsReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_MeterStats)

	meterMPReq := openflow15.NewMeterMultipartRequest(5)
	mpMeterStatsReq.Body = append(mpMeterStatsReq.Body, meterMPReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpMeterStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartMeterStatsReply(t *testing.T) {
	mpMeterStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_MeterStats)

	meterStats := openflow15.NewMeterStats(7)
	meterStats.RefCount = 10
	meterStats.PacketInCount = 3000
	meterStats.ByteInCount = 3000 * 8
	meterStats.DurationSec = 200
	meterStats.DurationNSec = 100

	stats := openflow15.NewMeterBandStats()
	stats.PacketBandCount = 100
	stats.ByteBandCount = 200
	meterStats.AddBandStats(*stats)

	mpMeterStatsReply.Body = append(mpMeterStatsReply.Body, meterStats)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpMeterStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartMeterDescRequest(t *testing.T) {
	mpMeterDescReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_MeterDesc)

	meterMPReq := openflow15.NewMeterMultipartRequest(5)
	mpMeterDescReq.Body = append(mpMeterDescReq.Body, meterMPReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpMeterDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartMeterDescReply(t *testing.T) {
	mpMeterDescReply :=
		openflow15.NewMpReply(openflow15.MultipartType_MeterDesc)

	meterDesc := openflow15.NewMeterDesc(9)
	meterDesc.Flags = openflow15.MF_KBPS

	bandDrop := openflow15.NewMeterBandDrop()
	meterDesc.AddBand(bandDrop)

	bandDSCP := openflow15.NewMeterBandDSCP()
	bandDSCP.PrecLevel = 2
	meterDesc.AddBand(bandDSCP)

	mpMeterDescReply.Body = append(mpMeterDescReply.Body, meterDesc)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpMeterDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartMeterFeaturesRequest(t *testing.T) {
	mpMeterFeaturesReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_MeterFeatures)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpMeterFeaturesReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartMeterFeaturesReply(t *testing.T) {
	mpMeterFeaturesReply :=
		openflow15.NewMpReply(openflow15.MultipartType_MeterFeatures)

	meterFeatures := openflow15.NewMeterFeatures()
	meterFeatures.MaxMeter = 10
	meterFeatures.BandTypes = openflow15.MBT_DSCP_REMARK
	meterFeatures.Capabilities = openflow15.MF_KBPS
	meterFeatures.MaxBands = 20
	meterFeatures.MaxColor = 5
	meterFeatures.Features = openflow15.MFF_ANY_POSITION

	mpMeterFeaturesReply.Body = append(mpMeterFeaturesReply.Body, meterFeatures)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpMeterFeaturesReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartTableFeaturesRequest(t *testing.T) {
	mpTableFeaturesReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_TableFeatures)

	tableFeatures := openflow15.NewTableFeatures(5)
	tableFeatures.Command = openflow15.TFC_ENABLE
	tableFeatures.Features = openflow15.TFF_EGRESS_TABLE
	copy(tableFeatures.Name, []byte("Table-Test"))
	tableFeatures.MetadataMatch = 0xff
	tableFeatures.MetadataWrite = 0xff
	tableFeatures.Capabilities = openflow15.TC_EVICTION
	tableFeatures.MaxEntries = 5000

	instrProp := openflow15.NewInstructionProperty(openflow15.TFPT_INSTRUCTIONS)
	instrId := openflow15.NewInstructionId(openflow15.InstrType_APPLY_ACTIONS)
	instrProp.AddInstructionId(*instrId)

	mpTableFeaturesReq.Body = append(mpTableFeaturesReq.Body, tableFeatures)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpTableFeaturesReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartTableFeaturesReply(t *testing.T) {
	mpTableFeaturesReply :=
		openflow15.NewMpReply(openflow15.MultipartType_TableFeatures)

	tableFeatures := openflow15.NewTableFeatures(5)
	tableFeatures.Command = openflow15.TFC_ENABLE
	tableFeatures.Features = openflow15.TFF_EGRESS_TABLE
	copy(tableFeatures.Name, []byte("Table-Test"))
	tableFeatures.MetadataMatch = 0xff
	tableFeatures.MetadataWrite = 0xff
	tableFeatures.Capabilities = openflow15.TC_EVICTION
	tableFeatures.MaxEntries = 5000

	instrProp := openflow15.NewInstructionProperty(openflow15.TFPT_INSTRUCTIONS)
	instrId := openflow15.NewInstructionId(openflow15.InstrType_APPLY_ACTIONS)
	instrProp.AddInstructionId(*instrId)

	mpTableFeaturesReply.Body = append(mpTableFeaturesReply.Body, tableFeatures)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpTableFeaturesReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartPortDescRequest(t *testing.T) {
	mpPortDescReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_PortDesc)

	portMPReq := openflow15.NewPortMultipartRequest(10)

	mpPortDescReq.Body = append(mpPortDescReq.Body, portMPReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpPortDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartPortDescReply(t *testing.T) {
	mpPortDescReply :=
		openflow15.NewMpReply(openflow15.MultipartType_PortDesc)

	port := openflow15.NewPort(15)
	var err error
	port.HWAddr, err = net.ParseMAC("00:50:56:04:05:06")
	if err != nil {
		t.Errorf("ParseMAC failed with error code: %v", err)
	}
	copy(port.Name, []byte("eth1"))
	port.Config = openflow15.PC_PORT_DOWN
	port.State = openflow15.PS_BLOCKED

	ethProp := openflow15.NewPortDescPropEthernet()
	ethProp.Curr = openflow15.PF_100MB_HD
	ethProp.Advertised = openflow15.PF_1GB_HD
	ethProp.Supported = openflow15.PF_100MB_FD | openflow15.PF_1GB_HD | openflow15.PF_40GB_FD
	ethProp.Peer = openflow15.PF_100MB_FD
	ethProp.CurrSpeed = 10000000
	ethProp.MaxSpeed = 10000000

	port.Properties = append(port.Properties, ethProp)

	mpPortDescReply.Body = append(mpPortDescReply.Body, port)

	n := new(openflow15.MultipartReply)
	err = validateOpenflowMessage(mpPortDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartTableDescRequest(t *testing.T) {
	mpTableDescReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_TableDesc)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpTableDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartTableDescReply(t *testing.T) {
	mpTableDescReply :=
		openflow15.NewMpReply(openflow15.MultipartType_TableDesc)

	tableDesc := openflow15.NewTableDesc(5)
	tableDesc.Config = openflow15.TC_EVICTION

	evicProp := openflow15.NewTableModPropEviction()
	evicProp.Flags = openflow15.TMPEF_IMPORTANCE

	tableDesc.Properties = append(tableDesc.Properties, evicProp)

	mpTableDescReply.Body = append(mpTableDescReply.Body, tableDesc)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpTableDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartQueueDescRequest(t *testing.T) {
	mpQueueDescReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_QueueDesc)

	queueStatsReq := openflow15.NewQueueStatsRequest()
	queueStatsReq.PortNo = 10
	queueStatsReq.QueueId = 20
	mpQueueDescReq.Body = append(mpQueueDescReq.Body, queueStatsReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpQueueDescReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartQueueDescReply(t *testing.T) {
	mpQueueDescReply :=
		openflow15.NewMpReply(openflow15.MultipartType_QueueDesc)

	queueDesc := openflow15.NewQueueDesc(7)
	queueDesc.PortNo = 5

	maxRateProp := openflow15.NewQueueDescPropMaxRate()
	maxRateProp.Rate = 1000

	queueDesc.Properties = append(queueDesc.Properties, maxRateProp)

	mpQueueDescReply.Body = append(mpQueueDescReply.Body, queueDesc)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpQueueDescReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartFlowMonitorRequest(t *testing.T) {
	mpFlowMonReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_FlowMonitor)

	flowMonReq := openflow15.NewFlowMonitorRequest(1)
	flowMonReq.OutPort = 2
	flowMonReq.OutGroup = 3
	flowMonReq.Flags = openflow15.FMF_INITIAL | openflow15.FMF_ADD
	flowMonReq.TableId = 10
	flowMonReq.Command = openflow15.FMC_ADD

	mpFlowMonReq.Body = append(mpFlowMonReq.Body, flowMonReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpFlowMonReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartFlowMonitorReply(t *testing.T) {
	mpFlowMonReply :=
		openflow15.NewMpReply(openflow15.MultipartType_FlowMonitor)

	flowUpdateFull := openflow15.NewFlowUpdateFull(openflow15.FME_INITIAL)
	flowUpdateFull.TableId = 10
	flowUpdateFull.Reason = 0
	flowUpdateFull.IdleTimeout = 1000
	flowUpdateFull.HardTimeout = 2000
	flowUpdateFull.Priority = 5
	flowUpdateFull.Cookie = 0x0102030405060708
	i := openflow15.NewInstrApplyActions()
	a := openflow15.NewActionOutput(10)
	i.AddAction(a, false)
	flowUpdateFull.AddInstruction(i)

	mpFlowMonReply.Body = append(mpFlowMonReply.Body, flowUpdateFull)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpFlowMonReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartFlowStatsRequest(t *testing.T) {
	mpFlowStatsReq := openflow15.NewMpRequest(openflow15.MultipartType_FlowStats)

	flowStatsReq := openflow15.NewFlowStatsRequest()
	flowStatsReq.TableId = 10
	flowStatsReq.OutPort = 20
	flowStatsReq.Cookie = 0x0102030405060708
	flowStatsReq.CookieMask = 0xffffffffffffffff
	//f := openflow15.NewInPortField(5)
	//flowStatsReq.Match.AddField(*f)
	mpFlowStatsReq.Body = append(mpFlowStatsReq.Body, flowStatsReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpFlowStatsReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartFlowStatsReply(t *testing.T) {
	mpFlowStatsReply :=
		openflow15.NewMpReply(openflow15.MultipartType_FlowStats)

	flowStats := openflow15.NewFlowStats()
	flowStats.TableId = 10
	flowStats.Reason = openflow15.FSR_STATS_REQUEST
	flowStats.Priority = 20

	stats := openflow15.NewStats()
	durationStats := openflow15.NewDurationStatField()
	durationStats.Sec = 300
	durationStats.NSec = 600
	stats.Fields = append(stats.Fields, durationStats)
	flowStats.Stats = append(flowStats.Stats, *stats)
	mpFlowStatsReply.Body = append(mpFlowStatsReply.Body, flowStats)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpFlowStatsReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartControllerStatusRequest(t *testing.T) {
	mpControllerStatusReq :=
		openflow15.NewMpRequest(openflow15.MultipartType_ControllerStatus)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpControllerStatusReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartControllerStatusReply(t *testing.T) {
	mpControllerStatusReply :=
		openflow15.NewMpReply(openflow15.MultipartType_ControllerStatus)

	controllerStatus := openflow15.NewControllerStatus()
	controllerStatus.ShortId = 100
	controllerStatus.Role = openflow15.CR_ROLE_MASTER
	controllerStatus.Reason = openflow15.CSR_REQUEST
	controllerStatus.ChannelStatus = openflow15.CT_STATUS_UP

	propUri := openflow15.NewControllerStatusPropUri()
	s := "tls:192.168.34.23:6653"
	propUri.Uri = append(propUri.Uri, s...)

	controllerStatus.Properties = append(controllerStatus.Properties, propUri)
	mpControllerStatusReply.Body = append(mpControllerStatusReply.Body, controllerStatus)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpControllerStatusReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartBundleFeaturesRequest(t *testing.T) {
	mpBundleFeaturesReq := openflow15.NewMpRequest(openflow15.MultipartType_BundleFeatures)

	bundleFeaturesReq := openflow15.NewBundleFeaturesRequest()
	bundleFeaturesReq.FeaturesRequestFlag = openflow15.BF_TIMESTAMP | openflow15.BF_TIME_SET_SCHED

	prop := openflow15.NewBundleFeaturesPropTime()
	prop.SchedAccuracy.Seconds = 100
	prop.SchedAccuracy.NanoSeconds = 200
	prop.SchedMaxFuture.Seconds = 300
	prop.SchedMaxFuture.NanoSeconds = 400
	prop.SchedMaxPast.Seconds = 500
	prop.SchedMaxPast.NanoSeconds = 600
	prop.Timestamp.Seconds = 700
	prop.Timestamp.NanoSeconds = 800

	bundleFeaturesReq.Properties = append(bundleFeaturesReq.Properties, prop)
	mpBundleFeaturesReq.Body = append(mpBundleFeaturesReq.Body, bundleFeaturesReq)

	n := new(openflow15.MultipartRequest)
	err := validateOpenflowMessage(mpBundleFeaturesReq, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}

func Test_MultipartBundleFeaturesReply(t *testing.T) {
	mpBundleFeaturesReply := openflow15.NewMpReply(openflow15.MultipartType_BundleFeatures)

	bundleFeatures := openflow15.NewBundleFeatures()
	bundleFeatures.Capabilities = openflow15.BF_ORDERED

	prop := openflow15.NewBundleFeaturesPropTime()
	prop.SchedAccuracy.Seconds = 100
	prop.SchedAccuracy.NanoSeconds = 200
	prop.SchedMaxFuture.Seconds = 300
	prop.SchedMaxFuture.NanoSeconds = 400
	prop.SchedMaxPast.Seconds = 500
	prop.SchedMaxPast.NanoSeconds = 600
	prop.Timestamp.Seconds = 700
	prop.Timestamp.NanoSeconds = 800

	bundleFeatures.Properties = append(bundleFeatures.Properties, prop)
	mpBundleFeaturesReply.Body = append(mpBundleFeaturesReply.Body, bundleFeatures)

	n := new(openflow15.MultipartReply)
	err := validateOpenflowMessage(mpBundleFeaturesReply, n)
	if err != nil {
		t.Errorf("MarshalBinary failed with error code: %v", err)
	}
}