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

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