2 * Copyright (c) 2013 Pantheon Technologies s.r.o. and others. All rights reserved.
\r
4 * This program and the accompanying materials are made available under the
\r
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
\r
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
\r
8 package org.opendaylight.openflowjava.protocol.impl.util;
\r
10 import io.netty.buffer.ByteBuf;
\r
12 import java.util.List;
\r
14 import org.junit.Assert;
\r
15 import org.junit.Before;
\r
16 import org.junit.Test;
\r
17 import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
\r
18 import org.opendaylight.openflowjava.protocol.api.extensibility.HeaderDeserializer;
\r
19 import org.opendaylight.openflowjava.protocol.api.extensibility.MessageCodeKey;
\r
20 import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
\r
21 import org.opendaylight.openflowjava.protocol.api.keys.MatchEntryDeserializerKey;
\r
22 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
\r
23 import org.opendaylight.openflowjava.protocol.impl.deserialization.DeserializerRegistryImpl;
\r
24 import org.opendaylight.openflowjava.util.ByteBufUtils;
\r
25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
\r
26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
\r
27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
\r
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.BosMatchEntry;
\r
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.DscpMatchEntry;
\r
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EcnMatchEntry;
\r
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EthTypeMatchEntry;
\r
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv4CodeMatchEntry;
\r
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv4TypeMatchEntry;
\r
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv6CodeMatchEntry;
\r
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Icmpv6TypeMatchEntry;
\r
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv4AddressMatchEntry;
\r
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv6AddressMatchEntry;
\r
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.Ipv6FlabelMatchEntry;
\r
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.IsidMatchEntry;
\r
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MacAddressMatchEntry;
\r
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MaskMatchEntry;
\r
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MetadataMatchEntry;
\r
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MplsLabelMatchEntry;
\r
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.OpCodeMatchEntry;
\r
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortMatchEntry;
\r
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortNumberMatchEntry;
\r
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.ProtocolNumberMatchEntry;
\r
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PseudoFieldMatchEntry;
\r
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.TcMatchEntry;
\r
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanPcpMatchEntry;
\r
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanVidMatchEntry;
\r
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Ipv6ExthdrFlags;
\r
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.StandardMatchType;
\r
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpOp;
\r
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpSha;
\r
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpSpa;
\r
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpTha;
\r
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.ArpTpa;
\r
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthDst;
\r
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthSrc;
\r
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.EthType;
\r
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv4Code;
\r
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv4Type;
\r
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv6Code;
\r
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Icmpv6Type;
\r
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPhyPort;
\r
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPort;
\r
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpDscp;
\r
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpEcn;
\r
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.IpProto;
\r
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv4Dst;
\r
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv4Src;
\r
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Dst;
\r
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Exthdr;
\r
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Flabel;
\r
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdSll;
\r
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdTarget;
\r
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6NdTll;
\r
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Ipv6Src;
\r
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.Metadata;
\r
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsBos;
\r
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsLabel;
\r
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.MplsTc;
\r
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OpenflowBasicClass;
\r
85 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OxmMatchType;
\r
86 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.PbbIsid;
\r
87 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.SctpDst;
\r
88 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.SctpSrc;
\r
89 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TcpDst;
\r
90 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TcpSrc;
\r
91 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.TunnelId;
\r
92 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.UdpDst;
\r
93 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.UdpSrc;
\r
94 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.VlanPcp;
\r
95 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.VlanVid;
\r
96 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.match.grouping.Match;
\r
97 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.oxm.fields.grouping.MatchEntries;
\r
100 * @author michal.polkorab
\r
103 public class MatchDeserializerTest {
\r
105 private OFDeserializer<Match> matchDeserializer;
\r
106 private DeserializerRegistry registry;
\r
109 * Initializes deserializer registry and lookups correct deserializer
\r
112 public void startUp() {
\r
113 registry = new DeserializerRegistryImpl();
\r
115 matchDeserializer = registry.getDeserializer(
\r
116 new MessageCodeKey(EncodeConstants.OF13_VERSION_ID,
\r
117 EncodeConstants.EMPTY_VALUE, Match.class));
\r
121 * Testing Ipv4 address deserialization
\r
124 public void testIpv4Address() {
\r
125 ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("80 00 18 04 00 01 02 03");
\r
127 MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID,
\r
129 key.setExperimenterId(null);
\r
130 OFDeserializer<MatchEntries> entryDeserializer = registry.getDeserializer(key);
\r
131 MatchEntries entry = entryDeserializer.deserialize(buffer);
\r
132 Assert.assertEquals("Wrong Ipv4 address format", new Ipv4Address("0.1.2.3"),
\r
133 entry.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address());
\r
137 * Testing Ipv6 address deserialization
\r
140 public void testIpv6Address() {
\r
141 ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("80 00 34 10 00 00 00 01 00 02 00 03 00 04 00 05 00 06 0F 07");
\r
143 MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID,
\r
145 key.setExperimenterId(null);
\r
146 OFDeserializer<MatchEntries> entryDeserializer = registry.getDeserializer(key);
\r
147 MatchEntries entry = entryDeserializer.deserialize(buffer);
\r
148 Assert.assertEquals("Wrong Ipv6 address format", new Ipv6Address("0000:0001:0002:0003:0004:0005:0006:0F07"),
\r
149 entry.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address());
\r
153 * Testing match deserialization
\r
156 public void testMatch() {
\r
157 ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("00 01 01 AC "
\r
158 + "80 00 00 04 00 00 00 01 "
\r
159 + "80 00 02 04 00 00 00 02 "
\r
160 + "80 00 05 10 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00 04 "
\r
161 + "80 00 07 0C 00 00 00 00 00 05 00 00 00 00 00 06 "
\r
162 + "80 00 09 0C 00 00 00 00 00 07 00 00 00 00 00 08 "
\r
163 + "80 00 0A 02 00 09 "
\r
164 + "80 00 0D 04 00 0A 00 0B "
\r
165 + "80 00 0E 01 0C "
\r
166 + "80 00 10 01 0D "
\r
167 + "80 00 12 01 0E "
\r
168 + "80 00 14 01 0F "
\r
169 + "80 00 17 08 0A 00 00 01 00 00 FF 00 "
\r
170 + "80 00 19 08 0A 00 00 02 00 00 00 FF "
\r
171 + "80 00 1A 02 00 03 "
\r
172 + "80 00 1C 02 00 04 "
\r
173 + "80 00 1E 02 00 05 "
\r
174 + "80 00 20 02 00 06 "
\r
175 + "80 00 22 02 00 07 "
\r
176 + "80 00 24 02 00 08 "
\r
177 + "80 00 26 01 05 "
\r
178 + "80 00 28 01 07 "
\r
179 + "80 00 2A 02 00 10 "
\r
180 + "80 00 2D 08 0A 00 00 09 00 00 FF 00 "
\r
181 + "80 00 2F 08 0A 00 00 0A 00 00 00 FF "
\r
182 + "80 00 31 0C 00 00 00 00 00 01 00 00 00 00 00 03 "
\r
183 + "80 00 33 0C 00 00 00 00 00 02 00 00 00 00 00 04 "
\r
184 + "80 00 35 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 15 "
\r
185 + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16 "
\r
186 + "80 00 37 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 17 "
\r
187 + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18 "
\r
188 + "80 00 39 08 00 00 00 02 00 00 00 03 "
\r
189 + "80 00 3A 01 15 "
\r
190 + "80 00 3C 01 17 "
\r
191 + "80 00 3E 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 20 " //ipv6ndtarget
\r
192 + "80 00 40 06 00 05 00 00 00 01 "
\r
193 + "80 00 42 06 00 05 00 00 00 02 "
\r
194 + "80 00 44 04 00 00 02 03 "
\r
195 + "80 00 46 01 03 "
\r
196 + "80 00 48 01 01 "
\r
197 + "80 00 4B 06 00 00 02 00 00 01 "
\r
198 + "80 00 4D 10 00 00 00 00 00 00 00 07 00 00 00 00 00 00 00 FF "
\r
199 + "80 00 4F 04 00 00 03 04 "
\r
202 Match match = matchDeserializer.deserialize(buffer);
\r
203 Assert.assertEquals("Wrong match type", OxmMatchType.class, match.getType());
\r
204 Assert.assertEquals("Wrong match entries size", 40, match.getMatchEntries().size());
\r
205 List<MatchEntries> entries = match.getMatchEntries();
\r
206 MatchEntries entry0 = entries.get(0);
\r
207 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry0.getOxmClass());
\r
208 Assert.assertEquals("Wrong entry field", InPort.class, entry0.getOxmMatchField());
\r
209 Assert.assertEquals("Wrong entry hasMask", false, entry0.isHasMask());
\r
210 Assert.assertEquals("Wrong entry value", 1,
\r
211 entry0.getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue());
\r
212 MatchEntries entry1 = entries.get(1);
\r
213 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry1.getOxmClass());
\r
214 Assert.assertEquals("Wrong entry field", InPhyPort.class, entry1.getOxmMatchField());
\r
215 Assert.assertEquals("Wrong entry hasMask", false, entry1.isHasMask());
\r
216 Assert.assertEquals("Wrong entry value", 2,
\r
217 entry1.getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue());
\r
218 MatchEntries entry2 = entries.get(2);
\r
219 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry2.getOxmClass());
\r
220 Assert.assertEquals("Wrong entry field", Metadata.class, entry2.getOxmMatchField());
\r
221 Assert.assertEquals("Wrong entry hasMask", true, entry2.isHasMask());
\r
222 Assert.assertArrayEquals("Wrong entry value", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 03"),
\r
223 entry2.getAugmentation(MetadataMatchEntry.class).getMetadata());
\r
224 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 04"),
\r
225 entry2.getAugmentation(MaskMatchEntry.class).getMask());
\r
226 MatchEntries entry3 = entries.get(3);
\r
227 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry3.getOxmClass());
\r
228 Assert.assertEquals("Wrong entry field", EthDst.class, entry3.getOxmMatchField());
\r
229 Assert.assertEquals("Wrong entry hasMask", true, entry3.isHasMask());
\r
230 Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:05"),
\r
231 entry3.getAugmentation(MacAddressMatchEntry.class).getMacAddress());
\r
232 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 06"),
\r
233 entry3.getAugmentation(MaskMatchEntry.class).getMask());
\r
234 MatchEntries entry4 = entries.get(4);
\r
235 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry4.getOxmClass());
\r
236 Assert.assertEquals("Wrong entry field", EthSrc.class, entry4.getOxmMatchField());
\r
237 Assert.assertEquals("Wrong entry hasMask", true, entry4.isHasMask());
\r
238 Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:07"),
\r
239 entry4.getAugmentation(MacAddressMatchEntry.class).getMacAddress());
\r
240 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 08"),
\r
241 entry4.getAugmentation(MaskMatchEntry.class).getMask());
\r
242 MatchEntries entry5 = entries.get(5);
\r
243 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry5.getOxmClass());
\r
244 Assert.assertEquals("Wrong entry field", EthType.class, entry5.getOxmMatchField());
\r
245 Assert.assertEquals("Wrong entry hasMask", false, entry5.isHasMask());
\r
246 Assert.assertEquals("Wrong entry value", 9,
\r
247 entry5.getAugmentation(EthTypeMatchEntry.class).getEthType().getValue().intValue());
\r
248 MatchEntries entry6 = entries.get(6);
\r
249 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry6.getOxmClass());
\r
250 Assert.assertEquals("Wrong entry field", VlanVid.class, entry6.getOxmMatchField());
\r
251 Assert.assertEquals("Wrong entry hasMask", true, entry6.isHasMask());
\r
252 Assert.assertEquals("Wrong entry value", 10,
\r
253 entry6.getAugmentation(VlanVidMatchEntry.class).getVlanVid().intValue());
\r
254 Assert.assertEquals("Wrong entry value", false,
\r
255 entry6.getAugmentation(VlanVidMatchEntry.class).isCfiBit());
\r
256 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 0B"),
\r
257 entry6.getAugmentation(MaskMatchEntry.class).getMask());
\r
258 MatchEntries entry7 = entries.get(7);
\r
259 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry7.getOxmClass());
\r
260 Assert.assertEquals("Wrong entry field", VlanPcp.class, entry7.getOxmMatchField());
\r
261 Assert.assertEquals("Wrong entry hasMask", false, entry7.isHasMask());
\r
262 Assert.assertEquals("Wrong entry value", 12,
\r
263 entry7.getAugmentation(VlanPcpMatchEntry.class).getVlanPcp().intValue());
\r
264 MatchEntries entry8 = entries.get(8);
\r
265 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry8.getOxmClass());
\r
266 Assert.assertEquals("Wrong entry field", IpDscp.class, entry8.getOxmMatchField());
\r
267 Assert.assertEquals("Wrong entry hasMask", false, entry8.isHasMask());
\r
268 Assert.assertEquals("Wrong entry value", 13,
\r
269 entry8.getAugmentation(DscpMatchEntry.class).getDscp().getValue().intValue());
\r
270 MatchEntries entry9 = entries.get(9);
\r
271 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry9.getOxmClass());
\r
272 Assert.assertEquals("Wrong entry field", IpEcn.class, entry9.getOxmMatchField());
\r
273 Assert.assertEquals("Wrong entry hasMask", false, entry9.isHasMask());
\r
274 Assert.assertEquals("Wrong entry value", 14,
\r
275 entry9.getAugmentation(EcnMatchEntry.class).getEcn().intValue());
\r
276 MatchEntries entry10 = entries.get(10);
\r
277 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry10.getOxmClass());
\r
278 Assert.assertEquals("Wrong entry field", IpProto.class, entry10.getOxmMatchField());
\r
279 Assert.assertEquals("Wrong entry hasMask", false, entry10.isHasMask());
\r
280 Assert.assertEquals("Wrong entry value", 15,
\r
281 entry10.getAugmentation(ProtocolNumberMatchEntry.class).getProtocolNumber().intValue());
\r
282 MatchEntries entry11 = entries.get(11);
\r
283 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry11.getOxmClass());
\r
284 Assert.assertEquals("Wrong entry field", Ipv4Src.class, entry11.getOxmMatchField());
\r
285 Assert.assertEquals("Wrong entry hasMask", true, entry11.isHasMask());
\r
286 Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.1"),
\r
287 entry11.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address());
\r
288 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 FF 00"),
\r
289 entry11.getAugmentation(MaskMatchEntry.class).getMask());
\r
290 MatchEntries entry12 = entries.get(12);
\r
291 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry12.getOxmClass());
\r
292 Assert.assertEquals("Wrong entry field", Ipv4Dst.class, entry12.getOxmMatchField());
\r
293 Assert.assertEquals("Wrong entry hasMask", true, entry12.isHasMask());
\r
294 Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.2"),
\r
295 entry12.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address());
\r
296 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 FF"),
\r
297 entry12.getAugmentation(MaskMatchEntry.class).getMask());
\r
298 MatchEntries entry13 = entries.get(13);
\r
299 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry13.getOxmClass());
\r
300 Assert.assertEquals("Wrong entry field", TcpSrc.class, entry13.getOxmMatchField());
\r
301 Assert.assertEquals("Wrong entry hasMask", false, entry13.isHasMask());
\r
302 Assert.assertEquals("Wrong entry value", 3,
\r
303 entry13.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
\r
304 MatchEntries entry14 = entries.get(14);
\r
305 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry14.getOxmClass());
\r
306 Assert.assertEquals("Wrong entry field", TcpDst.class, entry14.getOxmMatchField());
\r
307 Assert.assertEquals("Wrong entry hasMask", false, entry14.isHasMask());
\r
308 Assert.assertEquals("Wrong entry value", 4,
\r
309 entry14.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
\r
310 MatchEntries entry15 = entries.get(15);
\r
311 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry15.getOxmClass());
\r
312 Assert.assertEquals("Wrong entry field", UdpSrc.class, entry15.getOxmMatchField());
\r
313 Assert.assertEquals("Wrong entry hasMask", false, entry15.isHasMask());
\r
314 Assert.assertEquals("Wrong entry value", 5,
\r
315 entry15.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
\r
316 MatchEntries entry16 = entries.get(16);
\r
317 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry16.getOxmClass());
\r
318 Assert.assertEquals("Wrong entry field", UdpDst.class, entry16.getOxmMatchField());
\r
319 Assert.assertEquals("Wrong entry hasMask", false, entry16.isHasMask());
\r
320 Assert.assertEquals("Wrong entry value", 6,
\r
321 entry16.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
\r
322 MatchEntries entry17 = entries.get(17);
\r
323 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry17.getOxmClass());
\r
324 Assert.assertEquals("Wrong entry field", SctpSrc.class, entry17.getOxmMatchField());
\r
325 Assert.assertEquals("Wrong entry hasMask", false, entry17.isHasMask());
\r
326 Assert.assertEquals("Wrong entry value", 7,
\r
327 entry17.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
\r
328 MatchEntries entry18 = entries.get(18);
\r
329 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry18.getOxmClass());
\r
330 Assert.assertEquals("Wrong entry field", SctpDst.class, entry18.getOxmMatchField());
\r
331 Assert.assertEquals("Wrong entry hasMask", false, entry18.isHasMask());
\r
332 Assert.assertEquals("Wrong entry value", 8,
\r
333 entry18.getAugmentation(PortMatchEntry.class).getPort().getValue().intValue());
\r
334 MatchEntries entry19 = entries.get(19);
\r
335 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry19.getOxmClass());
\r
336 Assert.assertEquals("Wrong entry field", Icmpv4Type.class, entry19.getOxmMatchField());
\r
337 Assert.assertEquals("Wrong entry hasMask", false, entry19.isHasMask());
\r
338 Assert.assertEquals("Wrong entry value", 5,
\r
339 entry19.getAugmentation(Icmpv4TypeMatchEntry.class).getIcmpv4Type().intValue());
\r
340 MatchEntries entry20 = entries.get(20);
\r
341 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry20.getOxmClass());
\r
342 Assert.assertEquals("Wrong entry field", Icmpv4Code.class, entry20.getOxmMatchField());
\r
343 Assert.assertEquals("Wrong entry hasMask", false, entry20.isHasMask());
\r
344 Assert.assertEquals("Wrong entry value", 7,
\r
345 entry20.getAugmentation(Icmpv4CodeMatchEntry.class).getIcmpv4Code().intValue());
\r
346 MatchEntries entry21 = entries.get(21);
\r
347 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry21.getOxmClass());
\r
348 Assert.assertEquals("Wrong entry field", ArpOp.class, entry21.getOxmMatchField());
\r
349 Assert.assertEquals("Wrong entry hasMask", false, entry21.isHasMask());
\r
350 Assert.assertEquals("Wrong entry value", 16,
\r
351 entry21.getAugmentation(OpCodeMatchEntry.class).getOpCode().intValue());
\r
352 MatchEntries entry22 = entries.get(22);
\r
353 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry22.getOxmClass());
\r
354 Assert.assertEquals("Wrong entry field", ArpSpa.class, entry22.getOxmMatchField());
\r
355 Assert.assertEquals("Wrong entry hasMask", true, entry22.isHasMask());
\r
356 Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.9"),
\r
357 entry22.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address());
\r
358 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 FF 00"),
\r
359 entry22.getAugmentation(MaskMatchEntry.class).getMask());
\r
360 MatchEntries entry23 = entries.get(23);
\r
361 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry23.getOxmClass());
\r
362 Assert.assertEquals("Wrong entry field", ArpTpa.class, entry23.getOxmMatchField());
\r
363 Assert.assertEquals("Wrong entry hasMask", true, entry23.isHasMask());
\r
364 Assert.assertEquals("Wrong entry value", new Ipv4Address("10.0.0.10"),
\r
365 entry23.getAugmentation(Ipv4AddressMatchEntry.class).getIpv4Address());
\r
366 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 FF"),
\r
367 entry23.getAugmentation(MaskMatchEntry.class).getMask());
\r
368 MatchEntries entry24 = entries.get(24);
\r
369 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry24.getOxmClass());
\r
370 Assert.assertEquals("Wrong entry field", ArpSha.class, entry24.getOxmMatchField());
\r
371 Assert.assertEquals("Wrong entry hasMask", true, entry24.isHasMask());
\r
372 Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:01"),
\r
373 entry24.getAugmentation(MacAddressMatchEntry.class).getMacAddress());
\r
374 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 03"),
\r
375 entry24.getAugmentation(MaskMatchEntry.class).getMask());
\r
376 MatchEntries entry25 = entries.get(25);
\r
377 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry25.getOxmClass());
\r
378 Assert.assertEquals("Wrong entry field", ArpTha.class, entry25.getOxmMatchField());
\r
379 Assert.assertEquals("Wrong entry hasMask", true, entry25.isHasMask());
\r
380 Assert.assertEquals("Wrong entry value", new MacAddress("00:00:00:00:00:02"),
\r
381 entry25.getAugmentation(MacAddressMatchEntry.class).getMacAddress());
\r
382 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 04"),
\r
383 entry25.getAugmentation(MaskMatchEntry.class).getMask());
\r
384 MatchEntries entry26 = entries.get(26);
\r
385 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry26.getOxmClass());
\r
386 Assert.assertEquals("Wrong entry field", Ipv6Src.class, entry26.getOxmMatchField());
\r
387 Assert.assertEquals("Wrong entry hasMask", true, entry26.isHasMask());
\r
388 Assert.assertEquals("Wrong entry value", new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0015"),
\r
389 entry26.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address());
\r
390 Assert.assertArrayEquals("Wrong entry mask",
\r
391 ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 16"),
\r
392 entry26.getAugmentation(MaskMatchEntry.class).getMask());
\r
393 MatchEntries entry27 = entries.get(27);
\r
394 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry27.getOxmClass());
\r
395 Assert.assertEquals("Wrong entry field", Ipv6Dst.class, entry27.getOxmMatchField());
\r
396 Assert.assertEquals("Wrong entry hasMask", true, entry27.isHasMask());
\r
397 Assert.assertEquals("Wrong entry value", new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0017"),
\r
398 entry27.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address());
\r
399 Assert.assertArrayEquals("Wrong entry mask",
\r
400 ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 18"),
\r
401 entry27.getAugmentation(MaskMatchEntry.class).getMask());
\r
402 MatchEntries entry28 = entries.get(28);
\r
403 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry28.getOxmClass());
\r
404 Assert.assertEquals("Wrong entry field", Ipv6Flabel.class, entry28.getOxmMatchField());
\r
405 Assert.assertEquals("Wrong entry hasMask", true, entry28.isHasMask());
\r
406 Assert.assertEquals("Wrong entry value", 2,
\r
407 entry28.getAugmentation(Ipv6FlabelMatchEntry.class).getIpv6Flabel().getValue().intValue());
\r
408 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 03"),
\r
409 entry28.getAugmentation(MaskMatchEntry.class).getMask());
\r
410 MatchEntries entry29 = entries.get(29);
\r
411 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry29.getOxmClass());
\r
412 Assert.assertEquals("Wrong entry field", Icmpv6Type.class, entry29.getOxmMatchField());
\r
413 Assert.assertEquals("Wrong entry hasMask", false, entry29.isHasMask());
\r
414 Assert.assertEquals("Wrong entry value", 21,
\r
415 entry29.getAugmentation(Icmpv6TypeMatchEntry.class).getIcmpv6Type().intValue());
\r
416 MatchEntries entry30 = entries.get(30);
\r
417 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry30.getOxmClass());
\r
418 Assert.assertEquals("Wrong entry field", Icmpv6Code.class, entry30.getOxmMatchField());
\r
419 Assert.assertEquals("Wrong entry hasMask", false, entry30.isHasMask());
\r
420 Assert.assertEquals("Wrong entry value", 23,
\r
421 entry30.getAugmentation(Icmpv6CodeMatchEntry.class).getIcmpv6Code().intValue());
\r
422 MatchEntries entry31 = entries.get(31);
\r
423 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry31.getOxmClass());
\r
424 Assert.assertEquals("Wrong entry field", Ipv6NdTarget.class, entry31.getOxmMatchField());
\r
425 Assert.assertEquals("Wrong entry hasMask", false, entry31.isHasMask());
\r
426 Assert.assertEquals("Wrong entry value", new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0020"),
\r
427 entry31.getAugmentation(Ipv6AddressMatchEntry.class).getIpv6Address());
\r
428 MatchEntries entry32 = entries.get(32);
\r
429 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry32.getOxmClass());
\r
430 Assert.assertEquals("Wrong entry field", Ipv6NdSll.class, entry32.getOxmMatchField());
\r
431 Assert.assertEquals("Wrong entry hasMask", false, entry32.isHasMask());
\r
432 Assert.assertEquals("Wrong entry value", new MacAddress("00:05:00:00:00:01"),
\r
433 entry32.getAugmentation(MacAddressMatchEntry.class).getMacAddress());
\r
434 MatchEntries entry33 = entries.get(33);
\r
435 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry33.getOxmClass());
\r
436 Assert.assertEquals("Wrong entry field", Ipv6NdTll.class, entry33.getOxmMatchField());
\r
437 Assert.assertEquals("Wrong entry hasMask", false, entry33.isHasMask());
\r
438 Assert.assertEquals("Wrong entry value", new MacAddress("00:05:00:00:00:02"),
\r
439 entry33.getAugmentation(MacAddressMatchEntry.class).getMacAddress());
\r
440 MatchEntries entry34 = entries.get(34);
\r
441 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry34.getOxmClass());
\r
442 Assert.assertEquals("Wrong entry field", MplsLabel.class, entry34.getOxmMatchField());
\r
443 Assert.assertEquals("Wrong entry hasMask", false, entry34.isHasMask());
\r
444 Assert.assertEquals("Wrong entry value", 515,
\r
445 entry34.getAugmentation(MplsLabelMatchEntry.class).getMplsLabel().intValue());
\r
446 MatchEntries entry35 = entries.get(35);
\r
447 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry35.getOxmClass());
\r
448 Assert.assertEquals("Wrong entry field", MplsTc.class, entry35.getOxmMatchField());
\r
449 Assert.assertEquals("Wrong entry hasMask", false, entry35.isHasMask());
\r
450 Assert.assertEquals("Wrong entry value", 3,
\r
451 entry35.getAugmentation(TcMatchEntry.class).getTc().intValue());
\r
452 MatchEntries entry36 = entries.get(36);
\r
453 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry36.getOxmClass());
\r
454 Assert.assertEquals("Wrong entry field", MplsBos.class, entry36.getOxmMatchField());
\r
455 Assert.assertEquals("Wrong entry hasMask", false, entry36.isHasMask());
\r
456 Assert.assertEquals("Wrong entry value", true,
\r
457 entry36.getAugmentation(BosMatchEntry.class).isBos());
\r
458 MatchEntries entry37 = entries.get(37);
\r
459 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry37.getOxmClass());
\r
460 Assert.assertEquals("Wrong entry field", PbbIsid.class, entry37.getOxmMatchField());
\r
461 Assert.assertEquals("Wrong entry hasMask", true, entry37.isHasMask());
\r
462 Assert.assertEquals("Wrong entry value", 2,
\r
463 entry37.getAugmentation(IsidMatchEntry.class).getIsid().intValue());
\r
464 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 01"),
\r
465 entry37.getAugmentation(MaskMatchEntry.class).getMask());
\r
466 MatchEntries entry38 = entries.get(38);
\r
467 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry38.getOxmClass());
\r
468 Assert.assertEquals("Wrong entry field", TunnelId.class, entry38.getOxmMatchField());
\r
469 Assert.assertEquals("Wrong entry hasMask", true, entry38.isHasMask());
\r
470 Assert.assertArrayEquals("Wrong entry value", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 07"),
\r
471 entry38.getAugmentation(MetadataMatchEntry.class).getMetadata());
\r
472 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("00 00 00 00 00 00 00 FF"),
\r
473 entry38.getAugmentation(MaskMatchEntry.class).getMask());
\r
474 MatchEntries entry39 = entries.get(39);
\r
475 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry39.getOxmClass());
\r
476 Assert.assertEquals("Wrong entry field", Ipv6Exthdr.class, entry39.getOxmMatchField());
\r
477 Assert.assertEquals("Wrong entry hasMask", true, entry39.isHasMask());
\r
478 Assert.assertEquals("Wrong entry value",
\r
479 new Ipv6ExthdrFlags(false, false, false, false, false, false, false, false, false),
\r
480 entry39.getAugmentation(PseudoFieldMatchEntry.class).getPseudoField());
\r
481 Assert.assertArrayEquals("Wrong entry mask", ByteBufUtils.hexStringToBytes("03 04"),
\r
482 entry39.getAugmentation(MaskMatchEntry.class).getMask());
\r
483 Assert.assertTrue("Unread data", buffer.readableBytes() == 0);
\r
487 * Testing header deserialization
\r
490 public void testHeaders() {
\r
491 ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("80 00 18 04 00 01 02 03");
\r
493 MatchEntryDeserializerKey key = new MatchEntryDeserializerKey(EncodeConstants.OF13_VERSION_ID,
\r
495 key.setExperimenterId(null);
\r
496 HeaderDeserializer<MatchEntries> entryDeserializer = registry.getDeserializer(key);
\r
497 MatchEntries entry = entryDeserializer.deserializeHeader(buffer);
\r
498 Assert.assertEquals("Wrong entry class", OpenflowBasicClass.class, entry.getOxmClass());
\r
499 Assert.assertEquals("Wrong entry field", Ipv4Dst.class, entry.getOxmMatchField());
\r
500 Assert.assertEquals("Wrong entry hasMask", false, entry.isHasMask());
\r
501 Assert.assertEquals("Wrong Ipv4 address", null, entry.getAugmentation(Ipv4AddressMatchEntry.class));
\r
505 * Testing standard match type
\r
508 public void testStandardMatch() {
\r
509 ByteBuf buffer = ByteBufUtils.hexStringToByteBuf("00 00 00 10 80 00 04 08 00 00 00 00 00 00 00 01");
\r
511 Match match = matchDeserializer.deserialize(buffer);
\r
513 Assert.assertEquals("Wrong match type", StandardMatchType.class, match.getType());
\r
514 Assert.assertEquals("Wrong match entries size", 1, match.getMatchEntries().size());
\r
Code Review / openflowjava.git / blob