sfc/classifier/impl/src/test/java/org/opendaylight/netvirt/sfc/classifier/utils/AclMatchesTest.java

   1 /*
   2  * Copyright © 2017 Ericsson, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.netvirt.sfc.classifier.utils;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotEquals;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.assertNull;
  15 import static org.junit.Assert.assertTrue;
  16
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Set;
  21 import org.junit.Test;
  22 import org.opendaylight.genius.mdsalutil.NwConstants;
  23 import org.opendaylight.genius.mdsalutil.packet.IPProtocols;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.Matches;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.MatchesBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceEth;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceEthBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIp;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.AceIpBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv4;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv4Builder;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv6;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.acl.access.list.entries.ace.matches.ace.type.ace.ip.ace.ip.version.AceIpv6Builder;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.DestinationPortRange;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.DestinationPortRangeBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.SourcePortRange;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160218.acl.transport.header.fields.SourcePortRangeBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatch;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.IpMatch;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4Match;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6Match;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.general.rev140714.GeneralAugMatchNodesNodeTableFlow;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.NxAugMatchNodesNodeTableFlow;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.tcp.dst.grouping.NxmOfTcpDst;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.tcp.src.grouping.NxmOfTcpSrc;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.udp.dst.grouping.NxmOfUdpDst;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.match.rev140714.nxm.of.udp.src.grouping.NxmOfUdpSrc;
  54 import org.opendaylight.yangtools.yang.common.Uint32;
  55 import org.opendaylight.yangtools.yang.common.Uint8;
  56
  57 public class AclMatchesTest {
  58
  59     private static final String MAC_SRC_STR = "11:22:33:44:55:66";
  60     private static final String MAC_DST_STR = "66:55:44:33:22:11";
  61     private static final String IPV4_DST_STR = "10.1.2.0/24";
  62     private static final String IPV4_SRC_STR = "10.1.2.3/32";
  63     private static final String IPV6_DST_STR = "2001:DB8:AC10:FE01::/64";
  64     private static final String IPV6_SRC_STR = "2001:db8:85a3:7334::/64";
  65     private static final int TCP_SRC_LOWER_PORT = 80;
  66     private static final int TCP_SRC_UPPER_PORT = 82;
  67     private static final int TCP_DST_LOWER_PORT = 800;
  68     private static final int TCP_DST_UPPER_PORT = 800;
  69     private static final int UDP_SRC_LOWER_PORT = 90;
  70     private static final int UDP_SRC_UPPER_PORT = 90;
  71     private static final int UDP_DST_LOWER_PORT = 900;
  72     private static final int UDP_DST_UPPER_PORT = 902;
  73     private static final short DSCP_VALUE = (short) 42;
  74
  75
  76     @Test
  77     public void buildEthMatchTest() {
  78         AceEthBuilder aceEthBuilder = new AceEthBuilder();
  79         aceEthBuilder.setDestinationMacAddress(new MacAddress(MAC_DST_STR));
  80         aceEthBuilder.setSourceMacAddress(new MacAddress(MAC_SRC_STR));
  81
  82         MatchesBuilder matchesBuilder = new MatchesBuilder();
  83         matchesBuilder.setAceType(aceEthBuilder.build());
  84
  85         // Create the aclMatches that is the object to be tested
  86         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
  87         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
  88
  89         for (MatchBuilder matchBuilder : matchBuilds) {
  90             // The ethernet match should be there with src/dst values
  91             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
  92             assertNotNull(ethMatch);
  93             assertEquals(ethMatch.getEthernetSource().getAddress().getValue(), MAC_SRC_STR);
  94             assertEquals(ethMatch.getEthernetDestination().getAddress().getValue(), MAC_DST_STR);
  95
  96             // The rest should be null
  97             assertNull(matchBuilder.getIpMatch());
  98             assertNull(matchBuilder.getLayer3Match());
  99             assertNull(matchBuilder.getLayer4Match());
 100         }
 101     }
 102
 103     @Test
 104     public void buildIpv4MatchTest() {
 105         AceIpv4Builder aceIpv4 = new AceIpv4Builder();
 106         aceIpv4.setDestinationIpv4Network(new Ipv4Prefix(IPV4_DST_STR));
 107         aceIpv4.setSourceIpv4Network(new Ipv4Prefix(IPV4_SRC_STR));
 108
 109         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 110         aceIpBuilder.setAceIpVersion(aceIpv4.build());
 111
 112         MatchesBuilder matchesBuilder = new MatchesBuilder();
 113         matchesBuilder.setAceType(aceIpBuilder.build());
 114
 115         // Create the aclMatches that is the object to be tested
 116         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 117         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 118
 119         for (MatchBuilder matchBuilder : matchBuilds) {
 120             // The layer3 match should be there with src/dst values
 121             Ipv4Match l3 = (Ipv4Match) matchBuilder.getLayer3Match();
 122             assertNotNull(l3);
 123             assertEquals(l3.getIpv4Destination().getValue().toString(), IPV4_DST_STR);
 124             assertEquals(l3.getIpv4Source().getValue().toString(), IPV4_SRC_STR);
 125
 126             // There should be an IPv4 etherType set
 127             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 128             assertNotNull(ethMatch);
 129             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 130
 131             // The rest should be null
 132             assertNull(matchBuilder.getIpMatch());
 133             assertNull(matchBuilder.getLayer4Match());
 134         }
 135         assertEquals(1, matchBuilds.size());
 136     }
 137
 138     @Test
 139     public void buildIpv4SrcLwrTcpMatchTest() {
 140         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 141         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 142         aceIpBuilder.setProtocol(IPProtocols.TCP.shortValue());
 143
 144         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 145         srcPortRange.setLowerPort(new PortNumber(TCP_SRC_LOWER_PORT));
 146         aceIpBuilder.setSourcePortRange(srcPortRange.build());
 147
 148         MatchesBuilder matchesBuilder = new MatchesBuilder();
 149         matchesBuilder.setAceType(aceIpBuilder.build());
 150
 151         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 152         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 153
 154         Set<Integer> srcTcpMatches = new HashSet<>();
 155
 156         for (MatchBuilder matchBuilder : matchBuilds) {
 157             // There should be an IPv4 etherType set
 158             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 159             assertNotNull(ethMatch);
 160             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 161
 162             // Make sure its TCP
 163             IpMatch ipMatch = matchBuilder.getIpMatch();
 164             assertNotNull(ipMatch);
 165             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.TCP.shortValue()));
 166
 167             NxmOfTcpSrc tcpSrc = matchBuilder
 168                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 169                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfTcpSrc();
 170
 171
 172             if (tcpSrc != null) {
 173                 srcTcpMatches.add(tcpSrc.getPort().getValue().toJava());
 174                 srcTcpMatches.add(tcpSrc.getMask().toJava());
 175             }
 176
 177             // The layer3 match should be null
 178             assertNull(matchBuilder.getLayer3Match());
 179         }
 180         assertEquals(1, matchBuilds.size());
 181         assertEquals(2, srcTcpMatches.size());
 182         assertTrue(srcTcpMatches.contains(TCP_SRC_LOWER_PORT));
 183         assertTrue(srcTcpMatches.contains(65535));
 184     }
 185
 186     @Test
 187     public void buildIpv4SrcTcpMatchTest() {
 188         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 189         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 190         aceIpBuilder.setProtocol(IPProtocols.TCP.shortValue());
 191
 192         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 193         srcPortRange.setLowerPort(new PortNumber(TCP_SRC_LOWER_PORT));
 194         srcPortRange.setUpperPort(new PortNumber(TCP_SRC_UPPER_PORT));
 195         aceIpBuilder.setSourcePortRange(srcPortRange.build());
 196
 197         MatchesBuilder matchesBuilder = new MatchesBuilder();
 198         matchesBuilder.setAceType(aceIpBuilder.build());
 199
 200         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 201         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 202
 203         Set<Integer> srcTcpMatches = new HashSet<>();
 204
 205         for (MatchBuilder matchBuilder : matchBuilds) {
 206             // There should be an IPv4 etherType set
 207             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 208             assertNotNull(ethMatch);
 209             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 210
 211             // Make sure its TCP
 212             IpMatch ipMatch = matchBuilder.getIpMatch();
 213             assertNotNull(ipMatch);
 214             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.TCP.shortValue()));
 215
 216             NxmOfTcpSrc tcpSrc = matchBuilder
 217                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 218                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfTcpSrc();
 219
 220
 221             if (tcpSrc != null) {
 222                 srcTcpMatches.add(tcpSrc.getPort().getValue().toJava());
 223                 srcTcpMatches.add(tcpSrc.getMask().toJava());
 224             }
 225
 226             // The layer3 match should be null
 227             assertNull(matchBuilder.getLayer3Match());
 228         }
 229         assertEquals(2, matchBuilds.size());
 230         assertEquals(4, srcTcpMatches.size());
 231         assertTrue(srcTcpMatches.contains(TCP_SRC_LOWER_PORT));
 232         assertTrue(srcTcpMatches.contains(TCP_SRC_UPPER_PORT));
 233         assertTrue(srcTcpMatches.contains(65535));
 234         assertTrue(srcTcpMatches.contains(65534));
 235     }
 236
 237     @Test
 238     public void buildIpv4DstLwrTcpMatchTest() {
 239         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 240         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 241         aceIpBuilder.setProtocol(IPProtocols.TCP.shortValue());
 242
 243         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 244         dstPortRange.setLowerPort(new PortNumber(TCP_DST_LOWER_PORT));
 245         aceIpBuilder.setDestinationPortRange(dstPortRange.build());
 246
 247         MatchesBuilder matchesBuilder = new MatchesBuilder();
 248         matchesBuilder.setAceType(aceIpBuilder.build());
 249
 250         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 251         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 252
 253         Set<Integer> dstTcpMatches = new HashSet<>();
 254
 255         for (MatchBuilder matchBuilder : matchBuilds) {
 256             // There should be an IPv4 etherType set
 257             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 258             assertNotNull(ethMatch);
 259             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 260
 261             // Make sure its TCP
 262             IpMatch ipMatch = matchBuilder.getIpMatch();
 263             assertNotNull(ipMatch);
 264             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.TCP.shortValue()));
 265
 266             NxmOfTcpDst tcpDst = matchBuilder
 267                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 268                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfTcpDst();
 269
 270             if (tcpDst != null) {
 271                 dstTcpMatches.add(tcpDst.getPort().getValue().toJava());
 272                 dstTcpMatches.add(tcpDst.getMask().toJava());
 273             }
 274             // The layer3 match should be null
 275             assertNull(matchBuilder.getLayer3Match());
 276         }
 277         assertEquals(1, matchBuilds.size());
 278         assertEquals(2, dstTcpMatches.size());
 279         assertTrue(dstTcpMatches.contains(TCP_DST_LOWER_PORT));
 280         assertTrue(dstTcpMatches.contains(65535));
 281     }
 282
 283     @Test
 284     public void buildIpv4DstTcpMatchTest() {
 285         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 286         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 287         aceIpBuilder.setProtocol(IPProtocols.TCP.shortValue());
 288
 289         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 290         dstPortRange.setLowerPort(new PortNumber(TCP_DST_LOWER_PORT));
 291         dstPortRange.setUpperPort(new PortNumber(TCP_DST_UPPER_PORT));
 292         aceIpBuilder.setDestinationPortRange(dstPortRange.build());
 293
 294         MatchesBuilder matchesBuilder = new MatchesBuilder();
 295         matchesBuilder.setAceType(aceIpBuilder.build());
 296
 297         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 298         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 299
 300         Set<Integer> dstTcpMatches = new HashSet<>();
 301
 302         for (MatchBuilder matchBuilder : matchBuilds) {
 303             // There should be an IPv4 etherType set
 304             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 305             assertNotNull(ethMatch);
 306             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 307
 308             // Make sure its TCP
 309             IpMatch ipMatch = matchBuilder.getIpMatch();
 310             assertNotNull(ipMatch);
 311             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.TCP.shortValue()));
 312
 313             NxmOfTcpDst tcpDst = matchBuilder
 314                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 315                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfTcpDst();
 316
 317             if (tcpDst != null) {
 318                 dstTcpMatches.add(tcpDst.getPort().getValue().toJava());
 319                 dstTcpMatches.add(tcpDst.getMask().toJava());
 320             }
 321             // The layer3 match should be null
 322             assertNull(matchBuilder.getLayer3Match());
 323         }
 324         assertEquals(1, matchBuilds.size());
 325         assertEquals(2, dstTcpMatches.size());
 326         assertTrue(dstTcpMatches.contains(TCP_DST_LOWER_PORT));
 327         assertTrue(dstTcpMatches.contains(TCP_DST_UPPER_PORT));
 328         assertTrue(dstTcpMatches.contains(65535));
 329     }
 330
 331     @Test
 332     public void buildIpv4TcpMatchTest() {
 333         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 334         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 335         aceIpBuilder.setProtocol(IPProtocols.TCP.shortValue());
 336
 337         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 338         srcPortRange.setLowerPort(new PortNumber(TCP_SRC_LOWER_PORT));
 339         srcPortRange.setUpperPort(new PortNumber(TCP_SRC_UPPER_PORT));
 340         aceIpBuilder.setSourcePortRange(srcPortRange.build());
 341
 342         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 343         dstPortRange.setLowerPort(new PortNumber(TCP_DST_LOWER_PORT));
 344         dstPortRange.setUpperPort(new PortNumber(TCP_DST_UPPER_PORT));
 345         aceIpBuilder.setDestinationPortRange(dstPortRange.build());
 346
 347         MatchesBuilder matchesBuilder = new MatchesBuilder();
 348         matchesBuilder.setAceType(aceIpBuilder.build());
 349
 350         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 351         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 352
 353         Set<Integer> dstTcpMatches = new HashSet<>();
 354         Set<Integer> srcTcpMatches = new HashSet<>();
 355
 356         for (MatchBuilder matchBuilder : matchBuilds) {
 357             // There should be an IPv4 etherType set
 358             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 359             assertNotNull(ethMatch);
 360             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 361
 362             // Make sure its TCP
 363             IpMatch ipMatch = matchBuilder.getIpMatch();
 364             assertNotNull(ipMatch);
 365             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.TCP.shortValue()));
 366
 367             NxmOfTcpSrc tcpSrc = matchBuilder
 368                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 369                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfTcpSrc();
 370
 371             NxmOfTcpDst tcpDst = matchBuilder
 372                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(1)
 373                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfTcpDst();
 374
 375             if (tcpSrc != null) {
 376                 srcTcpMatches.add(tcpSrc.getPort().getValue().toJava());
 377                 srcTcpMatches.add(tcpSrc.getMask().toJava());
 378             }
 379
 380             if (tcpDst != null) {
 381                 dstTcpMatches.add(tcpDst.getPort().getValue().toJava());
 382                 dstTcpMatches.add(tcpDst.getMask().toJava());
 383             }
 384             // The layer3 match should be null
 385             assertNull(matchBuilder.getLayer3Match());
 386         }
 387         assertEquals(2, matchBuilds.size());
 388         assertEquals(4, srcTcpMatches.size());
 389         assertEquals(2, dstTcpMatches.size());
 390
 391         assertTrue(srcTcpMatches.contains(TCP_SRC_LOWER_PORT));
 392         assertTrue(srcTcpMatches.contains(TCP_SRC_UPPER_PORT));
 393         assertTrue(srcTcpMatches.contains(65535));
 394         assertTrue(srcTcpMatches.contains(65534));
 395
 396         assertTrue(dstTcpMatches.contains(TCP_DST_LOWER_PORT));
 397         assertTrue(dstTcpMatches.contains(TCP_DST_UPPER_PORT));
 398         assertTrue(dstTcpMatches.contains(65535));
 399     }
 400
 401     @Test
 402     public void buildIpv4SrcLwrUdpMatchTest() {
 403         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 404         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 405         aceIpBuilder.setProtocol(IPProtocols.UDP.shortValue());
 406
 407         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 408         srcPortRange.setLowerPort(new PortNumber(UDP_SRC_LOWER_PORT));
 409         aceIpBuilder.setSourcePortRange(srcPortRange.build());
 410
 411         MatchesBuilder matchesBuilder = new MatchesBuilder();
 412         matchesBuilder.setAceType(aceIpBuilder.build());
 413
 414         // Create the aclMatches that is the object to be tested
 415         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 416         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 417
 418         Set<Integer> srcUdpMatches = new HashSet<>();
 419
 420         for (MatchBuilder matchBuilder : matchBuilds) {
 421             // There should be an IPv4 etherType set
 422             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 423             assertNotNull(ethMatch);
 424             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 425
 426             // Make sure its UDP
 427             IpMatch ipMatch = matchBuilder.getIpMatch();
 428             assertNotNull(ipMatch);
 429             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.UDP.shortValue()));
 430
 431             NxmOfUdpSrc udpSrc = matchBuilder
 432                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 433                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfUdpSrc();
 434
 435             if (udpSrc != null) {
 436                 srcUdpMatches.add(udpSrc.getPort().getValue().toJava());
 437                 srcUdpMatches.add(udpSrc.getMask().toJava());
 438             }
 439
 440             // The layer3 match should be null
 441             assertNull(matchBuilder.getLayer3Match());
 442         }
 443         assertEquals(1, matchBuilds.size());
 444         assertEquals(2, srcUdpMatches.size());
 445         assertTrue(srcUdpMatches.contains(UDP_SRC_LOWER_PORT));
 446         assertTrue(srcUdpMatches.contains(65535));
 447     }
 448
 449     @Test
 450     public void buildIpv4SrcUdpMatchTest() {
 451         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 452         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 453         aceIpBuilder.setProtocol(IPProtocols.UDP.shortValue());
 454
 455         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 456         srcPortRange.setLowerPort(new PortNumber(UDP_SRC_LOWER_PORT));
 457         srcPortRange.setUpperPort(new PortNumber(UDP_SRC_UPPER_PORT));
 458         aceIpBuilder.setSourcePortRange(srcPortRange.build());
 459
 460         MatchesBuilder matchesBuilder = new MatchesBuilder();
 461         matchesBuilder.setAceType(aceIpBuilder.build());
 462
 463         // Create the aclMatches that is the object to be tested
 464         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 465         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 466
 467         Set<Integer> srcUdpMatches = new HashSet<>();
 468
 469         for (MatchBuilder matchBuilder : matchBuilds) {
 470             // There should be an IPv4 etherType set
 471             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 472             assertNotNull(ethMatch);
 473             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 474
 475             // Make sure its UDP
 476             IpMatch ipMatch = matchBuilder.getIpMatch();
 477             assertNotNull(ipMatch);
 478             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.UDP.shortValue()));
 479
 480             NxmOfUdpSrc udpSrc = matchBuilder
 481                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 482                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfUdpSrc();
 483
 484             if (udpSrc != null) {
 485                 srcUdpMatches.add(udpSrc.getPort().getValue().toJava());
 486                 srcUdpMatches.add(udpSrc.getMask().toJava());
 487             }
 488
 489             // The layer3 match should be null
 490             assertNull(matchBuilder.getLayer3Match());
 491         }
 492         assertEquals(1, matchBuilds.size());
 493         assertEquals(2, srcUdpMatches.size());
 494         assertTrue(srcUdpMatches.contains(UDP_SRC_LOWER_PORT));
 495         assertTrue(srcUdpMatches.contains(UDP_SRC_UPPER_PORT));
 496         assertTrue(srcUdpMatches.contains(65535));
 497     }
 498
 499     @Test
 500     public void buildIpv4DstLwrUdpMatchTest() {
 501         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 502         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 503         aceIpBuilder.setProtocol(IPProtocols.UDP.shortValue());
 504
 505         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 506         dstPortRange.setLowerPort(new PortNumber(UDP_DST_LOWER_PORT));
 507         aceIpBuilder.setDestinationPortRange(dstPortRange.build());
 508
 509         MatchesBuilder matchesBuilder = new MatchesBuilder();
 510         matchesBuilder.setAceType(aceIpBuilder.build());
 511
 512         // Create the aclMatches that is the object to be tested
 513         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 514         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 515
 516         Set<Integer> dstUdpMatches = new HashSet<>();
 517
 518         for (MatchBuilder matchBuilder : matchBuilds) {
 519             // There should be an IPv4 etherType set
 520             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 521             assertNotNull(ethMatch);
 522             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 523
 524             // Make sure its UDP
 525             IpMatch ipMatch = matchBuilder.getIpMatch();
 526             assertNotNull(ipMatch);
 527             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.UDP.shortValue()));
 528
 529             NxmOfUdpDst udpDst = matchBuilder
 530                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 531                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfUdpDst();
 532
 533             if (udpDst != null) {
 534                 dstUdpMatches.add(udpDst.getPort().getValue().toJava());
 535                 dstUdpMatches.add(udpDst.getMask().toJava());
 536             }
 537
 538             // The layer3 match should be null
 539             assertNull(matchBuilder.getLayer3Match());
 540         }
 541         assertEquals(1, matchBuilds.size());
 542         assertEquals(2, dstUdpMatches.size());
 543         assertTrue(dstUdpMatches.contains(UDP_DST_LOWER_PORT));
 544         assertTrue(dstUdpMatches.contains(65535));
 545     }
 546
 547     @Test
 548     public void buildIpv4DstUdpMatchTest() {
 549         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 550         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 551         aceIpBuilder.setProtocol(IPProtocols.UDP.shortValue());
 552
 553         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 554         dstPortRange.setLowerPort(new PortNumber(UDP_DST_LOWER_PORT));
 555         dstPortRange.setUpperPort(new PortNumber(UDP_DST_UPPER_PORT));
 556         aceIpBuilder.setDestinationPortRange(dstPortRange.build());
 557
 558         MatchesBuilder matchesBuilder = new MatchesBuilder();
 559         matchesBuilder.setAceType(aceIpBuilder.build());
 560
 561         // Create the aclMatches that is the object to be tested
 562         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 563         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 564
 565         Set<Integer> dstUdpMatches = new HashSet<>();
 566
 567         for (MatchBuilder matchBuilder : matchBuilds) {
 568             // There should be an IPv4 etherType set
 569             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 570             assertNotNull(ethMatch);
 571             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 572
 573             // Make sure its UDP
 574             IpMatch ipMatch = matchBuilder.getIpMatch();
 575             assertNotNull(ipMatch);
 576             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.UDP.shortValue()));
 577
 578             NxmOfUdpDst udpDst = matchBuilder
 579                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 580                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfUdpDst();
 581
 582             if (udpDst != null) {
 583                 dstUdpMatches.add(udpDst.getPort().getValue().toJava());
 584                 dstUdpMatches.add(udpDst.getMask().toJava());
 585             }
 586
 587             // The layer3 match should be null
 588             assertNull(matchBuilder.getLayer3Match());
 589         }
 590         assertEquals(2, matchBuilds.size());
 591         assertEquals(4, dstUdpMatches.size());
 592         assertTrue(dstUdpMatches.contains(UDP_DST_LOWER_PORT));
 593         assertTrue(dstUdpMatches.contains(UDP_DST_UPPER_PORT));
 594         assertTrue(dstUdpMatches.contains(65534));
 595         assertTrue(dstUdpMatches.contains(65535));
 596     }
 597
 598     @Test
 599     public void buildIpv4UdpMatchTest() {
 600         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 601         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 602         aceIpBuilder.setProtocol(IPProtocols.UDP.shortValue());
 603
 604         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 605         srcPortRange.setLowerPort(new PortNumber(UDP_SRC_LOWER_PORT));
 606         srcPortRange.setUpperPort(new PortNumber(UDP_SRC_UPPER_PORT));
 607         aceIpBuilder.setSourcePortRange(srcPortRange.build());
 608
 609         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 610         dstPortRange.setLowerPort(new PortNumber(UDP_DST_LOWER_PORT));
 611         dstPortRange.setUpperPort(new PortNumber(UDP_DST_UPPER_PORT));
 612         aceIpBuilder.setDestinationPortRange(dstPortRange.build());
 613
 614         MatchesBuilder matchesBuilder = new MatchesBuilder();
 615         matchesBuilder.setAceType(aceIpBuilder.build());
 616
 617         // Create the aclMatches that is the object to be tested
 618         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 619         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 620
 621         Set<Integer> srcUdpMatches = new HashSet<>();
 622         Set<Integer> dstUdpMatches = new HashSet<>();
 623
 624         for (MatchBuilder matchBuilder : matchBuilds) {
 625             // There should be an IPv4 etherType set
 626             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 627             assertNotNull(ethMatch);
 628             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 629
 630             // Make sure its UDP
 631             IpMatch ipMatch = matchBuilder.getIpMatch();
 632             assertNotNull(ipMatch);
 633             assertEquals(ipMatch.getIpProtocol(), Uint8.valueOf(IPProtocols.UDP.shortValue()));
 634
 635             NxmOfUdpSrc udpSrc = matchBuilder
 636                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(0)
 637                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfUdpSrc();
 638
 639             NxmOfUdpDst udpDst = matchBuilder
 640                     .augmentation(GeneralAugMatchNodesNodeTableFlow.class).getExtensionList().get(1)
 641                     .getExtension().augmentation(NxAugMatchNodesNodeTableFlow.class).getNxmOfUdpDst();
 642
 643             if (udpSrc != null) {
 644                 srcUdpMatches.add(udpSrc.getPort().getValue().toJava());
 645                 srcUdpMatches.add(udpSrc.getMask().toJava());
 646             }
 647
 648             if (udpDst != null) {
 649                 dstUdpMatches.add(udpDst.getPort().getValue().toJava());
 650                 dstUdpMatches.add(udpDst.getMask().toJava());
 651             }
 652
 653             // The layer3 match should be null
 654             assertNull(matchBuilder.getLayer3Match());
 655         }
 656         assertEquals(2, matchBuilds.size());
 657         assertEquals(2, srcUdpMatches.size());
 658         assertEquals(4, dstUdpMatches.size());
 659
 660         assertTrue(srcUdpMatches.contains(UDP_SRC_LOWER_PORT));
 661         assertTrue(srcUdpMatches.contains(UDP_SRC_UPPER_PORT));
 662         assertTrue(srcUdpMatches.contains(65535));
 663
 664         assertTrue(dstUdpMatches.contains(UDP_DST_LOWER_PORT));
 665         assertTrue(dstUdpMatches.contains(UDP_DST_UPPER_PORT));
 666         assertTrue(dstUdpMatches.contains(65534));
 667         assertTrue(dstUdpMatches.contains(65535));
 668     }
 669
 670     @Test
 671     public void buildIpv4DscpMatchTest() {
 672         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 673         aceIpBuilder.setAceIpVersion(new AceIpv4Builder().build());
 674         aceIpBuilder.setDscp(new Dscp(DSCP_VALUE));
 675
 676         MatchesBuilder matchesBuilder = new MatchesBuilder();
 677         matchesBuilder.setAceType(aceIpBuilder.build());
 678
 679         // Create the aclMatches that is the object to be tested
 680         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 681         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 682
 683         for (MatchBuilder matchBuilder : matchBuilds) {
 684             // There should be an IPv4 etherType set
 685             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 686             assertNotNull(ethMatch);
 687             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV4));
 688
 689             // Check the DSCP value
 690             IpMatch ipMatch = matchBuilder.getIpMatch();
 691             assertNotNull(ipMatch);
 692             assertEquals(ipMatch.getIpDscp().getValue(), Uint8.valueOf(DSCP_VALUE));
 693
 694             // The rest should be null
 695             assertNull(matchBuilder.getLayer3Match());
 696             assertNull(matchBuilder.getLayer4Match());
 697         }
 698     }
 699
 700     @Test
 701     public void buildIpv6MatchTest() {
 702         AceIpv6Builder aceIpv6 = new AceIpv6Builder();
 703         aceIpv6.setDestinationIpv6Network(new Ipv6Prefix(IPV6_DST_STR));
 704         aceIpv6.setSourceIpv6Network(new Ipv6Prefix(IPV6_SRC_STR));
 705
 706         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 707         aceIpBuilder.setAceIpVersion(aceIpv6.build());
 708
 709         MatchesBuilder matchesBuilder = new MatchesBuilder();
 710         matchesBuilder.setAceType(aceIpBuilder.build());
 711
 712         // Create the aclMatches that is the object to be tested
 713         AclMatches aclMatches = new AclMatches(matchesBuilder.build());
 714         List<MatchBuilder> matchBuilds = aclMatches.buildMatch();
 715
 716         for (MatchBuilder matchBuilder : matchBuilds) {
 717             // The layer3 match should be there with src/dst values
 718             Ipv6Match l3 = (Ipv6Match) matchBuilder.getLayer3Match();
 719             assertNotNull(l3);
 720             assertEquals(l3.getIpv6Destination().getValue().toString(), IPV6_DST_STR);
 721             assertEquals(l3.getIpv6Source().getValue().toString(), IPV6_SRC_STR);
 722
 723             // There should be an IPv6 etherType set
 724             EthernetMatch ethMatch = matchBuilder.getEthernetMatch();
 725             assertNotNull(ethMatch);
 726             assertEquals(ethMatch.getEthernetType().getType().getValue(), Uint32.valueOf(NwConstants.ETHTYPE_IPV6));
 727
 728             // The rest should be null
 729             assertNull(matchBuilder.getIpMatch());
 730             assertNull(matchBuilder.getLayer4Match());
 731         }
 732     }
 733
 734     @Test
 735     public void invertEthMatchTest() {
 736         AceEthBuilder aceEthBuilder = new AceEthBuilder();
 737         aceEthBuilder.setDestinationMacAddress(new MacAddress(MAC_DST_STR));
 738         aceEthBuilder.setSourceMacAddress(new MacAddress(MAC_SRC_STR));
 739         AceEth aceEth = aceEthBuilder.build();
 740
 741         MatchesBuilder matchesBuilder = new MatchesBuilder();
 742         matchesBuilder.setAceType(aceEth);
 743         Matches matches = matchesBuilder.build();
 744
 745         Matches invertedMatches = AclMatches.invertMatches(matches);
 746
 747         assertNotEquals(matches, invertedMatches);
 748
 749         AceEth invertedAceEth = (AceEth) invertedMatches.getAceType();
 750         assertEquals(invertedAceEth.getDestinationMacAddress(), aceEth.getSourceMacAddress());
 751         assertEquals(invertedAceEth.getSourceMacAddress(), aceEth.getDestinationMacAddress());
 752     }
 753
 754     @Test
 755     public void invertIpv4MatchTest() {
 756         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 757         aceIpBuilder.setProtocol(IPProtocols.UDP.shortValue());
 758         aceIpBuilder.setDscp(new Dscp(DSCP_VALUE));
 759
 760         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 761         dstPortRange.setLowerPort(new PortNumber(UDP_DST_LOWER_PORT));
 762         dstPortRange.setUpperPort(new PortNumber(UDP_DST_UPPER_PORT));
 763         DestinationPortRange destinationPortRange = dstPortRange.build();
 764         aceIpBuilder.setDestinationPortRange(destinationPortRange);
 765
 766         AceIpv4Builder aceIpv4Builder = new AceIpv4Builder();
 767         aceIpv4Builder.setDestinationIpv4Network(new Ipv4Prefix(IPV4_DST_STR));
 768         aceIpv4Builder.setSourceIpv4Network(new Ipv4Prefix(IPV4_SRC_STR));
 769         AceIpv4 aceIpv4 = aceIpv4Builder.build();
 770         aceIpBuilder.setAceIpVersion(aceIpv4);
 771
 772         MatchesBuilder matchesBuilder = new MatchesBuilder();
 773         AceIp aceIp = aceIpBuilder.build();
 774         matchesBuilder.setAceType(aceIp);
 775
 776         Matches matches = matchesBuilder.build();
 777
 778         Matches invertedMatches = AclMatches.invertMatches(matches);
 779
 780         assertNotEquals(matches, invertedMatches);
 781
 782         AceIp invertedAceIp = (AceIp) invertedMatches.getAceType();
 783         assertEquals(invertedAceIp.getDscp(), aceIp.getDscp());
 784         assertEquals(invertedAceIp.getProtocol(), aceIp.getProtocol());
 785
 786         DestinationPortRange invertedDestinationPortRange = invertedAceIp.getDestinationPortRange();
 787         assertNull(invertedDestinationPortRange);
 788
 789         SourcePortRange invertedSourcePortRange = invertedAceIp.getSourcePortRange();
 790         assertEquals(invertedSourcePortRange.getLowerPort(), destinationPortRange.getLowerPort());
 791         assertEquals(invertedSourcePortRange.getUpperPort(), destinationPortRange.getUpperPort());
 792
 793         AceIpv4 invertedAceIpv4 = (AceIpv4) invertedAceIp.getAceIpVersion();
 794         assertEquals(invertedAceIpv4.getDestinationIpv4Network(), aceIpv4.getSourceIpv4Network());
 795         assertEquals(invertedAceIpv4.getSourceIpv4Network(), aceIpv4.getDestinationIpv4Network());
 796     }
 797
 798     @Test
 799     public void invertIpv6MatchTest() {
 800         AceIpBuilder aceIpBuilder = new AceIpBuilder();
 801         aceIpBuilder.setProtocol(IPProtocols.TCP.shortValue());
 802         aceIpBuilder.setDscp(new Dscp(DSCP_VALUE));
 803
 804         SourcePortRangeBuilder srcPortRange = new SourcePortRangeBuilder();
 805         srcPortRange.setLowerPort(new PortNumber(TCP_SRC_LOWER_PORT));
 806         srcPortRange.setUpperPort(new PortNumber(TCP_SRC_UPPER_PORT));
 807         SourcePortRange sourcePortRange = srcPortRange.build();
 808         aceIpBuilder.setSourcePortRange(sourcePortRange);
 809
 810         DestinationPortRangeBuilder dstPortRange = new DestinationPortRangeBuilder();
 811         dstPortRange.setLowerPort(new PortNumber(TCP_DST_LOWER_PORT));
 812         dstPortRange.setUpperPort(new PortNumber(TCP_DST_UPPER_PORT));
 813         DestinationPortRange destinationPortRange = dstPortRange.build();
 814         aceIpBuilder.setDestinationPortRange(destinationPortRange);
 815
 816         AceIpv6Builder aceIpv6Builder = new AceIpv6Builder();
 817         aceIpv6Builder.setDestinationIpv6Network(new Ipv6Prefix(IPV6_DST_STR));
 818         aceIpv6Builder.setSourceIpv6Network(new Ipv6Prefix(IPV6_SRC_STR));
 819         AceIpv6 aceIpv6 = aceIpv6Builder.build();
 820         aceIpBuilder.setAceIpVersion(aceIpv6);
 821
 822         MatchesBuilder matchesBuilder = new MatchesBuilder();
 823         AceIp aceIp = aceIpBuilder.build();
 824         matchesBuilder.setAceType(aceIp);
 825
 826         Matches matches = matchesBuilder.build();
 827
 828         Matches invertedMatches = AclMatches.invertMatches(matches);
 829
 830         assertNotEquals(matches, invertedMatches);
 831
 832         AceIp invertedAceIp = (AceIp) invertedMatches.getAceType();
 833         assertEquals(invertedAceIp.getDscp(), aceIp.getDscp());
 834         assertEquals(invertedAceIp.getProtocol(), aceIp.getProtocol());
 835
 836         DestinationPortRange invertedDestinationPortRange = invertedAceIp.getDestinationPortRange();
 837         assertEquals(invertedDestinationPortRange.getLowerPort(), sourcePortRange.getLowerPort());
 838         assertEquals(invertedDestinationPortRange.getUpperPort(), sourcePortRange.getUpperPort());
 839
 840         SourcePortRange invertedSourcePortRange = invertedAceIp.getSourcePortRange();
 841         assertEquals(invertedSourcePortRange.getLowerPort(), destinationPortRange.getLowerPort());
 842         assertEquals(invertedSourcePortRange.getUpperPort(), destinationPortRange.getUpperPort());
 843
 844         AceIpv6 invertedAceIpv6 = (AceIpv6) invertedAceIp.getAceIpVersion();
 845         assertEquals(invertedAceIpv6.getDestinationIpv6Network(), aceIpv6.getSourceIpv6Network());
 846         assertEquals(invertedAceIpv6.getSourceIpv6Network(), aceIpv6.getDestinationIpv6Network());
 847     }
 848
 849     @Test
 850     public void testgetLayer4MaskForRange_SinglePort() {
 851         Map<Integer, Integer> layer4MaskForRange = AclMatches.getLayer4MaskForRange(1111, 1111);
 852         assertEquals("port L4 mask missing", 1, layer4MaskForRange.size());
 853     }
 854
 855     @Test
 856     public void testgetLayer4MaskForRange_MultiplePorts() {
 857         Map<Integer, Integer> layer4MaskForRange = AclMatches.getLayer4MaskForRange(1024, 2048);
 858         assertEquals("port L4 mask missing", 2, layer4MaskForRange.size());
 859     }
 860
 861     @Test
 862     public void testgetLayer4MaskForRange_IllegalPortRange_ExceedMin() {
 863         Map<Integer, Integer> layer4MaskForRange = AclMatches.getLayer4MaskForRange(0, 1);
 864
 865         assertEquals("port L4 mask missing", 1, layer4MaskForRange.size());
 866     }
 867
 868     @Test
 869     public void testgetLayer4MaskForRange_IllegalPortRange_ExceedMax() {
 870         Map<Integer, Integer> layer4MaskForRange = AclMatches.getLayer4MaskForRange(1, 65536);
 871         assertEquals("Illegal ports range", 0, layer4MaskForRange.size());
 872     }
 873
 874     @Test
 875     public void testgetLayer4MaskForRange_IllegalPortRange_MinGreaterThanMax() {
 876         Map<Integer, Integer> layer4MaskForRange = AclMatches.getLayer4MaskForRange(8192, 4096);
 877         assertEquals("Illegal ports range", 0, layer4MaskForRange.size());
 878     }
 879 }