applications/statistics-manager/src/test/java/org/opendaylight/openflowplugin/applications/statistics/manager/impl/helper/MatchComparatorHelperTest.java

   1 /*
   2  * Copyright (c) 2014, 2016 Cisco Systems, 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 package org.opendaylight.openflowplugin.applications.statistics.manager.impl.helper;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12 import static org.junit.Assert.fail;
  13
  14 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  15 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.ArpMatchBuilder;
  18
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchArbitraryBitMaskBuilder;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv4MatchBuilder;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetTypeBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetDestinationBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.ethernet.match.fields.EthernetSourceBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.EthernetMatchBuilder;
  28 import org.junit.Test;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._3.match.Ipv6MatchBuilder;
  30
  31 /**
  32  * @author sai.marapareddy@gmail.com (arbitrary masks)
  33  */
  34
  35 /**
  36  * test of {@link MatchComparatorHelper}
  37  */
  38 public class MatchComparatorHelperTest {
  39
  40     /**
  41      * mask for /32
  42      */
  43     private static final int DEFAULT_IPV4_MASK = 0xffffffff;
  44
  45     /**
  46      * mask for /30
  47      */
  48     private static final int IPV4_30_MASK = 0xfffffffc;
  49     private static final int IP_ADDRESS = 0xC0A80101;
  50
  51     /**
  52      * The test of conversion valid IP addres without mask to binary form.
  53      */
  54     @Test
  55     public void validIpWithoutMaskTest() {
  56         IntegerIpAddress intIp = MatchComparatorHelper.strIpToIntIp("192.168.1.1");
  57         assertEquals(IP_ADDRESS, intIp.getIp());
  58         assertEquals(DEFAULT_IPV4_MASK, intIp.getMask());
  59     }
  60
  61     /**
  62      * The test of conversion of valid IP address with valid mask to binary form.
  63      */
  64     @Test
  65     public void validIpWithValidMaskTest() {
  66         IntegerIpAddress intIp = MatchComparatorHelper.strIpToIntIp("192.168.1.1/30");
  67         assertEquals(IP_ADDRESS, intIp.getIp());
  68         assertEquals(IPV4_30_MASK, intIp.getMask());
  69     }
  70
  71     /**
  72      * The test of conversion of valid IP address invalid mask to binary form.
  73      */
  74     @Test
  75     public void validIpWithInvalidMaskTest() {
  76         try {
  77             MatchComparatorHelper.strIpToIntIp("192.168.1.1/40");
  78         } catch (IllegalStateException e) {
  79             assertEquals("Valid values for mask are from range 0 - 32. Value 40 is invalid.", e.getMessage());
  80             return;
  81         }
  82         fail("IllegalStateException was awaited (40 subnet is invalid)");
  83     }
  84
  85     /**
  86      * The test of conversion invalid IP address with valid mask to binary form.
  87      */
  88     @Test
  89     public void invalidIpWithValidMaskTest() {
  90         try {
  91             MatchComparatorHelper.strIpToIntIp("257.168.1.1/25");
  92         } catch (IllegalArgumentException e) {
  93             assertEquals("'257.168.1.1' is not an IP string literal.", e.getMessage());
  94         }
  95     }
  96
  97     @Test
  98     public void ethernetMatchEqualsTest() {
  99         final EthernetMatchBuilder statsEthernetBuilder = new EthernetMatchBuilder();
 100         final EthernetMatchBuilder storedEthernetBuilder = new EthernetMatchBuilder();
 101
 102         assertEquals(true, MatchComparatorHelper.ethernetMatchEquals(null, null));
 103
 104         statsEthernetBuilder.setEthernetSource(new EthernetSourceBuilder().setAddress(
 105                 new MacAddress("11:22:33:44:55:66")).build());
 106         storedEthernetBuilder.setEthernetSource(new EthernetSourceBuilder().setAddress(
 107                 new MacAddress("11:22:33:44:55:77")).build());
 108         assertEquals(false,
 109                 MatchComparatorHelper.ethernetMatchEquals(statsEthernetBuilder.build(), storedEthernetBuilder.build()));
 110
 111         storedEthernetBuilder.setEthernetSource(new EthernetSourceBuilder().setAddress(
 112                 new MacAddress("11:22:33:44:55:66")).build());
 113         statsEthernetBuilder.setEthernetDestination(new EthernetDestinationBuilder().setAddress(
 114                 new MacAddress("66:55:44:33:22:11")).build());
 115         storedEthernetBuilder.setEthernetDestination(new EthernetDestinationBuilder().setAddress(
 116                 new MacAddress("77:55:44:33:22:11")).build());
 117         assertEquals(false,
 118                 MatchComparatorHelper.ethernetMatchEquals(statsEthernetBuilder.build(), storedEthernetBuilder.build()));
 119
 120         storedEthernetBuilder.setEthernetDestination(new EthernetDestinationBuilder().setAddress(
 121                 new MacAddress("66:55:44:33:22:11")).build());
 122         statsEthernetBuilder.setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long) 1)).build());
 123         storedEthernetBuilder.setEthernetType(new EthernetTypeBuilder().setType(new EtherType((long) 1)).build());
 124         assertEquals(true,
 125                 MatchComparatorHelper.ethernetMatchEquals(statsEthernetBuilder.build(), storedEthernetBuilder.build()));
 126
 127         statsEthernetBuilder.setEthernetType(null).build();
 128         assertEquals(false,
 129                 MatchComparatorHelper.ethernetMatchEquals(statsEthernetBuilder.build(), storedEthernetBuilder.build()));
 130
 131         storedEthernetBuilder.setEthernetType(null).build();
 132         assertEquals(true,
 133                 MatchComparatorHelper.ethernetMatchEquals(statsEthernetBuilder.build(), storedEthernetBuilder.build()));
 134
 135     }
 136
 137     @Test
 138     public void ethernetMatchFieldsEqualsTest() {
 139         final EthernetSourceBuilder statsBuilder = new EthernetSourceBuilder();
 140         final EthernetSourceBuilder storedBuilder = new EthernetSourceBuilder();
 141
 142         assertEquals(true, MatchComparatorHelper.ethernetMatchFieldsEquals(null, null));
 143
 144         statsBuilder.setAddress(new MacAddress("11:22:33:44:55:66"));
 145         storedBuilder.setAddress(new MacAddress("11:22:33:44:55:77"));
 146         assertEquals(false,
 147                 MatchComparatorHelper.ethernetMatchFieldsEquals(statsBuilder.build(), storedBuilder.build()));
 148
 149         storedBuilder.setAddress(new MacAddress("11:22:33:44:55:66"));
 150         assertEquals(true, MatchComparatorHelper.ethernetMatchFieldsEquals(statsBuilder.build(), storedBuilder.build()));
 151     }
 152
 153     @Test
 154     public void macAddressEqualsTest() {
 155         assertEquals(true, MatchComparatorHelper.macAddressEquals(null, null));
 156         assertEquals(true, MatchComparatorHelper.macAddressEquals(new MacAddress("11:22:33:44:55:66"), new MacAddress(
 157                 "11:22:33:44:55:66")));
 158         assertEquals(false, MatchComparatorHelper.macAddressEquals(new MacAddress("11:22:33:44:55:66"), new MacAddress(
 159                 "11:22:33:44:55:77")));
 160     }
 161
 162     @Test
 163     public void checkNullValuesTest() {
 164         assertEquals(false, MatchComparatorHelper.checkNullValues(null, ""));
 165         assertEquals(false, MatchComparatorHelper.checkNullValues("", null));
 166         assertEquals(true, MatchComparatorHelper.checkNullValues(null, null));
 167         assertTrue(MatchComparatorHelper.checkNullValues("", "") == null);
 168     }
 169
 170     @Test
 171     public void compareIpv4PrefixNullSafeTest() {
 172         assertEquals(true, MatchComparatorHelper.compareIpv4PrefixNullSafe(null, null));
 173         assertEquals(true, MatchComparatorHelper.compareIpv4PrefixNullSafe(new Ipv4Prefix("192.168.1.1/31"),
 174                 new Ipv4Prefix("192.168.1.1/31")));
 175
 176         assertEquals(false, MatchComparatorHelper.compareIpv4PrefixNullSafe(new Ipv4Prefix("192.168.1.1/31"),
 177                 new Ipv4Prefix("191.168.1.1/31")));
 178     }
 179
 180     @Test
 181     public void compareStringNullSafeTest() {
 182         assertEquals(true, MatchComparatorHelper.compareStringNullSafe(null,null));
 183         assertEquals(true, MatchComparatorHelper.compareStringNullSafe("Hello", "Hello"));
 184         assertEquals(false, MatchComparatorHelper.compareStringNullSafe("Hello", "hello"));
 185     }
 186
 187     private static final int ip_192_168_1_1 = 0xC0A80101;
 188     private static final int ip_192_168_1_4 = 0xC0A80104;
 189
 190     @Test
 191     public void ipBasedMatchTest() {
 192         // are equals because only IP address is compared
 193         assertEquals(true, MatchComparatorHelper.ipBasedMatch(new IntegerIpAddress(ip_192_168_1_1, 32),
 194                 new IntegerIpAddress(ip_192_168_1_1, 16)));
 195     }
 196
 197     @Test
 198     public void ipAndMaskBasedMatchTest() {
 199         // true because both cases are network 192.168.1.0
 200         assertEquals(true, MatchComparatorHelper.ipBasedMatch(new IntegerIpAddress(ip_192_168_1_1, 31),
 201                 new IntegerIpAddress(ip_192_168_1_1, 30)));
 202
 203         // false because first is network 192.168.1.0 and second is 192.168.1.4
 204         assertEquals(false, MatchComparatorHelper.ipBasedMatch(new IntegerIpAddress(ip_192_168_1_1, 31),
 205                 new IntegerIpAddress(ip_192_168_1_4, 30)));
 206     }
 207
 208     @Test
 209     public void layer3MatchEqualsTest() {
 210         final Ipv4MatchBuilder statsBuilder = new Ipv4MatchBuilder();
 211         final Ipv4MatchBuilder storedBuilder = new Ipv4MatchBuilder();
 212         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 213         statsBuilder.setIpv4Destination(new Ipv4Prefix("192.168.1.1/30"));
 214         storedBuilder.setIpv4Destination(new Ipv4Prefix("191.168.1.1/30"));
 215         assertEquals(false, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 216         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(null, null));
 217         assertEquals(true,
 218                 MatchComparatorHelper.layer3MatchEquals(new ArpMatchBuilder().build(), new ArpMatchBuilder().build()));
 219     }
 220
 221     @Test
 222     public void layer3MatchEqualsIpv6Test() {
 223         final Ipv6MatchBuilder statsBuilder = new Ipv6MatchBuilder();
 224         final Ipv6MatchBuilder storedBuilder = new Ipv6MatchBuilder();
 225         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 226
 227         statsBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000D:0000:0000:0000:5D99/64"));
 228         storedBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000D:0000:0000:0000:4D99/64"));
 229         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 230
 231         statsBuilder.setIpv6Destination(new Ipv6Prefix("aabb:1234:2acf:000d:0000:0000:0000:5d99/64"));
 232         storedBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000D:0000:0000:0000:4D99/64"));
 233         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 234
 235         statsBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000C:0000:0000:0000:5D99/64"));
 236         storedBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000D:0000:0000:0000:4D99/64"));
 237         assertEquals(false, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 238
 239         statsBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000C:0000:0000:0000:5D99/63"));
 240         storedBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000D:0000:0000:0000:4D99/63"));
 241         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 242
 243         statsBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000D:0000:0000:0000:5D99/63"));
 244         storedBuilder.setIpv6Destination(new Ipv6Prefix("AABB:1234:2ACF:000E:0000:0000:0000:4D99/63"));
 245         assertEquals(false, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 246     }
 247
 248     @Test
 249     public void layer3MatchEqualsIpv4ArbitraryMaskTest(){
 250         final Ipv4MatchBuilder statsBuilder = new Ipv4MatchBuilder();
 251         final Ipv4MatchArbitraryBitMaskBuilder storedBuilder = new Ipv4MatchArbitraryBitMaskBuilder();
 252         assertEquals(true,MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(),storedBuilder.build()));
 253         statsBuilder.setIpv4Destination(new Ipv4Prefix("192.168.1.1/24"));
 254         storedBuilder.setIpv4DestinationAddressNoMask(new Ipv4Address("192.168.1.1"));
 255         storedBuilder.setIpv4DestinationArbitraryBitmask(new DottedQuad("255.255.255.0"));
 256         statsBuilder.setIpv4Source(new Ipv4Prefix("192.168.1.1/24"));
 257         storedBuilder.setIpv4SourceAddressNoMask(new Ipv4Address("192.168.1.1"));
 258         storedBuilder.setIpv4SourceArbitraryBitmask(new DottedQuad("255.255.255.0"));
 259         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 260         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(null, null));
 261
 262     }
 263
 264     @Test
 265     public void layer3MatchEqualsIpv4ArbitraryMaskRandomTest() {
 266         final Ipv4MatchArbitraryBitMaskBuilder statsBuilder = new Ipv4MatchArbitraryBitMaskBuilder();
 267         final Ipv4MatchArbitraryBitMaskBuilder storedBuilder = new Ipv4MatchArbitraryBitMaskBuilder();
 268         assertEquals(true,MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(),storedBuilder.build()));
 269         statsBuilder.setIpv4DestinationAddressNoMask(new Ipv4Address("192.168.0.1"));
 270         statsBuilder.setIpv4DestinationArbitraryBitmask(new DottedQuad("255.255.0.255"));
 271         storedBuilder.setIpv4DestinationAddressNoMask(new Ipv4Address("192.168.1.1"));
 272         storedBuilder.setIpv4DestinationArbitraryBitmask(new DottedQuad("255.255.0.255"));
 273         statsBuilder.setIpv4SourceAddressNoMask(new Ipv4Address("192.0.0.1"));
 274         statsBuilder.setIpv4SourceArbitraryBitmask(new DottedQuad("255.0.0.255"));
 275         storedBuilder.setIpv4SourceAddressNoMask(new Ipv4Address("192.7.1.1"));
 276         storedBuilder.setIpv4SourceArbitraryBitmask(new DottedQuad("255.0.0.255"));
 277         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 278         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(null, null));
 279     }
 280
 281     @Test
 282     public void layer3MatchEqualsIpv4ArbitraryMaskEqualsNullTest() {
 283         final Ipv4MatchBuilder statsBuilder = new Ipv4MatchBuilder();
 284         final Ipv4MatchArbitraryBitMaskBuilder storedBuilder = new Ipv4MatchArbitraryBitMaskBuilder();
 285         assertEquals(true,MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(),storedBuilder.build()));
 286         statsBuilder.setIpv4Source(new Ipv4Prefix("192.168.0.1/32"));
 287         storedBuilder.setIpv4DestinationAddressNoMask(new Ipv4Address("192.168.0.1"));
 288         statsBuilder.setIpv4Destination(new Ipv4Prefix("192.1.0.0/32"));
 289         storedBuilder.setIpv4SourceAddressNoMask(new Ipv4Address("192.1.0.0"));
 290         assertEquals(false, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 291         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(null, null));
 292     }
 293
 294     @Test
 295     public void layer3MatchEqualsIpv4ArbitraryEmptyBitMaskTest(){
 296         final Ipv4MatchBuilder statsBuilder = new Ipv4MatchBuilder();
 297         final Ipv4MatchArbitraryBitMaskBuilder storedBuilder = new Ipv4MatchArbitraryBitMaskBuilder();
 298         assertEquals(true,MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(),storedBuilder.build()));
 299         statsBuilder.setIpv4Destination(new Ipv4Prefix("192.168.1.1/32"));
 300         storedBuilder.setIpv4DestinationAddressNoMask(new Ipv4Address("192.168.1.1"));
 301         statsBuilder.setIpv4Source(new Ipv4Prefix("192.168.1.1/32"));
 302         storedBuilder.setIpv4SourceAddressNoMask(new Ipv4Address("192.168.1.1"));
 303         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(statsBuilder.build(), storedBuilder.build()));
 304         assertEquals(true, MatchComparatorHelper.layer3MatchEquals(null, null));
 305     }
 306
 307     @Test
 308     public void extractIpv4AddressTest() {
 309         Ipv4Address ipAddress = new Ipv4Address("1.1.1.1");
 310         DottedQuad netMask = new DottedQuad("255.255.255.0");
 311         String extractedIpAddress;
 312         extractedIpAddress = MatchComparatorHelper.normalizeIpv4Address(ipAddress,netMask);
 313         assertEquals(extractedIpAddress,"1.1.1.0");
 314     }
 315
 316     @Test
 317     public void convertArbitraryMaskToByteArrayTest() {
 318         int value = 0xffffffff;
 319         byte[] bytes = new byte[]{
 320                 (byte)(value >>> 24), (byte)(value >> 16 & 0xff), (byte)(value >> 8 & 0xff), (byte)(value & 0xff) };
 321         byte[] maskBytes;
 322         maskBytes = MatchComparatorHelper.convertArbitraryMaskToByteArray(new DottedQuad("255.255.255.255"));
 323         for (int i=0; i<bytes.length;i++) {
 324             int mask = maskBytes[i];
 325             assertEquals(bytes[i],mask);
 326         }
 327     }
 328
 329     @Test
 330     public void isArbitraryBitMaskTest() {
 331         boolean arbitraryBitMask;
 332         arbitraryBitMask = MatchComparatorHelper.isArbitraryBitMask(new byte[] {1,1,1,1});
 333         assertEquals(arbitraryBitMask,true);
 334         arbitraryBitMask = MatchComparatorHelper.isArbitraryBitMask(new byte[] {-1,-1,-1,-1});
 335         assertEquals(arbitraryBitMask,false);
 336         arbitraryBitMask = MatchComparatorHelper.isArbitraryBitMask(new byte[] {-1,-1,0,-1});
 337         assertEquals(arbitraryBitMask,true);
 338         arbitraryBitMask = MatchComparatorHelper.isArbitraryBitMask(null);
 339         assertEquals(arbitraryBitMask,false);
 340     }
 341
 342     @Test
 343     public void createPrefixTest() {
 344         Ipv4Address ipv4Address = new Ipv4Address("1.1.1.1");
 345         byte [] byteMask = new byte[] {-1,-1,-1,-1};
 346         Ipv4Prefix ipv4Prefix = MatchComparatorHelper.createPrefix(ipv4Address,byteMask);
 347         assertEquals(ipv4Prefix,new Ipv4Prefix("1.1.1.1/32"));
 348         String nullMask = "";
 349         Ipv4Prefix ipv4PrefixNullMask = MatchComparatorHelper.createPrefix(ipv4Address,nullMask);
 350         assertEquals(ipv4PrefixNullMask,new Ipv4Prefix("1.1.1.1/32"));
 351         Ipv4Prefix ipv4PrefixNoMask = MatchComparatorHelper.createPrefix(ipv4Address);
 352         assertEquals(ipv4PrefixNoMask,new Ipv4Prefix("1.1.1.1/32"));
 353     }
 354 }