Example usage for io.netty.buffer UnpooledByteBufAllocator DEFAULT

List of usage examples for io.netty.buffer UnpooledByteBufAllocator DEFAULT

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.buffer.*
  5. UnpooledByteBufAllocator
  6. DEFAULT

Introduction

In this page you can find the example usage for io.netty.buffer UnpooledByteBufAllocator DEFAULT.

Prototype

UnpooledByteBufAllocator DEFAULT

To view the source code for io.netty.buffer UnpooledByteBufAllocator DEFAULT.

Click Source Link

Document

Default instance which uses leak-detection for direct buffers.

Usage

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13InstructionsSerializerTest.java

License:Open Source License

/**
 * Testing instructions translation/*from   w  w w .j  ava  2 s. c  o  m*/
 */
@Test
public void test() {
    List<Instruction> instructions = new ArrayList<>();
    // Goto_table instruction
    InstructionBuilder builder = new InstructionBuilder();
    GotoTableCaseBuilder gotoCaseBuilder = new GotoTableCaseBuilder();
    GotoTableBuilder instructionBuilder = new GotoTableBuilder();
    instructionBuilder.setTableId((short) 5);
    gotoCaseBuilder.setGotoTable(instructionBuilder.build());
    builder.setInstructionChoice(gotoCaseBuilder.build());
    instructions.add(builder.build());
    // Write_metadata instruction
    builder = new InstructionBuilder();
    WriteMetadataCaseBuilder metadataCaseBuilder = new WriteMetadataCaseBuilder();
    WriteMetadataBuilder metadataBuilder = new WriteMetadataBuilder();
    metadataBuilder.setMetadata(ByteBufUtils.hexStringToBytes("00 01 02 03 04 05 06 07"));
    metadataBuilder.setMetadataMask(ByteBufUtils.hexStringToBytes("07 06 05 04 03 02 01 00"));
    metadataCaseBuilder.setWriteMetadata(metadataBuilder.build());
    builder.setInstructionChoice(metadataCaseBuilder.build());
    instructions.add(builder.build());
    // Clear_actions instruction
    builder = new InstructionBuilder();
    builder.setInstructionChoice(new ClearActionsCaseBuilder().build());
    instructions.add(builder.build());
    // Meter instruction
    builder = new InstructionBuilder();
    MeterCaseBuilder meterCaseBuilder = new MeterCaseBuilder();
    MeterBuilder meterBuilder = new MeterBuilder();
    meterBuilder.setMeterId(42L);
    meterCaseBuilder.setMeter(meterBuilder.build());
    builder.setInstructionChoice(meterCaseBuilder.build());
    instructions.add(builder.build());
    // Write_actions instruction
    builder = new InstructionBuilder();
    WriteActionsCaseBuilder writeActionsCaseBuilder = new WriteActionsCaseBuilder();
    WriteActionsBuilder writeActionsBuilder = new WriteActionsBuilder();
    List<Action> actions = new ArrayList<>();
    ActionBuilder actionBuilder = new ActionBuilder();
    OutputActionCaseBuilder caseBuilder = new OutputActionCaseBuilder();
    OutputActionBuilder outputBuilder = new OutputActionBuilder();
    outputBuilder.setPort(new PortNumber(45L));
    outputBuilder.setMaxLength(55);
    caseBuilder.setOutputAction(outputBuilder.build());
    actionBuilder.setActionChoice(caseBuilder.build());
    actions.add(actionBuilder.build());
    actionBuilder = new ActionBuilder();
    SetNwTtlCaseBuilder ttlCaseBuilder = new SetNwTtlCaseBuilder();
    SetNwTtlActionBuilder ttlActionBuilder = new SetNwTtlActionBuilder();
    ttlActionBuilder.setNwTtl((short) 64);
    ttlCaseBuilder.setSetNwTtlAction(ttlActionBuilder.build());
    actionBuilder.setActionChoice(ttlCaseBuilder.build());
    actions.add(actionBuilder.build());
    writeActionsBuilder.setAction(actions);
    writeActionsCaseBuilder.setWriteActions(writeActionsBuilder.build());
    builder.setInstructionChoice(writeActionsCaseBuilder.build());
    instructions.add(builder.build());
    // Apply_actions instruction
    builder = new InstructionBuilder();
    ApplyActionsCaseBuilder applyActionsCaseBuilder = new ApplyActionsCaseBuilder();
    ApplyActionsBuilder applyActionsBuilder = new ApplyActionsBuilder();
    actions = new ArrayList<>();
    actionBuilder = new ActionBuilder();
    PushVlanCaseBuilder vlanCaseBuilder = new PushVlanCaseBuilder();
    PushVlanActionBuilder vlanBuilder = new PushVlanActionBuilder();
    vlanBuilder.setEthertype(new EtherType(new EtherType(14)));
    vlanCaseBuilder.setPushVlanAction(vlanBuilder.build());
    actionBuilder.setActionChoice(vlanCaseBuilder.build());
    actions.add(actionBuilder.build());
    actionBuilder = new ActionBuilder();
    actionBuilder.setActionChoice(new PopPbbCaseBuilder().build());
    actions.add(actionBuilder.build());
    applyActionsBuilder.setAction(actions);
    applyActionsCaseBuilder.setApplyActions(applyActionsBuilder.build());
    builder.setInstructionChoice(applyActionsCaseBuilder.build());
    instructions.add(builder.build());

    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    ListSerializer.serializeList(instructions,
            TypeKeyMakerFactory.createInstructionKeyMaker(EncodeConstants.OF13_VERSION_ID), registry, out);

    Assert.assertEquals("Wrong instruction type", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction length", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction table-id", 5, out.readUnsignedByte());
    out.skipBytes(3);
    Assert.assertEquals("Wrong instruction type", 2, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction length", 24, out.readUnsignedShort());
    out.skipBytes(4);
    byte[] actual = new byte[8];
    out.readBytes(actual);
    Assert.assertEquals("Wrong instruction metadata", "00 01 02 03 04 05 06 07",
            ByteBufUtils.bytesToHexString(actual));
    actual = new byte[8];
    out.readBytes(actual);
    Assert.assertEquals("Wrong instruction metadata-mask", "07 06 05 04 03 02 01 00",
            ByteBufUtils.bytesToHexString(actual));
    Assert.assertEquals("Wrong instruction type", 5, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction length", 8, out.readUnsignedShort());
    out.skipBytes(4);
    Assert.assertEquals("Wrong instruction type", 6, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction length", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction meter-id", 42, out.readUnsignedInt());
    Assert.assertEquals("Wrong instruction type", 3, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction length", 32, out.readUnsignedShort());
    out.skipBytes(4);
    Assert.assertEquals("Wrong action type", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong action length", 16, out.readUnsignedShort());
    Assert.assertEquals("Wrong action type", 45, out.readUnsignedInt());
    Assert.assertEquals("Wrong action type", 55, out.readUnsignedShort());
    out.skipBytes(6);
    Assert.assertEquals("Wrong action type", 23, out.readUnsignedShort());
    Assert.assertEquals("Wrong action length", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong action type", 64, out.readUnsignedByte());
    out.skipBytes(3);
    Assert.assertEquals("Wrong instruction type", 4, out.readUnsignedShort());
    Assert.assertEquals("Wrong instruction length", 24, out.readUnsignedShort());
    out.skipBytes(4);
    Assert.assertEquals("Wrong action type", 17, out.readUnsignedShort());
    Assert.assertEquals("Wrong action length", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong action ethertype", 14, out.readUnsignedShort());
    out.skipBytes(2);
    Assert.assertEquals("Wrong action type", 27, out.readUnsignedShort());
    Assert.assertEquals("Wrong action length", 8, out.readUnsignedShort());
    out.skipBytes(4);
    Assert.assertTrue("Not all data were read", out.readableBytes() == 0);
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializer02Test.java

License:Open Source License

/**
 * Testing serialization of match//from  ww w  .  j  a v  a 2s . com
 */
@Test
public void testEmptyMatch() {
    MatchBuilder builder = new MatchBuilder();
    builder.setType(OxmMatchType.class);
    Match match = builder.build();

    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong match type", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong match length", 4, out.readUnsignedShort());
    Assert.assertTrue("Wrong padding", out.readableBytes() == 4);
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializer02Test.java

License:Open Source License

/**
 * Testing serialization of match/*from ww  w. j  ava2s.  co  m*/
 */
@Test
public void test() {
    MatchBuilder builder = new MatchBuilder();
    builder.setType(OxmMatchType.class);
    List<MatchEntry> entries = new ArrayList<>();
    MatchEntryBuilder entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(InPort.class);
    entryBuilder.setHasMask(false);
    InPortCaseBuilder inPortCaseBuilder = new InPortCaseBuilder();
    InPortBuilder inPortBuilder = new InPortBuilder();
    inPortBuilder.setPortNumber(new PortNumber(42L));
    inPortCaseBuilder.setInPort(inPortBuilder.build());
    entryBuilder.setMatchEntryValue(inPortCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(InPhyPort.class);
    entryBuilder.setHasMask(false);
    InPhyPortCaseBuilder inPhyPortCaseBuilder = new InPhyPortCaseBuilder();
    InPhyPortBuilder inPhyPortBuilder = new InPhyPortBuilder();
    inPhyPortBuilder.setPortNumber(new PortNumber(43L));
    inPhyPortCaseBuilder.setInPhyPort(inPhyPortBuilder.build());
    entryBuilder.setMatchEntryValue(inPhyPortCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Metadata.class);
    entryBuilder.setHasMask(true);
    MetadataCaseBuilder metaCaseBuilder = new MetadataCaseBuilder();
    MetadataBuilder metadataBuilder = new MetadataBuilder();
    metadataBuilder.setMetadata(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 });
    metadataBuilder.setMask(new byte[] { 0, 0, 0, 0, 0, 0, 0, 2 });
    metaCaseBuilder.setMetadata(metadataBuilder.build());
    entryBuilder.setMatchEntryValue(metaCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(EthDst.class);
    entryBuilder.setHasMask(true);
    EthDstCaseBuilder ethDstCaseBuilder = new EthDstCaseBuilder();
    EthDstBuilder ethDstBuilder = new EthDstBuilder();
    ethDstBuilder.setMacAddress(new MacAddress("01:00:03:00:00:06"));
    ethDstBuilder.setMask(new byte[] { 0, 0, 0, 0, 0, 5 });
    ethDstCaseBuilder.setEthDst(ethDstBuilder.build());
    entryBuilder.setMatchEntryValue(ethDstCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(EthSrc.class);
    entryBuilder.setHasMask(true);
    EthSrcCaseBuilder ethSrcCaseBuilder = new EthSrcCaseBuilder();
    EthSrcBuilder ethSrcBuilder = new EthSrcBuilder();
    ethSrcBuilder.setMacAddress(new MacAddress("04:00:02:00:00:08"));
    ethSrcBuilder.setMask(new byte[] { 0, 0, 0, 0, 0, 2 });
    ethSrcCaseBuilder.setEthSrc(ethSrcBuilder.build());
    entryBuilder.setMatchEntryValue(ethSrcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(EthType.class);
    entryBuilder.setHasMask(false);
    EthTypeCaseBuilder ethTypeCaseBuilder = new EthTypeCaseBuilder();
    EthTypeBuilder ethTypeBuilder = new EthTypeBuilder();
    ethTypeBuilder.setEthType(new EtherType(46));
    ethTypeCaseBuilder.setEthType(ethTypeBuilder.build());
    entryBuilder.setMatchEntryValue(ethTypeCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(VlanVid.class);
    entryBuilder.setHasMask(true);
    VlanVidCaseBuilder vlanVidCaseBuilder = new VlanVidCaseBuilder();
    VlanVidBuilder vlanVidBuilder = new VlanVidBuilder();
    vlanVidBuilder.setVlanVid(45);
    vlanVidBuilder.setCfiBit(true);
    vlanVidBuilder.setMask(new byte[] { 0, 9 });
    vlanVidCaseBuilder.setVlanVid(vlanVidBuilder.build());
    entryBuilder.setMatchEntryValue(vlanVidCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(VlanPcp.class);
    entryBuilder.setHasMask(false);
    VlanPcpCaseBuilder vlanPcpCaseBuilder = new VlanPcpCaseBuilder();
    VlanPcpBuilder vlanPcpBuilder = new VlanPcpBuilder();
    vlanPcpBuilder.setVlanPcp((short) 14);
    vlanPcpCaseBuilder.setVlanPcp(vlanPcpBuilder.build());
    entryBuilder.setMatchEntryValue(vlanPcpCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(IpDscp.class);
    entryBuilder.setHasMask(false);
    IpDscpCaseBuilder ipDscpCaseBuilder = new IpDscpCaseBuilder();
    IpDscpBuilder ipDscpBuilder = new IpDscpBuilder();
    ipDscpBuilder.setDscp(new Dscp((short) 48));
    ipDscpCaseBuilder.setIpDscp(ipDscpBuilder.build());
    entryBuilder.setMatchEntryValue(ipDscpCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(IpEcn.class);
    entryBuilder.setHasMask(false);
    IpEcnCaseBuilder ipEcnCaseBuilder = new IpEcnCaseBuilder();
    IpEcnBuilder ipEcnBuilder = new IpEcnBuilder();
    ipEcnBuilder.setEcn((short) 49);
    ipEcnCaseBuilder.setIpEcn(ipEcnBuilder.build());
    entryBuilder.setMatchEntryValue(ipEcnCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(IpProto.class);
    entryBuilder.setHasMask(false);
    IpProtoCaseBuilder ipProtoCaseBuilder = new IpProtoCaseBuilder();
    IpProtoBuilder ipProtoBuilder = new IpProtoBuilder();
    ipProtoBuilder.setProtocolNumber((short) 50);
    ipProtoCaseBuilder.setIpProto(ipProtoBuilder.build());
    entryBuilder.setMatchEntryValue(ipProtoCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv4Src.class);
    entryBuilder.setHasMask(true);
    Ipv4SrcCaseBuilder ipv4SrcCaseBuilder = new Ipv4SrcCaseBuilder();
    Ipv4SrcBuilder ipv4SrcBuilder = new Ipv4SrcBuilder();
    ipv4SrcBuilder.setIpv4Address(new Ipv4Address("10.0.0.1"));
    ipv4SrcBuilder.setMask(new byte[] { 0, 0, 0, 14 });
    ipv4SrcCaseBuilder.setIpv4Src(ipv4SrcBuilder.build());
    entryBuilder.setMatchEntryValue(ipv4SrcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv4Dst.class);
    entryBuilder.setHasMask(true);
    Ipv4DstCaseBuilder ipv4DstCaseBuilder = new Ipv4DstCaseBuilder();
    Ipv4DstBuilder ipv4DstBuilder = new Ipv4DstBuilder();
    ipv4DstBuilder.setIpv4Address(new Ipv4Address("10.0.0.2"));
    ipv4DstBuilder.setMask(new byte[] { 0, 0, 0, 15 });
    ipv4DstCaseBuilder.setIpv4Dst(ipv4DstBuilder.build());
    entryBuilder.setMatchEntryValue(ipv4DstCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(TcpSrc.class);
    entryBuilder.setHasMask(false);
    TcpSrcCaseBuilder tcpSrcCaseBuilder = new TcpSrcCaseBuilder();
    TcpSrcBuilder tcpSrcBuilder = new TcpSrcBuilder();
    tcpSrcBuilder.setPort(
            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber(
                    6653));
    tcpSrcCaseBuilder.setTcpSrc(tcpSrcBuilder.build());
    entryBuilder.setMatchEntryValue(tcpSrcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(TcpDst.class);
    entryBuilder.setHasMask(false);
    TcpDstCaseBuilder tcpDstCaseBuilder = new TcpDstCaseBuilder();
    TcpDstBuilder tcpDstBuilder = new TcpDstBuilder();
    tcpDstBuilder.setPort(
            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber(
                    6654));
    tcpDstCaseBuilder.setTcpDst(tcpDstBuilder.build());
    entryBuilder.setMatchEntryValue(tcpDstCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(UdpSrc.class);
    entryBuilder.setHasMask(false);
    UdpSrcCaseBuilder udpSrcCaseBuilder = new UdpSrcCaseBuilder();
    UdpSrcBuilder udpSrcBuilder = new UdpSrcBuilder();
    udpSrcBuilder.setPort(
            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber(
                    6655));
    udpSrcCaseBuilder.setUdpSrc(udpSrcBuilder.build());
    entryBuilder.setMatchEntryValue(udpSrcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(UdpDst.class);
    entryBuilder.setHasMask(false);
    UdpDstCaseBuilder udpDstCaseBuilder = new UdpDstCaseBuilder();
    UdpDstBuilder udpDstBuilder = new UdpDstBuilder();
    udpDstBuilder.setPort(
            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber(
                    6656));
    udpDstCaseBuilder.setUdpDst(udpDstBuilder.build());
    entryBuilder.setMatchEntryValue(udpDstCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(SctpSrc.class);
    entryBuilder.setHasMask(false);
    SctpSrcCaseBuilder sctpSrcCaseBuilder = new SctpSrcCaseBuilder();
    SctpSrcBuilder sctpSrcBuilder = new SctpSrcBuilder();
    sctpSrcBuilder.setPort(
            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber(
                    6657));
    sctpSrcCaseBuilder.setSctpSrc(sctpSrcBuilder.build());
    entryBuilder.setMatchEntryValue(sctpSrcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(SctpDst.class);
    entryBuilder.setHasMask(false);
    SctpDstCaseBuilder sctpDstCaseBuilder = new SctpDstCaseBuilder();
    SctpDstBuilder sctpDstBuilder = new SctpDstBuilder();
    sctpDstBuilder.setPort(
            new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber(
                    6658));
    sctpDstCaseBuilder.setSctpDst(sctpDstBuilder.build());
    entryBuilder.setMatchEntryValue(sctpDstCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Icmpv4Type.class);
    entryBuilder.setHasMask(false);
    Icmpv4TypeCaseBuilder icmpv4TypeCaseBuilder = new Icmpv4TypeCaseBuilder();
    Icmpv4TypeBuilder icmpv4TypeBuilder = new Icmpv4TypeBuilder();
    icmpv4TypeBuilder.setIcmpv4Type((short) 51);
    icmpv4TypeCaseBuilder.setIcmpv4Type(icmpv4TypeBuilder.build());
    entryBuilder.setMatchEntryValue(icmpv4TypeCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Icmpv4Code.class);
    entryBuilder.setHasMask(false);
    Icmpv4CodeCaseBuilder icmpv4CodeCaseBuilder = new Icmpv4CodeCaseBuilder();
    Icmpv4CodeBuilder icmpv4CodeBuilder = new Icmpv4CodeBuilder();
    icmpv4CodeBuilder.setIcmpv4Code((short) 52);
    icmpv4CodeCaseBuilder.setIcmpv4Code(icmpv4CodeBuilder.build());
    entryBuilder.setMatchEntryValue(icmpv4CodeCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(ArpOp.class);
    entryBuilder.setHasMask(false);
    ArpOpCaseBuilder arpOpCaseBuilder = new ArpOpCaseBuilder();
    ArpOpBuilder arpOpBuilder = new ArpOpBuilder();
    arpOpBuilder.setOpCode(53);
    arpOpCaseBuilder.setArpOp(arpOpBuilder.build());
    entryBuilder.setMatchEntryValue(arpOpCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(ArpSpa.class);
    entryBuilder.setHasMask(true);
    ArpSpaCaseBuilder arpSpaCaseBuilder = new ArpSpaCaseBuilder();
    ArpSpaBuilder arpSpaBuilder = new ArpSpaBuilder();
    arpSpaBuilder.setIpv4Address(new Ipv4Address("10.0.0.4"));
    arpSpaBuilder.setMask(new byte[] { 0, 0, 0, 16 });
    arpSpaCaseBuilder.setArpSpa(arpSpaBuilder.build());
    entryBuilder.setMatchEntryValue(arpSpaCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(ArpTpa.class);
    entryBuilder.setHasMask(true);
    ArpTpaCaseBuilder arpTpaCaseBuilder = new ArpTpaCaseBuilder();
    ArpTpaBuilder arpTpaBuilder = new ArpTpaBuilder();
    arpTpaBuilder.setIpv4Address(new Ipv4Address("10.0.0.5"));
    arpTpaBuilder.setMask(new byte[] { 0, 0, 0, 17 });
    arpTpaCaseBuilder.setArpTpa(arpTpaBuilder.build());
    entryBuilder.setMatchEntryValue(arpTpaCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(ArpSha.class);
    entryBuilder.setHasMask(true);
    ArpShaCaseBuilder arpShaCaseBuilder = new ArpShaCaseBuilder();
    ArpShaBuilder arpShaBuilder = new ArpShaBuilder();
    arpShaBuilder.setMacAddress(new MacAddress("00:01:02:03:04:05"));
    arpShaBuilder.setMask(new byte[] { 0, 0, 4, 0, 0, 6 });
    arpShaCaseBuilder.setArpSha(arpShaBuilder.build());
    entryBuilder.setMatchEntryValue(arpShaCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(ArpTha.class);
    entryBuilder.setHasMask(true);
    ArpThaCaseBuilder arpThaCaseBuilder = new ArpThaCaseBuilder();
    ArpThaBuilder arpThaBuilder = new ArpThaBuilder();
    arpThaBuilder.setMacAddress(new MacAddress("00:00:00:00:00:03"));
    arpThaBuilder.setMask(new byte[] { 0, 0, 6, 0, 0, 4 });
    arpThaCaseBuilder.setArpTha(arpThaBuilder.build());
    entryBuilder.setMatchEntryValue(arpThaCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6Src.class);
    entryBuilder.setHasMask(true);
    Ipv6SrcCaseBuilder ipv6SrcCaseBuilder = new Ipv6SrcCaseBuilder();
    Ipv6SrcBuilder ipv6SrcBuilder = new Ipv6SrcBuilder();
    ipv6SrcBuilder.setIpv6Address(new Ipv6Address("0:0:0:0:0:0:0:1"));
    ipv6SrcBuilder.setMask(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 });
    ipv6SrcCaseBuilder.setIpv6Src(ipv6SrcBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6SrcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6Dst.class);
    entryBuilder.setHasMask(true);
    Ipv6DstCaseBuilder ipv6DstCaseBuilder = new Ipv6DstCaseBuilder();
    Ipv6DstBuilder ipv6DstBuilder = new Ipv6DstBuilder();
    ipv6DstBuilder.setIpv6Address(new Ipv6Address("0:0:1:0:1:0:0:1"));
    ipv6DstBuilder.setMask(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1 });
    ipv6DstCaseBuilder.setIpv6Dst(ipv6DstBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6DstCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6Flabel.class);
    entryBuilder.setHasMask(false);
    Ipv6FlabelCaseBuilder ipv6FlabelCaseBuilder = new Ipv6FlabelCaseBuilder();
    Ipv6FlabelBuilder ipv6FlabelBuilder = new Ipv6FlabelBuilder();
    ipv6FlabelBuilder.setIpv6Flabel(new Ipv6FlowLabel(58L));
    ipv6FlabelCaseBuilder.setIpv6Flabel(ipv6FlabelBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6FlabelCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Icmpv6Type.class);
    entryBuilder.setHasMask(false);
    Icmpv6TypeCaseBuilder icmpv6TypeCaseBuilder = new Icmpv6TypeCaseBuilder();
    Icmpv6TypeBuilder icmpv6TypeBuilder = new Icmpv6TypeBuilder();
    icmpv6TypeBuilder.setIcmpv6Type((short) 59);
    icmpv6TypeCaseBuilder.setIcmpv6Type(icmpv6TypeBuilder.build());
    entryBuilder.setMatchEntryValue(icmpv6TypeCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Icmpv6Code.class);
    entryBuilder.setHasMask(false);
    Icmpv6CodeCaseBuilder Icmpv6CodeCaseBuilder = new Icmpv6CodeCaseBuilder();
    Icmpv6CodeBuilder Icmpv6CodeBuilder = new Icmpv6CodeBuilder();
    Icmpv6CodeBuilder.setIcmpv6Code((short) 60);
    Icmpv6CodeCaseBuilder.setIcmpv6Code(Icmpv6CodeBuilder.build());
    entryBuilder.setMatchEntryValue(Icmpv6CodeCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6NdTarget.class);
    entryBuilder.setHasMask(false);
    Ipv6NdTargetCaseBuilder ipv6NdTargetCaseBuilder = new Ipv6NdTargetCaseBuilder();
    Ipv6NdTargetBuilder ipv6NdTargetBuilder = new Ipv6NdTargetBuilder();
    ipv6NdTargetBuilder.setIpv6Address(new Ipv6Address("F:0:0::0:0:0:1"));
    ipv6NdTargetCaseBuilder.setIpv6NdTarget(ipv6NdTargetBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6NdTargetCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6NdSll.class);
    entryBuilder.setHasMask(false);
    Ipv6NdSllCaseBuilder ipv6NdSllCaseBuilder = new Ipv6NdSllCaseBuilder();
    Ipv6NdSllBuilder ipv6NdSllBuilder = new Ipv6NdSllBuilder();
    ipv6NdSllBuilder.setMacAddress(new MacAddress("01:00:03:00:00:06"));
    ipv6NdSllCaseBuilder.setIpv6NdSll(ipv6NdSllBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6NdSllCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6NdTll.class);
    entryBuilder.setHasMask(false);
    Ipv6NdTllCaseBuilder ipv6NdTllCaseBuilder = new Ipv6NdTllCaseBuilder();
    Ipv6NdTllBuilder ipv6NdTllBuilder = new Ipv6NdTllBuilder();
    ipv6NdTllBuilder.setMacAddress(new MacAddress("04:00:02:00:00:08"));
    ipv6NdTllCaseBuilder.setIpv6NdTll(ipv6NdTllBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6NdTllCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(MplsLabel.class);
    entryBuilder.setHasMask(false);
    MplsLabelCaseBuilder mplsLabelCaseBuilder = new MplsLabelCaseBuilder();
    MplsLabelBuilder mplsLabelBuilder = new MplsLabelBuilder();
    mplsLabelBuilder.setMplsLabel(61L);
    mplsLabelCaseBuilder.setMplsLabel(mplsLabelBuilder.build());
    entryBuilder.setMatchEntryValue(mplsLabelCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(MplsTc.class);
    entryBuilder.setHasMask(false);
    MplsTcCaseBuilder MplsTcCaseBuilder = new MplsTcCaseBuilder();
    MplsTcBuilder MplsTcBuilder = new MplsTcBuilder();
    MplsTcBuilder.setTc((short) 62);
    MplsTcCaseBuilder.setMplsTc(MplsTcBuilder.build());
    entryBuilder.setMatchEntryValue(MplsTcCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(MplsBos.class);
    entryBuilder.setHasMask(false);
    MplsBosCaseBuilder MplsBosCaseBuilder = new MplsBosCaseBuilder();
    MplsBosBuilder MplsBosBuilder = new MplsBosBuilder();
    MplsBosBuilder.setBos(true);
    MplsBosCaseBuilder.setMplsBos(MplsBosBuilder.build());
    entryBuilder.setMatchEntryValue(MplsBosCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(PbbIsid.class);
    entryBuilder.setHasMask(true);
    PbbIsidCaseBuilder pbbIsidCaseBuilder = new PbbIsidCaseBuilder();
    PbbIsidBuilder pbbIsidBuilder = new PbbIsidBuilder();
    pbbIsidBuilder.setIsid(64L);
    pbbIsidBuilder.setMask(new byte[] { 0, 1, 2 });
    pbbIsidCaseBuilder.setPbbIsid(pbbIsidBuilder.build());
    entryBuilder.setMatchEntryValue(pbbIsidCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(TunnelId.class);
    entryBuilder.setHasMask(true);
    TunnelIdCaseBuilder tunnelIdCaseBuilder = new TunnelIdCaseBuilder();
    TunnelIdBuilder tunnelIdBuilder = new TunnelIdBuilder();
    tunnelIdBuilder.setTunnelId(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 });
    tunnelIdBuilder.setMask(new byte[] { 0, 0, 0, 0, 0, 0, 0, 2 });
    tunnelIdCaseBuilder.setTunnelId(tunnelIdBuilder.build());
    entryBuilder.setMatchEntryValue(tunnelIdCaseBuilder.build());
    entries.add(entryBuilder.build());
    entryBuilder = new MatchEntryBuilder();
    entryBuilder.setOxmClass(OpenflowBasicClass.class);
    entryBuilder.setOxmMatchField(Ipv6Exthdr.class);
    entryBuilder.setHasMask(true);
    Ipv6ExthdrCaseBuilder ipv6ExthdrCaseBuilder = new Ipv6ExthdrCaseBuilder();
    Ipv6ExthdrBuilder ipv6ExthdrBuilder = new Ipv6ExthdrBuilder();
    ipv6ExthdrBuilder
            .setPseudoField(new Ipv6ExthdrFlags(true, false, true, false, true, false, true, false, true));
    ipv6ExthdrBuilder.setMask(new byte[] { 0, 2 });
    ipv6ExthdrCaseBuilder.setIpv6Exthdr(ipv6ExthdrBuilder.build());
    entryBuilder.setMatchEntryValue(ipv6ExthdrCaseBuilder.build());
    entries.add(entryBuilder.build());

    builder.setMatchEntry(entries);
    Match match = builder.build();

    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong match type", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong match length", 424, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 0, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 4, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 42, out.readUnsignedInt());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 4, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 43, out.readUnsignedInt());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 5, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 1L, out.readLong());
    Assert.assertEquals("Wrong match entry mask", 2L, out.readLong());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 7, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 12, out.readUnsignedByte());
    byte[] array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 1, 0, 3, 0, 0, 6 }, array);
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 0, 0, 0, 5 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 9, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 12, out.readUnsignedByte());
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 4, 0, 2, 0, 0, 8 }, array);
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 0, 0, 0, 2 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 10, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 46, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 13, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 4, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 4141, out.readUnsignedShort());
    array = new byte[2];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 9 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 14, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 14, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 48, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 18, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 49, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 20, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 50, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 23, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 8, out.readUnsignedByte());
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 10, 0, 0, 1 }, array);
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 0, 14 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 25, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 8, out.readUnsignedByte());
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 10, 0, 0, 2 }, array);
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 0, 15 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 26, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 6653, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 28, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 6654, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 30, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 6655, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 32, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 6656, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 34, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 6657, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 36, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 6658, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 38, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 51, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 40, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 52, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 42, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 53, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 45, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 8, out.readUnsignedByte());
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 10, 0, 0, 4 }, array);
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 0, 16 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 47, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 8, out.readUnsignedByte());
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 10, 0, 0, 5 }, array);
    array = new byte[4];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 0, 17 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 49, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 12, out.readUnsignedByte());
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 0, 1, 2, 3, 4, 5 }, array);
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 4, 0, 0, 6 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 51, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 12, out.readUnsignedByte());
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 0, 0, 0, 0, 0, 3 }, array);
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 0, 6, 0, 0, 4 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 53, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 32, out.readUnsignedByte());
    array = new byte[16];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value",
            new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, array);
    array = new byte[16];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask",
            new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 55, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 32, out.readUnsignedByte());
    array = new byte[16];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value",
            new byte[] { 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1 }, array);
    array = new byte[16];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask",
            new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 56, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 4, out.readUnsignedByte()); //8, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 58, out.readUnsignedInt());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 58, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 59, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 60, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 60, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 62, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 16, out.readUnsignedByte());
    array = new byte[16];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value",
            new byte[] { 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 64, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 6, out.readUnsignedByte());
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 1, 0, 3, 0, 0, 6 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 66, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 6, out.readUnsignedByte());
    array = new byte[6];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 4, 0, 2, 0, 0, 8 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 68, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 4, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 61, out.readUnsignedInt());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 70, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 62, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 72, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 75, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 6, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 64, out.readUnsignedMedium());
    array = new byte[3];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry mask", new byte[] { 0, 1, 2 }, array);
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 77, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 1L, out.readLong());
    Assert.assertEquals("Wrong match entry mask", 2L, out.readLong());
    Assert.assertEquals("Wrong match entry class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong match entry field & hasMask", 79, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry length", 4, out.readUnsignedByte());
    Assert.assertEquals("Wrong match entry value", 358, out.readUnsignedShort());
    array = new byte[2];
    out.readBytes(array);
    Assert.assertArrayEquals("Wrong match entry value", new byte[] { 0, 2 }, array);
    Assert.assertTrue("Wrong padding", out.readableBytes() == 0);
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test for correct serialization of Ipv4Address match entry
 */// ww w .  j  a  v  a2  s  .  co m
@Test
public void testIpv4Src() {
    MatchBuilder builder = new MatchBuilder();
    builder.setType(OxmMatchType.class);
    List<MatchEntry> entries = new ArrayList<>();
    MatchEntryBuilder entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv4Src.class);
    entriesBuilder.setHasMask(false);
    Ipv4SrcCaseBuilder ipv4SrcCaseBuilder = new Ipv4SrcCaseBuilder();
    Ipv4SrcBuilder ipv4SrcBuilder = new Ipv4SrcBuilder();
    ipv4SrcBuilder.setIpv4Address(new Ipv4Address("1.2.3.4"));
    ipv4SrcCaseBuilder.setIpv4Src(ipv4SrcBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv4SrcCaseBuilder.build());
    entries.add(entriesBuilder.build());
    builder.setMatchEntry(entries);
    Match match = builder.build();

    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong type", 1, out.readUnsignedShort());
    out.skipBytes(EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 22, out.readUnsignedByte());
    out.skipBytes(EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
    Assert.assertEquals("Wrong ip address (first number)", 1, out.readUnsignedByte());
    Assert.assertEquals("Wrong ip address (second number)", 2, out.readUnsignedByte());
    Assert.assertEquals("Wrong ip address (third number)", 3, out.readUnsignedByte());
    Assert.assertEquals("Wrong ip address (fourth number)", 4, out.readUnsignedByte());
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test for correct serialization of Ipv6Address match entry
 *///from  ww  w  .j  a va2 s .  c om
@Test
public void testIpv6Various() {
    MatchBuilder builder = new MatchBuilder();
    builder.setType(OxmMatchType.class);
    List<MatchEntry> entries = new ArrayList<>();
    // ipv6 match entry with correct Ipv6 address
    MatchEntryBuilder entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv6Src.class);
    entriesBuilder.setHasMask(false);
    Ipv6SrcCaseBuilder ipv6SrcCaseBuilder = new Ipv6SrcCaseBuilder();
    Ipv6SrcBuilder ipv6SrcBuilder = new Ipv6SrcBuilder();
    ipv6SrcBuilder.setIpv6Address(new Ipv6Address("1:2:3:4:5:6:7:8"));
    ipv6SrcCaseBuilder.setIpv6Src(ipv6SrcBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv6SrcCaseBuilder.build());
    entries.add(entriesBuilder.build());
    // ipv6 match entry with abbreviated Ipv6 address
    entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv6NdTarget.class);
    entriesBuilder.setHasMask(false);
    Ipv6NdTargetCaseBuilder ipv6NdTargetCaseBuilder = new Ipv6NdTargetCaseBuilder();
    Ipv6NdTargetBuilder ipv6NdTargetBuilder = new Ipv6NdTargetBuilder();
    ipv6NdTargetBuilder.setIpv6Address(new Ipv6Address("1:2::6:7:8"));
    ipv6NdTargetCaseBuilder.setIpv6NdTarget(ipv6NdTargetBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv6NdTargetCaseBuilder.build());
    entries.add(entriesBuilder.build());
    // ipv6 match entry with abbreviated Ipv6 address
    entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv6Dst.class);
    entriesBuilder.setHasMask(false);
    Ipv6DstCaseBuilder ipv6DstCaseBuilder = new Ipv6DstCaseBuilder();
    Ipv6DstBuilder ipv6DstBuilder = new Ipv6DstBuilder();
    ipv6DstBuilder.setIpv6Address(new Ipv6Address("1::8"));
    ipv6DstCaseBuilder.setIpv6Dst(ipv6DstBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv6DstCaseBuilder.build());
    entries.add(entriesBuilder.build());
    // ipv6 match entry with abbreviated Ipv6 address
    entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv6Dst.class);
    entriesBuilder.setHasMask(false);
    ipv6DstCaseBuilder = new Ipv6DstCaseBuilder();
    ipv6DstBuilder = new Ipv6DstBuilder();
    ipv6DstBuilder.setIpv6Address(new Ipv6Address("::1"));
    ipv6DstCaseBuilder.setIpv6Dst(ipv6DstBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv6DstCaseBuilder.build());
    entries.add(entriesBuilder.build());
    // ipv6 match entry with abbreviated Ipv6 address
    entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv6Dst.class);
    entriesBuilder.setHasMask(false);
    ipv6DstCaseBuilder = new Ipv6DstCaseBuilder();
    ipv6DstBuilder = new Ipv6DstBuilder();
    ipv6DstBuilder.setIpv6Address(new Ipv6Address("::"));
    ipv6DstCaseBuilder.setIpv6Dst(ipv6DstBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv6DstCaseBuilder.build());
    entries.add(entriesBuilder.build());
    builder.setMatchEntry(entries);
    Match match = builder.build();
    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong type", 1, out.readUnsignedShort());
    out.skipBytes(EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 52, out.readUnsignedByte());
    Assert.assertEquals("Wrong entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong ipv6 address", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 2, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 3, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 4, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 5, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 6, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 7, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 62, out.readUnsignedByte());
    Assert.assertEquals("Wrong entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong ipv6 address", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 2, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 6, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 7, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 54, out.readUnsignedByte());
    Assert.assertEquals("Wrong entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong ipv6 address", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 8, out.readUnsignedShort());
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 54, out.readUnsignedByte());
    Assert.assertEquals("Wrong entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 1, out.readUnsignedShort());
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 54, out.readUnsignedByte());
    Assert.assertEquals("Wrong entry length", 16, out.readUnsignedByte());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong ipv6 address", 0, out.readUnsignedShort());
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test for correct serialization of incorrect Ipv6Address match entry
 *//*from   w  w  w  .  j  a  v  a 2 s.c  o m*/
@Test(expected = IllegalArgumentException.class)
public void testIpv6Incorrect() {
    MatchBuilder builder = new MatchBuilder();
    builder.setType(OxmMatchType.class);
    List<MatchEntry> entries = new ArrayList<>();
    // ipv6 match entry with incorrect Ipv6 address
    MatchEntryBuilder entriesBuilder = new MatchEntryBuilder();
    entriesBuilder.setOxmClass(OpenflowBasicClass.class);
    entriesBuilder.setOxmMatchField(Ipv6Src.class);
    entriesBuilder.setHasMask(false);
    Ipv6SrcCaseBuilder ipv6SrcCaseBuilder = new Ipv6SrcCaseBuilder();
    Ipv6SrcBuilder ipv6SrcBuilder = new Ipv6SrcBuilder();
    ipv6SrcBuilder.setIpv6Address(new Ipv6Address("1:2::::8"));
    ipv6SrcCaseBuilder.setIpv6Src(ipv6SrcBuilder.build());
    entriesBuilder.setMatchEntryValue(ipv6SrcCaseBuilder.build());
    entries.add(entriesBuilder.build());
    builder.setMatchEntry(entries);
    Match match = builder.build();
    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test for correct serialization of Ipv4Address match entry
 *///from  w  w w .j a va 2  s  .com
@Test
public void testIpv6Flabel() {
    Match match = buildIpv6FLabelMatch(0x0f9e8dL, false, null);

    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong type", 1, out.readUnsignedShort());
    out.skipBytes(EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 56, out.readUnsignedByte());
    out.skipBytes(EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
    byte[] label = new byte[4];
    out.readBytes(label);

    LOG.debug("label: {}", ByteBufUtils.bytesToHexString(label));
    Assert.assertArrayEquals("Wrong ipv6FLabel", new byte[] { 0, 0x0f, (byte) 0x9e, (byte) 0x8d }, label);
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test for correct serialization of Ipv4Address match entry
 *//*from   w  w  w.j  av a  2 s . co  m*/
@Test
public void testIpv6FlabelWithMask() {
    Match match = buildIpv6FLabelMatch(0x0f9e8dL, true, new byte[] { 0, 1, 2, 3 });

    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong type", 1, out.readUnsignedShort());
    out.skipBytes(EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
    Assert.assertEquals("Wrong class", 0x8000, out.readUnsignedShort());
    Assert.assertEquals("Wrong field and mask", 57, out.readUnsignedByte());
    out.skipBytes(EncodeConstants.SIZE_OF_BYTE_IN_BYTES);
    byte[] label = new byte[4];
    out.readBytes(label);
    Assert.assertArrayEquals("Wrong ipv6FLabel", new byte[] { 0, 0x0f, (byte) 0x9e, (byte) 0x8d }, label);
    byte[] mask = new byte[4];
    out.readBytes(mask);
    Assert.assertArrayEquals("Wrong ipv6FLabel mask", new byte[] { 0, 1, 2, 3 }, mask);
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test for correct serialization of Ipv4Address match entry with wrong mask
 *///from  w  w  w .j a  v a  2 s .  c  o  m
@Test
public void testIpv6FlabelWithMaskBad() {
    Match match = buildIpv6FLabelMatch(0x0f9e8dL, true, new byte[] { 0x0c, 0x7b, 0x6a });
    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();

    try {
        matchSerializer.serialize(match, out);
        Assert.fail("incorrect length of mask ignored");
    } catch (IllegalArgumentException e) {
        //expected
    }
}

From source file:org.opendaylight.openflowjava.protocol.impl.util.OF13MatchSerializerTest.java

License:Open Source License

/**
 * Test Standard match type//from w  ww  .j  ava 2 s  . co m
 */
@Test
public void testStandardMatchType() {
    MatchBuilder builder = new MatchBuilder();
    builder.setType(StandardMatchType.class);
    Match match = builder.build();
    ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();

    matchSerializer.serialize(match, out);

    Assert.assertEquals("Wrong match type", 0, out.readUnsignedShort());
    Assert.assertEquals("Wrong match length", 4, out.readUnsignedShort());
    Assert.assertEquals("Wrong padding", 0, out.readUnsignedInt());
    Assert.assertEquals("Unexpected data", 0, out.readableBytes());
}