packetcable-policy-server/src/test/java/org/opendaylight/controller/packetcable/provider/SubnetTest.java

   1 package org.opendaylight.controller.packetcable.provider;
   2
   3 import com.google.common.net.InetAddresses;
   4 import org.junit.After;
   5 import org.junit.Before;
   6 import org.junit.Test;
   7
   8 import java.net.InetAddress;
   9 import java.net.UnknownHostException;
  10
  11 import static org.hamcrest.CoreMatchers.*;
  12 import static org.junit.Assert.*;
  13
  14 public class SubnetTest {
  15
  16     // Various address class level prefix lengths
  17     private static final int CLASS_A = 8;
  18     private static final int CLASS_B = 16;
  19     private static final int CLASS_C = 24;
  20
  21     private InetAddress addressV4 = null;
  22     private InetAddress addressV6 = null;
  23
  24     private InetAddress v4MaskClassA;
  25     private InetAddress v4MaskClassB;
  26     private InetAddress v4MaskClassC;
  27
  28     @Before
  29     public final void setup()
  30     {
  31         addressV4 = InetAddresses.forString("192.168.0.1");
  32         addressV6 = InetAddresses.forString("2001:db8::1");
  33
  34         v4MaskClassA = InetAddresses.forString("255.0.0.0");
  35         v4MaskClassB = InetAddresses.forString("255.255.0.0");
  36         v4MaskClassC = InetAddresses.forString("255.255.255.0");
  37     }
  38
  39     @After
  40     public final void tearDown()
  41     {
  42         addressV4 = null;
  43         addressV6 = null;
  44
  45         v4MaskClassA = null;
  46         v4MaskClassB = null;
  47         v4MaskClassC = null;
  48     }
  49
  50     @Test
  51     public final void testCtorCidr()
  52     {
  53         assertThat(new Subnet(addressV4, 24), is(notNullValue()));
  54         assertThat(new Subnet(addressV6, 24), is(notNullValue()));
  55     }
  56
  57     @Test
  58     public final void testCtorAddressAndMask()
  59     {
  60         assertThat(new Subnet(addressV4, InetAddresses.forString("255.255.255.0")), is(notNullValue()));
  61         assertThat(new Subnet(addressV4, null), is(notNullValue()));
  62     }
  63
  64     @Test(expected = IllegalArgumentException.class)
  65     public final void testSubnetCtorCidrBadMaskv4_1()
  66     {
  67         new Subnet(addressV4, -1);
  68     }
  69
  70     @Test(expected = IllegalArgumentException.class)
  71     public final void testSubnetCtorCidrBadMaskv4_2()
  72     {
  73         new Subnet(addressV4, 33);
  74     }
  75
  76     @Test(expected = IllegalArgumentException.class)
  77     public final void testSubnetCtorCidrBadMaskv6_1()
  78     {
  79         new Subnet(addressV6, -1);
  80     }
  81
  82     @Test(expected = IllegalArgumentException.class)
  83     public final void testSubnetCtorCidrBadMaskv6_2()
  84     {
  85         new Subnet(addressV6, 129);
  86     }
  87
  88     @Test
  89     public final void testGetPrefixLen()
  90     {
  91         Subnet subnet = new Subnet(addressV4, CLASS_C);
  92         assertThat(subnet, is(notNullValue()) );
  93         assertThat(subnet.getPrefixLen(), is(CLASS_C) );
  94
  95         subnet = new Subnet(addressV4, CLASS_B);
  96         assertThat(subnet, is(notNullValue()) );
  97         assertThat(subnet.getPrefixLen(), is(CLASS_B) );
  98
  99         subnet = new Subnet(addressV4, CLASS_A);
 100         assertThat(subnet, is(notNullValue()) );
 101         assertThat(subnet.getPrefixLen(), is(CLASS_A) );
 102
 103         subnet = new Subnet(addressV4, v4MaskClassC);
 104         assertThat(subnet, is(notNullValue()) );
 105         assertThat(subnet.getPrefixLen(), is(CLASS_C) );
 106
 107         subnet = new Subnet(addressV4, v4MaskClassB);
 108         assertThat(subnet, is(notNullValue()) );
 109         assertThat(subnet.getPrefixLen(), is(CLASS_B) );
 110
 111         subnet = new Subnet(addressV4, v4MaskClassA);
 112         assertThat(subnet, is(notNullValue()) );
 113         assertThat(subnet.getPrefixLen(), is(CLASS_A) );
 114
 115     }
 116
 117     @Test
 118     public final void testSubnetCtorCidrAllValidMasks()
 119     {
 120         // validating no exceptions are thrown for valid masks
 121         for (int iMask = 0; iMask < 33; ++iMask) {
 122             final Subnet subnet = new Subnet(addressV4, iMask);
 123             assertThat(subnet.getPrefixLen(),  is(iMask) );
 124         }
 125
 126         for (int iMask = 0; iMask < 129; ++iMask) {
 127             final Subnet subnet = new Subnet(addressV6, iMask);
 128             assertThat(subnet.getPrefixLen(),  is(iMask) );
 129         }
 130     }
 131
 132
 133     @Test
 134     public final void testEquals()
 135     {
 136         final Subnet s41 = new Subnet(addressV4, 24);
 137         final Subnet s42 = new Subnet(addressV4, 24);
 138         final Subnet s43 = new Subnet(addressV4, 16);
 139
 140         final Subnet s61 = new Subnet(addressV6, 24);
 141         final Subnet s62 = new Subnet(addressV6, 56);
 142         final Subnet s63 = new Subnet(addressV6, 56);
 143
 144         assertThat(s41, is(equalTo(s41)));
 145         assertThat(s41, is(equalTo(s42)));
 146         assertThat(s41, is(not(equalTo(s43))));
 147         assertThat(s41, is(not(equalTo(s61))));
 148         assertThat(s41, is(not(equalTo(s62))));
 149         assertThat(s41, is(not(equalTo(s63))));
 150         assertThat(s41, is(not(equalTo(null))));
 151         assertNotEquals(s41, "random string");
 152
 153         assertThat(s42, is(equalTo(s41)));
 154         assertThat(s42, is(equalTo(s42)));
 155         assertThat(s42, is(not(equalTo(s43))));
 156         assertThat(s42, is(not(equalTo(s61))));
 157         assertThat(s42, is(not(equalTo(s62))));
 158         assertThat(s42, is(not(equalTo(s63))));
 159         assertThat(s42, is(not(equalTo(null))));
 160         assertNotEquals(s42, "random string");
 161
 162         assertThat(s43, is(not(equalTo(s41))));
 163         assertThat(s43, is(not(equalTo(s42))));
 164         assertThat(s43, is(equalTo(s43)));
 165         assertThat(s43, is(not(equalTo(s61))));
 166         assertThat(s43, is(not(equalTo(s62))));
 167         assertThat(s43, is(not(equalTo(s63))));
 168         assertThat(s43, is(not(equalTo(null))));
 169         assertNotEquals(s43, "random string");
 170
 171         assertThat(s61, is(not(equalTo(s41))));
 172         assertThat(s61, is(not(equalTo(s42))));
 173         assertThat(s61, is(not(equalTo(s43))));
 174         assertThat(s61, is(equalTo(s61)));
 175         assertThat(s61, is(not(equalTo(s62))));
 176         assertThat(s61, is(not(equalTo(s63))));
 177         assertThat(s61, is(not(equalTo(null))));
 178         assertNotEquals(s61, "random string");
 179
 180         assertThat(s62, is(not(equalTo(s41))));
 181         assertThat(s62, is(not(equalTo(s42))));
 182         assertThat(s62, is(not(equalTo(s43))));
 183         assertThat(s62, is(not(equalTo(s61))));
 184         assertThat(s62, is(equalTo(s62)));
 185         assertThat(s62, is(equalTo(s63)));
 186         assertThat(s62, is(not(equalTo(null))));
 187         assertNotEquals(s62, "random string");
 188
 189         assertThat(s63, is(not(equalTo(s41))));
 190         assertThat(s63, is(not(equalTo(s42))));
 191         assertThat(s63, is(not(equalTo(s43))));
 192         assertThat(s63, is(not(equalTo(s61))));
 193         assertThat(s63, is(equalTo(s62)));
 194         assertThat(s63, is(equalTo(s63)));
 195         assertThat(s63, is(not(equalTo(null))));
 196         assertNotEquals(s63, "random string");
 197     }
 198
 199     @Test
 200     public final void testHashcode()
 201     {
 202         final Subnet s41 = new Subnet(addressV4, 24);
 203         final Subnet s42 = new Subnet(addressV4, 24);
 204         final Subnet s43 = new Subnet(addressV4, 16);
 205
 206         final Subnet s61 = new Subnet(addressV6, 24);
 207         final Subnet s62 = new Subnet(addressV6, 56);
 208         final Subnet s63 = new Subnet(addressV6, 56);
 209
 210         assertThat(s41.hashCode(), is(equalTo(s41.hashCode())));
 211         assertThat(s41.hashCode(), is(equalTo(s42.hashCode())));
 212         assertThat(s41.hashCode(), is(not(equalTo(s43.hashCode()))));
 213         assertThat(s41.hashCode(), is(not(equalTo(s61.hashCode()))));
 214         assertThat(s41.hashCode(), is(not(equalTo(s62.hashCode()))));
 215         assertThat(s41.hashCode(), is(not(equalTo(s63.hashCode()))));
 216
 217         assertThat(s42.hashCode(), is(equalTo(s41.hashCode())));
 218         assertThat(s42.hashCode(), is(equalTo(s42.hashCode())));
 219         assertThat(s42.hashCode(), is(not(equalTo(s43.hashCode()))));
 220         assertThat(s42.hashCode(), is(not(equalTo(s61.hashCode()))));
 221         assertThat(s42.hashCode(), is(not(equalTo(s62.hashCode()))));
 222         assertThat(s42.hashCode(), is(not(equalTo(s63.hashCode()))));
 223
 224         assertThat(s43.hashCode(), is(not(equalTo(s41.hashCode()))));
 225         assertThat(s43.hashCode(), is(not(equalTo(s42.hashCode()))));
 226         assertThat(s43.hashCode(), is(equalTo(s43.hashCode())));
 227         assertThat(s43.hashCode(), is(not(equalTo(s61.hashCode()))));
 228         assertThat(s43.hashCode(), is(not(equalTo(s62.hashCode()))));
 229         assertThat(s43.hashCode(), is(not(equalTo(s63.hashCode()))));
 230
 231         assertThat(s61.hashCode(), is(not(equalTo(s41.hashCode()))));
 232         assertThat(s61.hashCode(), is(not(equalTo(s42.hashCode()))));
 233         assertThat(s61.hashCode(), is(not(equalTo(s43.hashCode()))));
 234         assertThat(s61.hashCode(), is(equalTo(s61.hashCode())));
 235         assertThat(s61.hashCode(), is(not(equalTo(s62.hashCode()))));
 236         assertThat(s61.hashCode(), is(not(equalTo(s63.hashCode()))));
 237
 238         assertThat(s62.hashCode(), is(not(equalTo(s41.hashCode()))));
 239         assertThat(s62.hashCode(), is(not(equalTo(s42.hashCode()))));
 240         assertThat(s62.hashCode(), is(not(equalTo(s43.hashCode()))));
 241         assertThat(s62.hashCode(), is(not(equalTo(s61.hashCode()))));
 242         assertThat(s62.hashCode(), is(equalTo(s62.hashCode())));
 243         assertThat(s62.hashCode(), is(equalTo(s63.hashCode())));
 244
 245         assertThat(s63.hashCode(), is(not(equalTo(s41.hashCode()))));
 246         assertThat(s63.hashCode(), is(not(equalTo(s42.hashCode()))));
 247         assertThat(s63.hashCode(), is(not(equalTo(s43.hashCode()))));
 248         assertThat(s63.hashCode(), is(not(equalTo(s61.hashCode()))));
 249         assertThat(s63.hashCode(), is(equalTo(s62.hashCode())));
 250         assertThat(s63.hashCode(), is(equalTo(s63.hashCode())));
 251     }
 252
 253     @Test
 254     public final void testCreateInstance() throws UnknownHostException {
 255         Subnet subnet = Subnet.createInstance("192.168.0.0/255.255.255.0");
 256         assertThat(subnet, is(notNullValue(Subnet.class)));
 257         assertThat(subnet.toString(), is("192.168.0.0/255.255.255.0"));
 258         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.0/255.255.255.0"))));
 259         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.0/24"))));
 260         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.10/255.255.255.0"))));
 261         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.10/24"))));
 262
 263         subnet = Subnet.createInstance("192.168.0.1");
 264         assertThat(subnet, is(notNullValue(Subnet.class)));
 265         assertThat(subnet.toString(), is("192.168.0.1/255.255.255.255"));
 266         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.1"))));
 267         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.1/32"))));
 268         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.1/255.255.255.255"))));
 269
 270         subnet = Subnet.createInstance("192.168.0.0/8");
 271         assertThat(subnet, is(notNullValue(Subnet.class)));
 272         assertThat(subnet.toString(), is("192.0.0.0/255.0.0.0"));
 273         assertThat(subnet, is(equalTo(Subnet.createInstance("192.168.0.0/8"))));
 274         assertThat(subnet, is(equalTo(Subnet.createInstance("192.175.0.10/8"))));
 275         assertThat(subnet, is(equalTo(Subnet.createInstance("192.10.0.0/255.0.0.0"))));
 276         assertThat(subnet, is(equalTo(Subnet.createInstance("192.1.0.100/255.0.0.0"))));
 277
 278     }
 279
 280     @Test
 281     public final void testIsInNet()
 282     {
 283         Subnet subnet = new Subnet(addressV4, CLASS_C);
 284         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.1")));
 285         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.100")));
 286         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.255")));
 287         assertFalse(subnet.isInNet(InetAddresses.forString("192.168.1.1")));
 288         assertFalse(subnet.isInNet(InetAddresses.forString("192.167.0.255")));
 289         assertFalse(subnet.isInNet(InetAddresses.forString("191.168.0.1")));
 290         assertFalse(subnet.isInNet(addressV6));
 291
 292         subnet = new Subnet(addressV4, CLASS_B);
 293         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.1")));
 294         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.100")));
 295         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.255")));
 296         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.1.1")));
 297         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.1.255")));
 298         assertFalse(subnet.isInNet(InetAddresses.forString("192.167.0.255")));
 299         assertFalse(subnet.isInNet(InetAddresses.forString("191.168.0.1")));
 300         assertFalse(subnet.isInNet(addressV6));
 301
 302         subnet = new Subnet(addressV4, CLASS_A);
 303         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.1")));
 304         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.100")));
 305         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.255")));
 306         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.1.1")));
 307         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.1.255")));
 308         assertTrue(subnet.isInNet(InetAddresses.forString("192.167.0.255")));
 309         assertFalse(subnet.isInNet(InetAddresses.forString("191.168.0.1")));
 310         assertFalse(subnet.isInNet(addressV6));
 311
 312         subnet = new Subnet(addressV4, 32);
 313         assertTrue(subnet.isInNet(InetAddresses.forString("192.168.0.1")));
 314         assertFalse(subnet.isInNet(InetAddresses.forString("192.168.0.100")));
 315         assertFalse(subnet.isInNet(InetAddresses.forString("192.168.0.255")));
 316         assertFalse(subnet.isInNet(InetAddresses.forString("192.168.1.1")));
 317         assertFalse(subnet.isInNet(InetAddresses.forString("192.168.1.255")));
 318         assertFalse(subnet.isInNet(InetAddresses.forString("192.167.0.255")));
 319         assertFalse(subnet.isInNet(InetAddresses.forString("191.168.0.1")));
 320         assertFalse(subnet.isInNet(addressV6));
 321
 322         subnet = new Subnet(addressV6, 64);
 323         assertTrue(subnet.isInNet(InetAddresses.forString("2001:db8::1")));
 324         assertTrue(subnet.isInNet(InetAddresses.forString("2001:db8::100")));
 325         assertTrue(subnet.isInNet(InetAddresses.forString("2001:db8::ffff")));
 326         assertFalse(subnet.isInNet(InetAddresses.forString("2001:db7::1")));
 327         assertFalse(subnet.isInNet(InetAddresses.forString("2000:db8::")));
 328         assertTrue(subnet.isInNet(InetAddresses.forString("2001:db8:0:0:1::1")));
 329         assertFalse(subnet.isInNet(addressV4));
 330
 331     }
 332 }