X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflow-protocol-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowjava%2Fprotocol%2Fimpl%2Futil%2FMatchDeserializerTest.java;fp=openflow-protocol-impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fopenflowjava%2Fprotocol%2Fimpl%2Futil%2FMatchDeserializerTest.java;h=4519deedb13d39df30c366ea6fc4b46e2e2fb51a;hb=29a2a074c78708f6d18583779ece96bb6573f0c6;hp=b139257f23a9258c99235e3a56df8630d253c598;hpb=435f3e8a95843a6e9a326ab56663c31ff6d7cdb7;p=openflowjava.git diff --git a/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/util/MatchDeserializerTest.java b/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/util/MatchDeserializerTest.java index b139257f..4519deed 100644 --- a/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/util/MatchDeserializerTest.java +++ b/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/util/MatchDeserializerTest.java @@ -25,76 +25,92 @@ import org.opendaylight.openflowjava.util.ByteBufUtils; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.BosMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.DscpMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EcnMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EthTypeMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv4CodeMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv4TypeMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv6CodeMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv6TypeMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv4AddressMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv6AddressMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv6FlabelMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.IsidMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MacAddressMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MaskMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MetadataMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MplsLabelMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.OpCodeMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortNumberMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.ProtocolNumberMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PseudoFieldMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.TcMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanPcpMatchEntry; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanVidMatchEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Ipv6ExthdrFlags; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.StandardMatchType; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpOp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpSha; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpSpa; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpTha; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpTpa; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthDst; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthSrc; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthType; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv4Code; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv4Type; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv6Code; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv6Type; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPhyPort; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPort; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpDscp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpEcn; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpProto; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv4Dst; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv4Src; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Dst; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Exthdr; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Flabel; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdSll; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdTarget; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdTll; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Src; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Metadata; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsBos; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsLabel; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsTc; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OpenflowBasicClass; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OxmMatchType; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.PbbIsid; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.SctpDst; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.SctpSrc; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TcpDst; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TcpSrc; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TunnelId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.UdpDst; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.UdpSrc; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.VlanPcp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.VlanVid; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.match.grouping.Match; -import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.oxm.fields.grouping.MatchEntries; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.ArpOp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.ArpSha; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.ArpSpa; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.ArpTha; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.ArpTpa; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.EthDst; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.EthSrc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.EthType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Icmpv4Code; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Icmpv4Type; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Icmpv6Code; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Icmpv6Type; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.InPhyPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.InPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.IpDscp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.IpEcn; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.IpProto; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv4Dst; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv4Src; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6Dst; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6Exthdr; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6Flabel; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6NdSll; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6NdTarget; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6NdTll; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Ipv6Src; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.Metadata; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MplsBos; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MplsLabel; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.MplsTc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OpenflowBasicClass; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.OxmMatchType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.PbbIsid; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.SctpDst; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.SctpSrc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.TcpDst; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.TcpSrc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.TunnelId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.UdpDst; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.UdpSrc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.VlanPcp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.VlanVid; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entries.grouping.MatchEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.ArpOpCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.ArpShaCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.ArpSpaCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.ArpThaCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.ArpTpaCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.EthDstCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.EthSrcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.EthTypeCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Icmpv4CodeCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Icmpv4TypeCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Icmpv6CodeCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Icmpv6TypeCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.InPhyPortCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.InPortCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.IpDscpCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.IpEcnCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.IpProtoCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv4DstCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv4SrcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6DstCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6ExthdrCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6FlabelCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6NdSllCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6NdTargetCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6NdTllCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.Ipv6SrcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.MetadataCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.MplsBosCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.MplsLabelCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.MplsTcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.PbbIsidCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.SctpDstCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.SctpSrcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.TcpDstCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.TcpSrcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.TunnelIdCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.UdpDstCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.UdpSrcCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.VlanPcpCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.VlanVidCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.grouping.Match; /** * @author michal.polkorab @@ -127,10 +143,10 @@ public class MatchDeserializerTest { MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID, 0x8000, 12); key.setExperimenterId(null); - OFDeserializer entryDeserializer = registry.getDeserializer(key); - MatchEntries entry = entryDeserializer.deserialize(buffer); + OFDeserializer entryDeserializer = registry.getDeserializer(key); + MatchEntry entry = entryDeserializer.deserialize(buffer); Assert.assertEquals("Wrong Ipv4 address format", new Ipv4Address("0.1.2.3"), - entry.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address()); + ((Ipv4DstCase) entry.getMatchEntryValue()).getIpv4Dst().getIpv4Address()); } /** @@ -143,10 +159,10 @@ public class MatchDeserializerTest { MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID, 0x8000, 26); key.setExperimenterId(null); - OFDeserializer entryDeserializer = registry.getDeserializer(key); - MatchEntries entry = entryDeserializer.deserialize(buffer); + OFDeserializer entryDeserializer = registry.getDeserializer(key); + MatchEntry entry = entryDeserializer.deserialize(buffer); Assert.assertEquals("Wrong Ipv6 address format", new Ipv6Address("0000:0001:0002:0003:0004:0005:0006:0F07"), - entry.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address()); + ((Ipv6SrcCase) entry.getMatchEntryValue()).getIpv6Src().getIpv6Address()); } /** @@ -154,7 +170,7 @@ public class MatchDeserializerTest { */ @Test public void testMatch() { - ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("00 01 01 AC " + ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("00 01 01 A8 " + "80 00 00 04 00 00 00 01 " + "80 00 02 04 00 00 00 02 " + "80 00 05 10 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00 04 " @@ -185,7 +201,7 @@ public class MatchDeserializerTest { + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16 " + "80 00 37 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 17 " + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 " - + "80 00 39 08 00 00 00 02 00 00 00 03 " + + "80 00 38 04 00 00 00 02 " + "80 00 3A 01 15 " + "80 00 3C 01 17 " + "80 00 3E 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 20 " //ipv6ndtarget @@ -196,290 +212,289 @@ public class MatchDeserializerTest { + "80 00 48 01 01 " + "80 00 4B 06 00 00 02 00 00 01 " + "80 00 4D 10 00 00 00 00 00 00 00 07 00 00 00 00 00 00 00 FF " - + "80 00 4F 04 00 00 03 04 " - + "00 00 00 00"); + + "80 00 4F 04 00 00 03 04"); + System.out.println(buffer.readableBytes()); Match match = matchDeserializer.deserialize(buffer); Assert.assertEquals("Wrong match type", OxmMatchType.class, match.getType()); - Assert.assertEquals("Wrong match entries size", 40, match.getMatchEntries().size()); - List entries = match.getMatchEntries(); - MatchEntries entry0 = entries.get(0); + Assert.assertEquals("Wrong match entries size", 40, match.getMatchEntry().size()); + List entries = match.getMatchEntry(); + MatchEntry entry0 = entries.get(0); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry0.getOxmClass()); Assert.assertEquals("Wrong entry field", InPort.class, entry0.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry0.isHasMask()); Assert.assertEquals("Wrong entry value", 1, - entry0.getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue()); - MatchEntries entry1 = entries.get(1); + ((InPortCase) entry0.getMatchEntryValue()).getInPort().getPortNumber().getValue().intValue()); + MatchEntry entry1 = entries.get(1); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry1.getOxmClass()); Assert.assertEquals("Wrong entry field", InPhyPort.class, entry1.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry1.isHasMask()); Assert.assertEquals("Wrong entry value", 2, - entry1.getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue()); - MatchEntries entry2 = entries.get(2); + ((InPhyPortCase) entry1.getMatchEntryValue()).getInPhyPort().getPortNumber().getValue().intValue()); + MatchEntry entry2 = entries.get(2); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry2.getOxmClass()); Assert.assertEquals("Wrong entry field", Metadata.class, entry2.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry2.isHasMask()); Assert.assertArrayEquals("Wrong entry value", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 03"), - entry2.getAugmentation(MetadataMatchEntry.class).getMetadata()); + ((MetadataCase) entry2.getMatchEntryValue()).getMetadata().getMetadata()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 04"), - entry2.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry3 = entries.get(3); + ((MetadataCase) entry2.getMatchEntryValue()).getMetadata().getMask()); + MatchEntry entry3 = entries.get(3); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry3.getOxmClass()); Assert.assertEquals("Wrong entry field", EthDst.class, entry3.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry3.isHasMask()); Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:05"), - entry3.getAugmentation(MacAddressMatchEntry.class).getMacAddress()); + ((EthDstCase) entry3.getMatchEntryValue()).getEthDst().getMacAddress()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 06"), - entry3.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry4 = entries.get(4); + ((EthDstCase) entry3.getMatchEntryValue()).getEthDst().getMask()); + MatchEntry entry4 = entries.get(4); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry4.getOxmClass()); Assert.assertEquals("Wrong entry field", EthSrc.class, entry4.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry4.isHasMask()); Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:07"), - entry4.getAugmentation(MacAddressMatchEntry.class).getMacAddress()); + ((EthSrcCase) entry4.getMatchEntryValue()).getEthSrc().getMacAddress()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 08"), - entry4.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry5 = entries.get(5); + ((EthSrcCase) entry4.getMatchEntryValue()).getEthSrc().getMask()); + MatchEntry entry5 = entries.get(5); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry5.getOxmClass()); Assert.assertEquals("Wrong entry field", EthType.class, entry5.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry5.isHasMask()); Assert.assertEquals("Wrong entry value", 9, - entry5.getAugmentation(EthTypeMatchEntry.class).getEthType().getValue().intValue()); - MatchEntries entry6 = entries.get(6); + ((EthTypeCase) entry5.getMatchEntryValue()).getEthType().getEthType().getValue().intValue()); + MatchEntry entry6 = entries.get(6); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry6.getOxmClass()); Assert.assertEquals("Wrong entry field", VlanVid.class, entry6.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry6.isHasMask()); Assert.assertEquals("Wrong entry value", 10, - entry6.getAugmentation(VlanVidMatchEntry.class).getVlanVid().intValue()); + ((VlanVidCase) entry6.getMatchEntryValue()).getVlanVid().getVlanVid().intValue()); Assert.assertEquals("Wrong entry value", false, - entry6.getAugmentation(VlanVidMatchEntry.class).isCfiBit()); + ((VlanVidCase) entry6.getMatchEntryValue()).getVlanVid().isCfiBit()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 0B"), - entry6.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry7 = entries.get(7); + ((VlanVidCase) entry6.getMatchEntryValue()).getVlanVid().getMask()); + MatchEntry entry7 = entries.get(7); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry7.getOxmClass()); Assert.assertEquals("Wrong entry field", VlanPcp.class, entry7.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry7.isHasMask()); Assert.assertEquals("Wrong entry value", 12, - entry7.getAugmentation(VlanPcpMatchEntry.class).getVlanPcp().intValue()); - MatchEntries entry8 = entries.get(8); + ((VlanPcpCase) entry7.getMatchEntryValue()).getVlanPcp().getVlanPcp().intValue()); + MatchEntry entry8 = entries.get(8); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry8.getOxmClass()); Assert.assertEquals("Wrong entry field", IpDscp.class, entry8.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry8.isHasMask()); Assert.assertEquals("Wrong entry value", 13, - entry8.getAugmentation(DscpMatchEntry.class).getDscp().getValue().intValue()); - MatchEntries entry9 = entries.get(9); + ((IpDscpCase) entry8.getMatchEntryValue()).getIpDscp().getDscp().getValue().intValue()); + MatchEntry entry9 = entries.get(9); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry9.getOxmClass()); Assert.assertEquals("Wrong entry field", IpEcn.class, entry9.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry9.isHasMask()); Assert.assertEquals("Wrong entry value", 14, - entry9.getAugmentation(EcnMatchEntry.class).getEcn().intValue()); - MatchEntries entry10 = entries.get(10); + ((IpEcnCase) entry9.getMatchEntryValue()).getIpEcn().getEcn().intValue()); + MatchEntry entry10 = entries.get(10); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry10.getOxmClass()); Assert.assertEquals("Wrong entry field", IpProto.class, entry10.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry10.isHasMask()); Assert.assertEquals("Wrong entry value", 15, - entry10.getAugmentation(ProtocolNumberMatchEntry.class).getProtocolNumber().intValue()); - MatchEntries entry11 = entries.get(11); + ((IpProtoCase) entry10.getMatchEntryValue()).getIpProto().getProtocolNumber().intValue()); + MatchEntry entry11 = entries.get(11); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry11.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv4Src.class, entry11.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry11.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.1"), - entry11.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address()); + ((Ipv4SrcCase) entry11.getMatchEntryValue()).getIpv4Src().getIpv4Address()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 FF 00"), - entry11.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry12 = entries.get(12); + ((Ipv4SrcCase) entry11.getMatchEntryValue()).getIpv4Src().getMask()); + MatchEntry entry12 = entries.get(12); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry12.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv4Dst.class, entry12.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry12.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.2"), - entry12.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address()); + ((Ipv4DstCase) entry12.getMatchEntryValue()).getIpv4Dst().getIpv4Address()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 FF"), - entry12.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry13 = entries.get(13); + ((Ipv4DstCase) entry12.getMatchEntryValue()).getIpv4Dst().getMask()); + MatchEntry entry13 = entries.get(13); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry13.getOxmClass()); Assert.assertEquals("Wrong entry field", TcpSrc.class, entry13.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry13.isHasMask()); Assert.assertEquals("Wrong entry value", 3, - entry13.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue()); - MatchEntries entry14 = entries.get(14); + ((TcpSrcCase) entry13.getMatchEntryValue()).getTcpSrc().getPort().getValue().intValue()); + MatchEntry entry14 = entries.get(14); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry14.getOxmClass()); Assert.assertEquals("Wrong entry field", TcpDst.class, entry14.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry14.isHasMask()); Assert.assertEquals("Wrong entry value", 4, - entry14.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue()); - MatchEntries entry15 = entries.get(15); + ((TcpDstCase) entry14.getMatchEntryValue()).getTcpDst().getPort().getValue().intValue()); + MatchEntry entry15 = entries.get(15); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry15.getOxmClass()); Assert.assertEquals("Wrong entry field", UdpSrc.class, entry15.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry15.isHasMask()); Assert.assertEquals("Wrong entry value", 5, - entry15.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue()); - MatchEntries entry16 = entries.get(16); + ((UdpSrcCase) entry15.getMatchEntryValue()).getUdpSrc().getPort().getValue().intValue()); + MatchEntry entry16 = entries.get(16); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry16.getOxmClass()); Assert.assertEquals("Wrong entry field", UdpDst.class, entry16.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry16.isHasMask()); Assert.assertEquals("Wrong entry value", 6, - entry16.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue()); - MatchEntries entry17 = entries.get(17); + ((UdpDstCase) entry16.getMatchEntryValue()).getUdpDst().getPort().getValue().intValue()); + MatchEntry entry17 = entries.get(17); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry17.getOxmClass()); Assert.assertEquals("Wrong entry field", SctpSrc.class, entry17.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry17.isHasMask()); Assert.assertEquals("Wrong entry value", 7, - entry17.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue()); - MatchEntries entry18 = entries.get(18); + ((SctpSrcCase) entry17.getMatchEntryValue()).getSctpSrc().getPort().getValue().intValue()); + MatchEntry entry18 = entries.get(18); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry18.getOxmClass()); Assert.assertEquals("Wrong entry field", SctpDst.class, entry18.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry18.isHasMask()); Assert.assertEquals("Wrong entry value", 8, - entry18.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue()); - MatchEntries entry19 = entries.get(19); + ((SctpDstCase) entry18.getMatchEntryValue()).getSctpDst().getPort().getValue().intValue()); + MatchEntry entry19 = entries.get(19); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry19.getOxmClass()); Assert.assertEquals("Wrong entry field", Icmpv4Type.class, entry19.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry19.isHasMask()); Assert.assertEquals("Wrong entry value", 5, - entry19.getAugmentation(Icmpv4TypeMatchEntry.class).getIcmpv4Type().intValue()); - MatchEntries entry20 = entries.get(20); + ((Icmpv4TypeCase) entry19.getMatchEntryValue()).getIcmpv4Type().getIcmpv4Type().intValue()); + MatchEntry entry20 = entries.get(20); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry20.getOxmClass()); Assert.assertEquals("Wrong entry field", Icmpv4Code.class, entry20.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry20.isHasMask()); Assert.assertEquals("Wrong entry value", 7, - entry20.getAugmentation(Icmpv4CodeMatchEntry.class).getIcmpv4Code().intValue()); - MatchEntries entry21 = entries.get(21); + ((Icmpv4CodeCase) entry20.getMatchEntryValue()).getIcmpv4Code().getIcmpv4Code().intValue()); + MatchEntry entry21 = entries.get(21); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry21.getOxmClass()); Assert.assertEquals("Wrong entry field", ArpOp.class, entry21.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry21.isHasMask()); Assert.assertEquals("Wrong entry value", 16, - entry21.getAugmentation(OpCodeMatchEntry.class).getOpCode().intValue()); - MatchEntries entry22 = entries.get(22); + ((ArpOpCase) entry21.getMatchEntryValue()).getArpOp().getOpCode().intValue()); + MatchEntry entry22 = entries.get(22); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry22.getOxmClass()); Assert.assertEquals("Wrong entry field", ArpSpa.class, entry22.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry22.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.9"), - entry22.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address()); + ((ArpSpaCase) entry22.getMatchEntryValue()).getArpSpa().getIpv4Address()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 FF 00"), - entry22.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry23 = entries.get(23); + ((ArpSpaCase) entry22.getMatchEntryValue()).getArpSpa().getMask()); + MatchEntry entry23 = entries.get(23); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry23.getOxmClass()); Assert.assertEquals("Wrong entry field", ArpTpa.class, entry23.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry23.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.10"), - entry23.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address()); + ((ArpTpaCase) entry23.getMatchEntryValue()).getArpTpa().getIpv4Address()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 FF"), - entry23.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry24 = entries.get(24); + ((ArpTpaCase) entry23.getMatchEntryValue()).getArpTpa().getMask()); + MatchEntry entry24 = entries.get(24); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry24.getOxmClass()); Assert.assertEquals("Wrong entry field", ArpSha.class, entry24.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry24.isHasMask()); Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:01"), - entry24.getAugmentation(MacAddressMatchEntry.class).getMacAddress()); + ((ArpShaCase) entry24.getMatchEntryValue()).getArpSha().getMacAddress()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 03"), - entry24.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry25 = entries.get(25); + ((ArpShaCase) entry24.getMatchEntryValue()).getArpSha().getMask()); + MatchEntry entry25 = entries.get(25); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry25.getOxmClass()); Assert.assertEquals("Wrong entry field", ArpTha.class, entry25.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry25.isHasMask()); Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:02"), - entry25.getAugmentation(MacAddressMatchEntry.class).getMacAddress()); + ((ArpThaCase) entry25.getMatchEntryValue()).getArpTha().getMacAddress()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 04"), - entry25.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry26 = entries.get(26); + ((ArpThaCase) entry25.getMatchEntryValue()).getArpTha().getMask()); + MatchEntry entry26 = entries.get(26); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry26.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6Src.class, entry26.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry26.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0015"), - entry26.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address()); + ((Ipv6SrcCase) entry26.getMatchEntryValue()).getIpv6Src().getIpv6Address()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16"), - entry26.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry27 = entries.get(27); + ((Ipv6SrcCase) entry26.getMatchEntryValue()).getIpv6Src().getMask()); + MatchEntry entry27 = entries.get(27); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry27.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6Dst.class, entry27.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry27.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0017"), - entry27.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address()); + ((Ipv6DstCase) entry27.getMatchEntryValue()).getIpv6Dst().getIpv6Address()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18"), - entry27.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry28 = entries.get(28); + ((Ipv6DstCase) entry27.getMatchEntryValue()).getIpv6Dst().getMask()); + MatchEntry entry28 = entries.get(28); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry28.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6Flabel.class, entry28.getOxmMatchField()); - Assert.assertEquals("Wrong entry hasMask", true, entry28.isHasMask()); + Assert.assertEquals("Wrong entry hasMask", false, entry28.isHasMask()); Assert.assertEquals("Wrong entry value", 2, - entry28.getAugmentation(Ipv6FlabelMatchEntry.class).getIpv6Flabel().getValue().intValue()); - Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 03"), - entry28.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry29 = entries.get(29); + ((Ipv6FlabelCase) entry28.getMatchEntryValue()).getIpv6Flabel().getIpv6Flabel() + .getValue().intValue()); + MatchEntry entry29 = entries.get(29); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry29.getOxmClass()); Assert.assertEquals("Wrong entry field", Icmpv6Type.class, entry29.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry29.isHasMask()); Assert.assertEquals("Wrong entry value", 21, - entry29.getAugmentation(Icmpv6TypeMatchEntry.class).getIcmpv6Type().intValue()); - MatchEntries entry30 = entries.get(30); + ((Icmpv6TypeCase) entry29.getMatchEntryValue()).getIcmpv6Type().getIcmpv6Type().intValue()); + MatchEntry entry30 = entries.get(30); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry30.getOxmClass()); Assert.assertEquals("Wrong entry field", Icmpv6Code.class, entry30.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry30.isHasMask()); Assert.assertEquals("Wrong entry value", 23, - entry30.getAugmentation(Icmpv6CodeMatchEntry.class).getIcmpv6Code().intValue()); - MatchEntries entry31 = entries.get(31); + ((Icmpv6CodeCase) entry30.getMatchEntryValue()).getIcmpv6Code().getIcmpv6Code().intValue()); + MatchEntry entry31 = entries.get(31); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry31.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6NdTarget.class, entry31.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry31.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0020"), - entry31.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address()); - MatchEntries entry32 = entries.get(32); + ((Ipv6NdTargetCase) entry31.getMatchEntryValue()).getIpv6NdTarget().getIpv6Address()); + MatchEntry entry32 = entries.get(32); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry32.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6NdSll.class, entry32.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry32.isHasMask()); Assert.assertEquals("Wrong entry value", new MacAddress("00:05:00:00:00:01"), - entry32.getAugmentation(MacAddressMatchEntry.class).getMacAddress()); - MatchEntries entry33 = entries.get(33); + ((Ipv6NdSllCase) entry32.getMatchEntryValue()).getIpv6NdSll().getMacAddress()); + MatchEntry entry33 = entries.get(33); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry33.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6NdTll.class, entry33.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry33.isHasMask()); Assert.assertEquals("Wrong entry value", new MacAddress("00:05:00:00:00:02"), - entry33.getAugmentation(MacAddressMatchEntry.class).getMacAddress()); - MatchEntries entry34 = entries.get(34); + ((Ipv6NdTllCase) entry33.getMatchEntryValue()).getIpv6NdTll().getMacAddress()); + MatchEntry entry34 = entries.get(34); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry34.getOxmClass()); Assert.assertEquals("Wrong entry field", MplsLabel.class, entry34.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry34.isHasMask()); Assert.assertEquals("Wrong entry value", 515, - entry34.getAugmentation(MplsLabelMatchEntry.class).getMplsLabel().intValue()); - MatchEntries entry35 = entries.get(35); + ((MplsLabelCase) entry34.getMatchEntryValue()).getMplsLabel().getMplsLabel().intValue()); + MatchEntry entry35 = entries.get(35); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry35.getOxmClass()); Assert.assertEquals("Wrong entry field", MplsTc.class, entry35.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry35.isHasMask()); Assert.assertEquals("Wrong entry value", 3, - entry35.getAugmentation(TcMatchEntry.class).getTc().intValue()); - MatchEntries entry36 = entries.get(36); + ((MplsTcCase) entry35.getMatchEntryValue()).getMplsTc().getTc().intValue()); + MatchEntry entry36 = entries.get(36); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry36.getOxmClass()); Assert.assertEquals("Wrong entry field", MplsBos.class, entry36.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry36.isHasMask()); Assert.assertEquals("Wrong entry value", true, - entry36.getAugmentation(BosMatchEntry.class).isBos()); - MatchEntries entry37 = entries.get(37); + ((MplsBosCase) entry36.getMatchEntryValue()).getMplsBos().isBos()); + MatchEntry entry37 = entries.get(37); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry37.getOxmClass()); Assert.assertEquals("Wrong entry field", PbbIsid.class, entry37.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry37.isHasMask()); Assert.assertEquals("Wrong entry value", 2, - entry37.getAugmentation(IsidMatchEntry.class).getIsid().intValue()); + ((PbbIsidCase) entry37.getMatchEntryValue()).getPbbIsid().getIsid().intValue()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 01"), - entry37.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry38 = entries.get(38); + ((PbbIsidCase) entry37.getMatchEntryValue()).getPbbIsid().getMask()); + MatchEntry entry38 = entries.get(38); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry38.getOxmClass()); Assert.assertEquals("Wrong entry field", TunnelId.class, entry38.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry38.isHasMask()); Assert.assertArrayEquals("Wrong entry value", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 07"), - entry38.getAugmentation(MetadataMatchEntry.class).getMetadata()); + ((TunnelIdCase) entry38.getMatchEntryValue()).getTunnelId().getTunnelId()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 FF"), - entry38.getAugmentation(MaskMatchEntry.class).getMask()); - MatchEntries entry39 = entries.get(39); + ((TunnelIdCase) entry38.getMatchEntryValue()).getTunnelId().getMask()); + MatchEntry entry39 = entries.get(39); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry39.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv6Exthdr.class, entry39.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", true, entry39.isHasMask()); Assert.assertEquals("Wrong entry value", new Ipv6ExthdrFlags(false, false, false, false, false, false, false, false, false), - entry39.getAugmentation(PseudoFieldMatchEntry.class).getPseudoField()); + ((Ipv6ExthdrCase) entry39.getMatchEntryValue()).getIpv6Exthdr().getPseudoField()); Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("03 04"), - entry39.getAugmentation(MaskMatchEntry.class).getMask()); + ((Ipv6ExthdrCase) entry39.getMatchEntryValue()).getIpv6Exthdr().getMask()); Assert.assertTrue("Unread data", buffer.readableBytes() == 0); } @@ -493,12 +508,12 @@ public class MatchDeserializerTest { MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID, 0x8000, 12); key.setExperimenterId(null); - HeaderDeserializer entryDeserializer = registry.getDeserializer(key); - MatchEntries entry = entryDeserializer.deserializeHeader(buffer); + HeaderDeserializer entryDeserializer = registry.getDeserializer(key); + MatchEntry entry = entryDeserializer.deserializeHeader(buffer); Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry.getOxmClass()); Assert.assertEquals("Wrong entry field", Ipv4Dst.class, entry.getOxmMatchField()); Assert.assertEquals("Wrong entry hasMask", false, entry.isHasMask()); - Assert.assertEquals("Wrong Ipv4 address", null, entry.getAugmentation(Ipv4AddressMatchEntry.class)); + Assert.assertNull("Wrong Ipv4 address", entry.getMatchEntryValue()); } /** @@ -511,6 +526,6 @@ public class MatchDeserializerTest { Match match = matchDeserializer.deserialize(buffer); Assert.assertEquals("Wrong match type", StandardMatchType.class, match.getType()); - Assert.assertEquals("Wrong match entries size", 1, match.getMatchEntries().size()); + Assert.assertEquals("Wrong match entries size", 1, match.getMatchEntry().size()); } } \ No newline at end of file