Gitiles
Code Review Sign In
gerrit.onosproject.org / onos / 68c4fc48623635f508e1fc10fa8ea3190635e2fb / . / utils / misc / src / test / java / org / onlab / packet / IpPrefixTest.java
blob: 052a4cbb43ad129656add8f07f6b2b874f7e3ab3 [file] [log] [blame]
Thomas Vachuska24c849c2014-10-27 09:53:05 -0700[diff] [blame]1/*
Ray Milkey34c95902015-04-15 09:47:53 -0700[diff] [blame]2 * Copyright 2014-2015 Open Networking Laboratory
Thomas Vachuska24c849c2014-10-27 09:53:05 -0700[diff] [blame]3 *
Thomas Vachuska4f1a60c2014-10-28 13:39:07 -0700[diff] [blame]4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
Thomas Vachuska24c849c2014-10-27 09:53:05 -0700[diff] [blame]7 *
Thomas Vachuska4f1a60c2014-10-28 13:39:07 -0700[diff] [blame]8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
Thomas Vachuska24c849c2014-10-27 09:53:05 -0700[diff] [blame]15 */
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]16package org.onlab.packet;
17
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]18import org.junit.Test;
19
Ray Milkey37f6a382014-11-25 14:54:42 -0800[diff] [blame]20import com.google.common.testing.EqualsTester;
21
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]22import static org.hamcrest.Matchers.equalTo;
23import static org.hamcrest.Matchers.is;
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]24import static org.junit.Assert.assertFalse;
Pavlin Radoslavov34c81642014-11-04 16:21:38 -0800[diff] [blame]25import static org.junit.Assert.assertNull;
26import static org.junit.Assert.assertThat;
Ayaka Koshibe40e7fec2014-09-16 22:32:19 -0700[diff] [blame]27import static org.junit.Assert.assertTrue;
Ray Milkey37f6a382014-11-25 14:54:42 -0800[diff] [blame]28import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutableBaseClass;
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]29
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]30/**
31 * Tests for class {@link IpPrefix}.
32 */
Ayaka Koshibe1d56fe42014-09-19 16:51:58 -0700[diff] [blame]33public class IpPrefixTest {
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]34 /**
35 * Tests the immutability of {@link IpPrefix}.
36 */
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]37 @Test
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]38 public void testImmutable() {
Ray Milkey37f6a382014-11-25 14:54:42 -0800[diff] [blame]39 assertThatClassIsImmutableBaseClass(IpPrefix.class);
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]40 }
41
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]42 /**
43 * Tests the maximum mask length.
44 */
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]45 @Test
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]46 public void testMaxMaskLength() {
47 assertThat(IpPrefix.MAX_INET_MASK_LENGTH, is(32));
48 assertThat(IpPrefix.MAX_INET6_MASK_LENGTH, is(128));
Ayaka Koshibe40e7fec2014-09-16 22:32:19 -0700[diff] [blame]49 }
50
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]51 /**
52 * Tests returning the IP version of the prefix.
53 */
Ayaka Koshibe40e7fec2014-09-16 22:32:19 -0700[diff] [blame]54 @Test
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]55 public void testVersion() {
56 IpPrefix ipPrefix;
57
58 // IPv4
59 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
60 assertThat(ipPrefix.version(), is(IpAddress.Version.INET));
61
62 // IPv6
63 ipPrefix = IpPrefix.valueOf("::/0");
64 assertThat(ipPrefix.version(), is(IpAddress.Version.INET6));
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]65 }
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]66
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]67 /**
Pavlin Radoslavov34ffe722015-03-10 12:48:55 -0700[diff] [blame]68 * Tests whether the IP version of a prefix is IPv4.
69 */
70 @Test
71 public void testIsIp4() {
72 IpPrefix ipPrefix;
73
74 // IPv4
75 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
76 assertTrue(ipPrefix.isIp4());
77
78 // IPv6
79 ipPrefix = IpPrefix.valueOf("::/0");
80 assertFalse(ipPrefix.isIp4());
81 }
82
83 /**
84 * Tests whether the IP version of a prefix is IPv6.
85 */
86 @Test
87 public void testIsIp6() {
88 IpPrefix ipPrefix;
89
90 // IPv4
91 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
92 assertFalse(ipPrefix.isIp6());
93
94 // IPv6
95 ipPrefix = IpPrefix.valueOf("::/0");
96 assertTrue(ipPrefix.isIp6());
97 }
98
99 /**
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]100 * Tests returning the IP address value and IP address prefix length of
101 * an IPv4 prefix.
102 */
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]103 @Test
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]104 public void testAddressAndPrefixLengthIPv4() {
105 IpPrefix ipPrefix;
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]106
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]107 ipPrefix = IpPrefix.valueOf("1.2.3.0/24");
108 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.0")));
109 assertThat(ipPrefix.prefixLength(), is(24));
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]110
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]111 ipPrefix = IpPrefix.valueOf("1.2.3.4/24");
112 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.0")));
113 assertThat(ipPrefix.prefixLength(), is(24));
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]114
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]115 ipPrefix = IpPrefix.valueOf("1.2.3.4/32");
116 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.4")));
117 assertThat(ipPrefix.prefixLength(), is(32));
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]118
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]119 ipPrefix = IpPrefix.valueOf("1.2.3.5/32");
120 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.5")));
121 assertThat(ipPrefix.prefixLength(), is(32));
122
123 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
124 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("0.0.0.0")));
125 assertThat(ipPrefix.prefixLength(), is(0));
126
127 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
128 assertThat(ipPrefix.address(),
129 equalTo(IpAddress.valueOf("255.255.255.255")));
130 assertThat(ipPrefix.prefixLength(), is(32));
Jonathan Hartb7a2ac32014-09-19 10:42:27 -0700[diff] [blame]131 }
Jonathan Hart70da5122014-10-01 16:37:42 -0700[diff] [blame]132
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]133 /**
134 * Tests returning the IP address value and IP address prefix length of
135 * an IPv6 prefix.
136 */
Jonathan Hart70da5122014-10-01 16:37:42 -0700[diff] [blame]137 @Test
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]138 public void testAddressAndPrefixLengthIPv6() {
139 IpPrefix ipPrefix;
Jonathan Hart70da5122014-10-01 16:37:42 -0700[diff] [blame]140
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]141 ipPrefix = IpPrefix.valueOf("1100::/8");
142 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1100::")));
143 assertThat(ipPrefix.prefixLength(), is(8));
Jonathan Hart70da5122014-10-01 16:37:42 -0700[diff] [blame]144
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]145 ipPrefix =
146 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/8");
147 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1100::")));
148 assertThat(ipPrefix.prefixLength(), is(8));
Jonathan Hart70da5122014-10-01 16:37:42 -0700[diff] [blame]149
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]150 ipPrefix =
151 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8800/120");
152 assertThat(ipPrefix.address(),
153 equalTo(IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8800")));
154 assertThat(ipPrefix.prefixLength(), is(120));
Jonathan Hartdbdbdbb2014-10-06 18:35:30 -0700[diff] [blame]155
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]156 ipPrefix =
157 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/128");
158 assertThat(ipPrefix.address(),
159 equalTo(IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8885")));
160 assertThat(ipPrefix.prefixLength(), is(128));
Jonathan Hartdbdbdbb2014-10-06 18:35:30 -0700[diff] [blame]161
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]162 ipPrefix = IpPrefix.valueOf("::/0");
163 assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("::")));
164 assertThat(ipPrefix.prefixLength(), is(0));
165
166 ipPrefix =
167 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
168 assertThat(ipPrefix.address(),
169 equalTo(IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
170 assertThat(ipPrefix.prefixLength(), is(128));
171
172 ipPrefix =
173 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/64");
174 assertThat(ipPrefix.address(),
175 equalTo(IpAddress.valueOf("1111:2222:3333:4444::")));
176 assertThat(ipPrefix.prefixLength(), is(64));
177 }
178
179 /**
Pavlin Radoslavov34c81642014-11-04 16:21:38 -0800[diff] [blame]180 * Tests getting the Ip4Prefix and Ip6Prefix view of the IP prefix.
181 */
182 @Test
183 public void testGetIp4AndIp6PrefixView() {
184 IpPrefix ipPrefix;
185 Ip4Prefix ip4Prefix;
186 Ip6Prefix ip6Prefix;
187
188 // Pure IPv4 IpPrefix
189 ipPrefix = IpPrefix.valueOf("1.2.3.0/24");
190 ip4Prefix = ipPrefix.getIp4Prefix();
191 ip6Prefix = ipPrefix.getIp6Prefix();
192 assertThat(ip4Prefix.toString(), is("1.2.3.0/24"));
193 assertNull(ip6Prefix);
194
195 // IPv4 IpPrefix that is Ip4Prefix
196 ipPrefix = Ip4Prefix.valueOf("1.2.3.0/24");
197 ip4Prefix = ipPrefix.getIp4Prefix();
198 ip6Prefix = ipPrefix.getIp6Prefix();
199 assertThat(ip4Prefix.toString(), is("1.2.3.0/24"));
200 assertNull(ip6Prefix);
201
202 // Pure IPv6 IpPrefix
203 ipPrefix = IpPrefix.valueOf("1111:2222::/64");
204 ip4Prefix = ipPrefix.getIp4Prefix();
205 ip6Prefix = ipPrefix.getIp6Prefix();
206 assertNull(ip4Prefix);
207 assertThat(ip6Prefix.toString(), is("1111:2222::/64"));
208
209 // IPv6 IpPrefix that is Ip6Prefix
210 ipPrefix = Ip6Prefix.valueOf("1111:2222::/64");
211 ip4Prefix = ipPrefix.getIp4Prefix();
212 ip6Prefix = ipPrefix.getIp6Prefix();
213 assertNull(ip4Prefix);
214 assertThat(ip6Prefix.toString(), is("1111:2222::/64"));
215 }
216
217 /**
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]218 * Tests valueOf() converter for IPv4 integer value.
219 */
220 @Test
221 public void testValueOfForIntegerIPv4() {
222 IpPrefix ipPrefix;
223
224 ipPrefix = IpPrefix.valueOf(0x01020304, 24);
225 assertThat(ipPrefix.toString(), is("1.2.3.0/24"));
226
227 ipPrefix = IpPrefix.valueOf(0x01020304, 32);
228 assertThat(ipPrefix.toString(), is("1.2.3.4/32"));
229
230 ipPrefix = IpPrefix.valueOf(0x01020305, 32);
231 assertThat(ipPrefix.toString(), is("1.2.3.5/32"));
232
233 ipPrefix = IpPrefix.valueOf(0, 0);
234 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
235
236 ipPrefix = IpPrefix.valueOf(0, 32);
237 assertThat(ipPrefix.toString(), is("0.0.0.0/32"));
238
239 ipPrefix = IpPrefix.valueOf(0xffffffff, 0);
240 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
241
242 ipPrefix = IpPrefix.valueOf(0xffffffff, 16);
243 assertThat(ipPrefix.toString(), is("255.255.0.0/16"));
244
245 ipPrefix = IpPrefix.valueOf(0xffffffff, 32);
246 assertThat(ipPrefix.toString(), is("255.255.255.255/32"));
247 }
248
249 /**
250 * Tests invalid valueOf() converter for IPv4 integer value and
251 * negative prefix length.
252 */
253 @Test(expected = IllegalArgumentException.class)
254 public void testInvalidValueOfIntegerNegativePrefixLengthIPv4() {
255 IpPrefix ipPrefix;
256
257 ipPrefix = IpPrefix.valueOf(0x01020304, -1);
258 }
259
260 /**
261 * Tests invalid valueOf() converter for IPv4 integer value and
262 * too long prefix length.
263 */
264 @Test(expected = IllegalArgumentException.class)
265 public void testInvalidValueOfIntegerTooLongPrefixLengthIPv4() {
266 IpPrefix ipPrefix;
267
268 ipPrefix = IpPrefix.valueOf(0x01020304, 33);
269 }
270
271 /**
272 * Tests valueOf() converter for IPv4 byte array.
273 */
274 @Test
275 public void testValueOfByteArrayIPv4() {
276 IpPrefix ipPrefix;
277 byte[] value;
278
279 value = new byte[] {1, 2, 3, 4};
280 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 24);
281 assertThat(ipPrefix.toString(), is("1.2.3.0/24"));
282
283 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32);
284 assertThat(ipPrefix.toString(), is("1.2.3.4/32"));
285
286 value = new byte[] {1, 2, 3, 5};
287 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32);
288 assertThat(ipPrefix.toString(), is("1.2.3.5/32"));
289
290 value = new byte[] {0, 0, 0, 0};
291 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 0);
292 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
293
294 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32);
295 assertThat(ipPrefix.toString(), is("0.0.0.0/32"));
296
297 value = new byte[] {(byte) 0xff, (byte) 0xff,
298 (byte) 0xff, (byte) 0xff};
299 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 0);
300 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
301
302 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 16);
303 assertThat(ipPrefix.toString(), is("255.255.0.0/16"));
304
305 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32);
306 assertThat(ipPrefix.toString(), is("255.255.255.255/32"));
307 }
308
309 /**
310 * Tests valueOf() converter for IPv6 byte array.
311 */
312 @Test
313 public void testValueOfByteArrayIPv6() {
314 IpPrefix ipPrefix;
315 byte[] value;
316
317 value = new byte[] {0x11, 0x11, 0x22, 0x22,
318 0x33, 0x33, 0x44, 0x44,
319 0x55, 0x55, 0x66, 0x66,
320 0x77, 0x77, (byte) 0x88, (byte) 0x88};
321 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 120);
322 assertThat(ipPrefix.toString(),
323 is("1111:2222:3333:4444:5555:6666:7777:8800/120"));
324
325 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 128);
326 assertThat(ipPrefix.toString(),
327 is("1111:2222:3333:4444:5555:6666:7777:8888/128"));
328
329 value = new byte[] {0x00, 0x00, 0x00, 0x00,
330 0x00, 0x00, 0x00, 0x00,
331 0x00, 0x00, 0x00, 0x00,
332 0x00, 0x00, 0x00, 0x00};
333 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 0);
334 assertThat(ipPrefix.toString(), is("::/0"));
335
336 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 128);
337 assertThat(ipPrefix.toString(), is("::/128"));
338
339 value = new byte[] {(byte) 0xff, (byte) 0xff,
340 (byte) 0xff, (byte) 0xff,
341 (byte) 0xff, (byte) 0xff,
342 (byte) 0xff, (byte) 0xff,
343 (byte) 0xff, (byte) 0xff,
344 (byte) 0xff, (byte) 0xff,
345 (byte) 0xff, (byte) 0xff,
346 (byte) 0xff, (byte) 0xff};
347 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 0);
348 assertThat(ipPrefix.toString(), is("::/0"));
349
350 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 64);
351 assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64"));
352
353 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 128);
354 assertThat(ipPrefix.toString(),
355 is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"));
356 }
357
358 /**
359 * Tests invalid valueOf() converter for a null array for IPv4.
360 */
361 @Test(expected = NullPointerException.class)
362 public void testInvalidValueOfNullArrayIPv4() {
363 IpPrefix ipPrefix;
364 byte[] value;
365
366 value = null;
367 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 24);
368 }
369
370 /**
371 * Tests invalid valueOf() converter for a null array for IPv6.
372 */
373 @Test(expected = NullPointerException.class)
374 public void testInvalidValueOfNullArrayIPv6() {
375 IpPrefix ipPrefix;
376 byte[] value;
377
378 value = null;
379 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 120);
380 }
381
382 /**
383 * Tests invalid valueOf() converter for a short array for IPv4.
384 */
385 @Test(expected = IllegalArgumentException.class)
386 public void testInvalidValueOfShortArrayIPv4() {
387 IpPrefix ipPrefix;
388 byte[] value;
389
390 value = new byte[] {1, 2, 3};
391 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 24);
392 }
393
394 /**
395 * Tests invalid valueOf() converter for a short array for IPv6.
396 */
397 @Test(expected = IllegalArgumentException.class)
398 public void testInvalidValueOfShortArrayIPv6() {
399 IpPrefix ipPrefix;
400 byte[] value;
401
402 value = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
403 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 120);
404 }
405
406 /**
407 * Tests invalid valueOf() converter for IPv4 byte array and
408 * negative prefix length.
409 */
410 @Test(expected = IllegalArgumentException.class)
411 public void testInvalidValueOfByteArrayNegativePrefixLengthIPv4() {
412 IpPrefix ipPrefix;
413 byte[] value;
414
415 value = new byte[] {1, 2, 3, 4};
416 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, -1);
417 }
418
419 /**
420 * Tests invalid valueOf() converter for IPv6 byte array and
421 * negative prefix length.
422 */
423 @Test(expected = IllegalArgumentException.class)
424 public void testInvalidValueOfByteArrayNegativePrefixLengthIPv6() {
425 IpPrefix ipPrefix;
426 byte[] value;
427
428 value = new byte[] {0x11, 0x11, 0x22, 0x22,
429 0x33, 0x33, 0x44, 0x44,
430 0x55, 0x55, 0x66, 0x66,
431 0x77, 0x77, (byte) 0x88, (byte) 0x88};
432 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, -1);
433 }
434
435 /**
436 * Tests invalid valueOf() converter for IPv4 byte array and
437 * too long prefix length.
438 */
439 @Test(expected = IllegalArgumentException.class)
440 public void testInvalidValueOfByteArrayTooLongPrefixLengthIPv4() {
441 IpPrefix ipPrefix;
442 byte[] value;
443
444 value = new byte[] {1, 2, 3, 4};
445 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 33);
446 }
447
448 /**
449 * Tests invalid valueOf() converter for IPv6 byte array and
450 * too long prefix length.
451 */
452 @Test(expected = IllegalArgumentException.class)
453 public void testInvalidValueOfByteArrayTooLongPrefixLengthIPv6() {
454 IpPrefix ipPrefix;
455 byte[] value;
456
457 value = new byte[] {0x11, 0x11, 0x22, 0x22,
458 0x33, 0x33, 0x44, 0x44,
459 0x55, 0x55, 0x66, 0x66,
460 0x77, 0x77, (byte) 0x88, (byte) 0x88};
461 ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 129);
462 }
463
464 /**
465 * Tests valueOf() converter for IPv4 address.
466 */
467 @Test
468 public void testValueOfAddressIPv4() {
469 IpAddress ipAddress;
470 IpPrefix ipPrefix;
471
472 ipAddress = IpAddress.valueOf("1.2.3.4");
473 ipPrefix = IpPrefix.valueOf(ipAddress, 24);
474 assertThat(ipPrefix.toString(), is("1.2.3.0/24"));
475
476 ipPrefix = IpPrefix.valueOf(ipAddress, 32);
477 assertThat(ipPrefix.toString(), is("1.2.3.4/32"));
478
479 ipAddress = IpAddress.valueOf("1.2.3.5");
480 ipPrefix = IpPrefix.valueOf(ipAddress, 32);
481 assertThat(ipPrefix.toString(), is("1.2.3.5/32"));
482
483 ipAddress = IpAddress.valueOf("0.0.0.0");
484 ipPrefix = IpPrefix.valueOf(ipAddress, 0);
485 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
486
487 ipPrefix = IpPrefix.valueOf(ipAddress, 32);
488 assertThat(ipPrefix.toString(), is("0.0.0.0/32"));
489
490 ipAddress = IpAddress.valueOf("255.255.255.255");
491 ipPrefix = IpPrefix.valueOf(ipAddress, 0);
492 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
493
494 ipPrefix = IpPrefix.valueOf(ipAddress, 16);
495 assertThat(ipPrefix.toString(), is("255.255.0.0/16"));
496
497 ipPrefix = IpPrefix.valueOf(ipAddress, 32);
498 assertThat(ipPrefix.toString(), is("255.255.255.255/32"));
499 }
500
501 /**
502 * Tests valueOf() converter for IPv6 address.
503 */
504 @Test
505 public void testValueOfAddressIPv6() {
506 IpAddress ipAddress;
507 IpPrefix ipPrefix;
508
509 ipAddress =
510 IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888");
511 ipPrefix = IpPrefix.valueOf(ipAddress, 120);
512 assertThat(ipPrefix.toString(),
513 is("1111:2222:3333:4444:5555:6666:7777:8800/120"));
514
515 ipPrefix = IpPrefix.valueOf(ipAddress, 128);
516 assertThat(ipPrefix.toString(),
517 is("1111:2222:3333:4444:5555:6666:7777:8888/128"));
518
519 ipAddress = IpAddress.valueOf("::");
520 ipPrefix = IpPrefix.valueOf(ipAddress, 0);
521 assertThat(ipPrefix.toString(), is("::/0"));
522
523 ipPrefix = IpPrefix.valueOf(ipAddress, 128);
524 assertThat(ipPrefix.toString(), is("::/128"));
525
526 ipAddress =
527 IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
528 ipPrefix = IpPrefix.valueOf(ipAddress, 0);
529 assertThat(ipPrefix.toString(), is("::/0"));
530
531 ipPrefix = IpPrefix.valueOf(ipAddress, 64);
532 assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64"));
533
534 ipPrefix = IpPrefix.valueOf(ipAddress, 128);
535 assertThat(ipPrefix.toString(),
536 is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"));
537 }
538
539 /**
540 * Tests invalid valueOf() converter for a null IP address.
541 */
542 @Test(expected = NullPointerException.class)
543 public void testInvalidValueOfNullAddress() {
544 IpAddress ipAddress;
545 IpPrefix ipPrefix;
546
547 ipAddress = null;
548 ipPrefix = IpPrefix.valueOf(ipAddress, 24);
549 }
550
551 /**
552 * Tests invalid valueOf() converter for IPv4 address and
553 * negative prefix length.
554 */
555 @Test(expected = IllegalArgumentException.class)
556 public void testInvalidValueOfAddressNegativePrefixLengthIPv4() {
557 IpAddress ipAddress;
558 IpPrefix ipPrefix;
559
560 ipAddress = IpAddress.valueOf("1.2.3.4");
561 ipPrefix = IpPrefix.valueOf(ipAddress, -1);
562 }
563
564 /**
565 * Tests invalid valueOf() converter for IPv6 address and
566 * negative prefix length.
567 */
568 @Test(expected = IllegalArgumentException.class)
569 public void testInvalidValueOfAddressNegativePrefixLengthIPv6() {
570 IpAddress ipAddress;
571 IpPrefix ipPrefix;
572
573 ipAddress =
574 IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888");
575 ipPrefix = IpPrefix.valueOf(ipAddress, -1);
576 }
577
578 /**
579 * Tests invalid valueOf() converter for IPv4 address and
580 * too long prefix length.
581 */
582 @Test(expected = IllegalArgumentException.class)
583 public void testInvalidValueOfAddressTooLongPrefixLengthIPv4() {
584 IpAddress ipAddress;
585 IpPrefix ipPrefix;
586
587 ipAddress = IpAddress.valueOf("1.2.3.4");
588 ipPrefix = IpPrefix.valueOf(ipAddress, 33);
589 }
590
591 /**
592 * Tests invalid valueOf() converter for IPv6 address and
593 * too long prefix length.
594 */
595 @Test(expected = IllegalArgumentException.class)
596 public void testInvalidValueOfAddressTooLongPrefixLengthIPv6() {
597 IpAddress ipAddress;
598 IpPrefix ipPrefix;
599
600 ipAddress =
601 IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888");
602 ipPrefix = IpPrefix.valueOf(ipAddress, 129);
603 }
604
605 /**
606 * Tests valueOf() converter for IPv4 string.
607 */
608 @Test
609 public void testValueOfStringIPv4() {
610 IpPrefix ipPrefix;
611
612 ipPrefix = IpPrefix.valueOf("1.2.3.4/24");
613 assertThat(ipPrefix.toString(), is("1.2.3.0/24"));
614
615 ipPrefix = IpPrefix.valueOf("1.2.3.4/32");
616 assertThat(ipPrefix.toString(), is("1.2.3.4/32"));
617
618 ipPrefix = IpPrefix.valueOf("1.2.3.5/32");
619 assertThat(ipPrefix.toString(), is("1.2.3.5/32"));
620
621 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
622 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
623
624 ipPrefix = IpPrefix.valueOf("0.0.0.0/32");
625 assertThat(ipPrefix.toString(), is("0.0.0.0/32"));
626
627 ipPrefix = IpPrefix.valueOf("255.255.255.255/0");
628 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
629
630 ipPrefix = IpPrefix.valueOf("255.255.255.255/16");
631 assertThat(ipPrefix.toString(), is("255.255.0.0/16"));
632
633 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
634 assertThat(ipPrefix.toString(), is("255.255.255.255/32"));
635 }
636
637 /**
638 * Tests valueOf() converter for IPv6 string.
639 */
640 @Test
641 public void testValueOfStringIPv6() {
642 IpPrefix ipPrefix;
643
644 ipPrefix =
645 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/120");
646 assertThat(ipPrefix.toString(),
647 is("1111:2222:3333:4444:5555:6666:7777:8800/120"));
648
649 ipPrefix =
650 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/128");
651 assertThat(ipPrefix.toString(),
652 is("1111:2222:3333:4444:5555:6666:7777:8888/128"));
653
654 ipPrefix = IpPrefix.valueOf("::/0");
655 assertThat(ipPrefix.toString(), is("::/0"));
656
657 ipPrefix = IpPrefix.valueOf("::/128");
658 assertThat(ipPrefix.toString(), is("::/128"));
659
660 ipPrefix =
661 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/0");
662 assertThat(ipPrefix.toString(), is("::/0"));
663
664 ipPrefix =
665 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64");
666 assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64"));
667
668 ipPrefix =
669 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
670 assertThat(ipPrefix.toString(),
671 is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"));
672 }
673
674 /**
675 * Tests invalid valueOf() converter for a null string.
676 */
677 @Test(expected = NullPointerException.class)
678 public void testInvalidValueOfNullString() {
679 IpPrefix ipPrefix;
680 String fromString;
681
682 fromString = null;
683 ipPrefix = IpPrefix.valueOf(fromString);
684 }
685
686 /**
687 * Tests invalid valueOf() converter for an empty string.
688 */
689 @Test(expected = IllegalArgumentException.class)
690 public void testInvalidValueOfEmptyString() {
691 IpPrefix ipPrefix;
692 String fromString;
693
694 fromString = "";
695 ipPrefix = IpPrefix.valueOf(fromString);
696 }
697
698 /**
699 * Tests invalid valueOf() converter for an incorrect string.
700 */
701 @Test(expected = IllegalArgumentException.class)
702 public void testInvalidValueOfIncorrectString() {
703 IpPrefix ipPrefix;
704 String fromString;
705
706 fromString = "NoSuchIpPrefix";
707 ipPrefix = IpPrefix.valueOf(fromString);
708 }
709
710 /**
711 * Tests invalid valueOf() converter for IPv4 string and
712 * negative prefix length.
713 */
714 @Test(expected = IllegalArgumentException.class)
715 public void testInvalidValueOfStringNegativePrefixLengthIPv4() {
716 IpPrefix ipPrefix;
717
718 ipPrefix = IpPrefix.valueOf("1.2.3.4/-1");
719 }
720
721 /**
722 * Tests invalid valueOf() converter for IPv6 string and
723 * negative prefix length.
724 */
725 @Test(expected = IllegalArgumentException.class)
726 public void testInvalidValueOfStringNegativePrefixLengthIPv6() {
727 IpPrefix ipPrefix;
728
729 ipPrefix =
730 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/-1");
731 }
732
733 /**
734 * Tests invalid valueOf() converter for IPv4 string and
735 * too long prefix length.
736 */
737 @Test(expected = IllegalArgumentException.class)
738 public void testInvalidValueOfStringTooLongPrefixLengthIPv4() {
739 IpPrefix ipPrefix;
740
741 ipPrefix = IpPrefix.valueOf("1.2.3.4/33");
742 }
743
744 /**
745 * Tests invalid valueOf() converter for IPv6 string and
746 * too long prefix length.
747 */
748 @Test(expected = IllegalArgumentException.class)
749 public void testInvalidValueOfStringTooLongPrefixLengthIPv6() {
750 IpPrefix ipPrefix;
751
752 ipPrefix =
753 IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/129");
754 }
755
756 /**
757 * Tests IP prefix contains another IP prefix for IPv4.
758 */
759 @Test
760 public void testContainsIpPrefixIPv4() {
761 IpPrefix ipPrefix;
762
763 ipPrefix = IpPrefix.valueOf("1.2.0.0/24");
764 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24")));
765 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32")));
766 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32")));
767 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16")));
768 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24")));
769 assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16")));
770 assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0")));
771 assertFalse(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32")));
772
773 ipPrefix = IpPrefix.valueOf("1.2.0.0/32");
774 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24")));
775 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32")));
776 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32")));
777 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16")));
778 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24")));
779 assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16")));
780 assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0")));
781 assertFalse(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32")));
782
783 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
784 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24")));
785 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32")));
786 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32")));
787 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16")));
788 assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24")));
789 assertTrue(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16")));
790 assertTrue(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0")));
791 assertTrue(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32")));
792
793 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
794 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24")));
795 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32")));
796 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32")));
797 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16")));
798 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24")));
799 assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16")));
800 assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0")));
801 assertTrue(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32")));
Pavlin Radoslavovdbeab4c2015-02-23 09:37:49 -0800[diff] [blame]802
803 // Test when there is a mistmatch in the compared IP address families
804 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
805 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1111:2222:3333:4444::/120")));
806 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
807 assertFalse(ipPrefix.contains(IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")));
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]808 }
809
810 /**
811 * Tests IP prefix contains another IP prefix for IPv6.
812 */
813 @Test
814 public void testContainsIpPrefixIPv6() {
815 IpPrefix ipPrefix;
816
817 ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/120");
818 assertTrue(ipPrefix.contains(
819 IpPrefix.valueOf("1111:2222:3333:4444::/120")));
820 assertTrue(ipPrefix.contains(
821 IpPrefix.valueOf("1111:2222:3333:4444::/128")));
822 assertTrue(ipPrefix.contains(
823 IpPrefix.valueOf("1111:2222:3333:4444::1/128")));
824 assertFalse(ipPrefix.contains(
825 IpPrefix.valueOf("1111:2222:3333:4444::/64")));
826 assertFalse(ipPrefix.contains(
827 IpPrefix.valueOf("1111:2222:3333:4445::/120")));
828 assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/64")));
829 assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/0")));
830 assertFalse(ipPrefix.contains(
831 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")));
832
833 ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/128");
834 assertFalse(ipPrefix.contains(
835 IpPrefix.valueOf("1111:2222:3333:4444::/120")));
836 assertTrue(ipPrefix.contains(
837 IpPrefix.valueOf("1111:2222:3333:4444::/128")));
838 assertFalse(ipPrefix.contains(
839 IpPrefix.valueOf("1111:2222:3333:4444::1/128")));
840 assertFalse(ipPrefix.contains(
841 IpPrefix.valueOf("1111:2222:3333:4444::/64")));
842 assertFalse(ipPrefix.contains(
843 IpPrefix.valueOf("1111:2222:3333:4445::/120")));
844 assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/64")));
845 assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/0")));
846 assertFalse(ipPrefix.contains(
847 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")));
848
849 ipPrefix = IpPrefix.valueOf("::/0");
850 assertTrue(ipPrefix.contains(
851 IpPrefix.valueOf("1111:2222:3333:4444::/120")));
852 assertTrue(ipPrefix.contains(
853 IpPrefix.valueOf("1111:2222:3333:4444::/128")));
854 assertTrue(ipPrefix.contains(
855 IpPrefix.valueOf("1111:2222:3333:4444::1/128")));
856 assertTrue(ipPrefix.contains(
857 IpPrefix.valueOf("1111:2222:3333:4444::/64")));
858 assertTrue(ipPrefix.contains(
859 IpPrefix.valueOf("1111:2222:3333:4445::/120")));
860 assertTrue(ipPrefix.contains(IpPrefix.valueOf("::/64")));
861 assertTrue(ipPrefix.contains(IpPrefix.valueOf("::/0")));
862 assertTrue(ipPrefix.contains(
863 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")));
864
865 ipPrefix =
866 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
867 assertFalse(ipPrefix.contains(
868 IpPrefix.valueOf("1111:2222:3333:4444::/120")));
869 assertFalse(ipPrefix.contains(
870 IpPrefix.valueOf("1111:2222:3333:4444::/128")));
871 assertFalse(ipPrefix.contains(
872 IpPrefix.valueOf("1111:2222:3333:4444::1/128")));
873 assertFalse(ipPrefix.contains(
874 IpPrefix.valueOf("1111:2222:3333:4444::/64")));
875 assertFalse(ipPrefix.contains(
876 IpPrefix.valueOf("1111:2222:3333:4445::/120")));
877 assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/64")));
878 assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/0")));
879 assertTrue(ipPrefix.contains(
880 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")));
Pavlin Radoslavovdbeab4c2015-02-23 09:37:49 -0800[diff] [blame]881
882 // Test when there is a mistmatch in the compared IP address families
883 ipPrefix = IpPrefix.valueOf("::/0");
884 assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24")));
885 ipPrefix = IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
886 assertFalse(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32")));
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]887 }
888
889 /**
890 * Tests IP prefix contains IP address for IPv4.
891 */
892 @Test
893 public void testContainsIpAddressIPv4() {
894 IpPrefix ipPrefix;
895
896 ipPrefix = IpPrefix.valueOf("1.2.0.0/24");
897 assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.0")));
898 assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.4")));
899 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.3.0.0")));
900 assertFalse(ipPrefix.contains(IpAddress.valueOf("0.0.0.0")));
901 assertFalse(ipPrefix.contains(IpAddress.valueOf("255.255.255.255")));
902
903 ipPrefix = IpPrefix.valueOf("1.2.0.0/32");
904 assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.0")));
905 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.4")));
906 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.3.0.0")));
907 assertFalse(ipPrefix.contains(IpAddress.valueOf("0.0.0.0")));
908 assertFalse(ipPrefix.contains(IpAddress.valueOf("255.255.255.255")));
909
910 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
911 assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.0")));
912 assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.4")));
913 assertTrue(ipPrefix.contains(IpAddress.valueOf("1.3.0.0")));
914 assertTrue(ipPrefix.contains(IpAddress.valueOf("0.0.0.0")));
915 assertTrue(ipPrefix.contains(IpAddress.valueOf("255.255.255.255")));
916
917 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
918 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.0")));
919 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.4")));
920 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.3.0.0")));
921 assertFalse(ipPrefix.contains(IpAddress.valueOf("0.0.0.0")));
922 assertTrue(ipPrefix.contains(IpAddress.valueOf("255.255.255.255")));
Pavlin Radoslavovdbeab4c2015-02-23 09:37:49 -0800[diff] [blame]923
924 // Test when there is a mistmatch in the compared IP address families
925 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
926 assertFalse(ipPrefix.contains(IpAddress.valueOf("1111:2222:3333:4444::")));
927 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
928 assertFalse(ipPrefix.contains(IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]929 }
930
931 /**
932 * Tests IP prefix contains IP address for IPv6.
933 */
934 @Test
935 public void testContainsIpAddressIPv6() {
936 IpPrefix ipPrefix;
937
938 ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/120");
939 assertTrue(ipPrefix.contains(
940 IpAddress.valueOf("1111:2222:3333:4444::")));
941 assertTrue(ipPrefix.contains(
942 IpAddress.valueOf("1111:2222:3333:4444::1")));
943 assertFalse(ipPrefix.contains(
944 IpAddress.valueOf("1111:2222:3333:4445::")));
945 assertFalse(ipPrefix.contains(IpAddress.valueOf("::")));
946 assertFalse(ipPrefix.contains(
947 IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
948
949 ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/128");
950 assertTrue(ipPrefix.contains(
951 IpAddress.valueOf("1111:2222:3333:4444::")));
952 assertFalse(ipPrefix.contains(
953 IpAddress.valueOf("1111:2222:3333:4444::1")));
954 assertFalse(ipPrefix.contains(
955 IpAddress.valueOf("1111:2222:3333:4445::")));
956 assertFalse(ipPrefix.contains(IpAddress.valueOf("::")));
957 assertFalse(ipPrefix.contains(
958 IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
959
960 ipPrefix = IpPrefix.valueOf("::/0");
961 assertTrue(ipPrefix.contains(
962 IpAddress.valueOf("1111:2222:3333:4444::")));
963 assertTrue(ipPrefix.contains(
964 IpAddress.valueOf("1111:2222:3333:4444::1")));
965 assertTrue(ipPrefix.contains(
966 IpAddress.valueOf("1111:2222:3333:4445::")));
967 assertTrue(ipPrefix.contains(IpAddress.valueOf("::")));
968 assertTrue(ipPrefix.contains(
969 IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
970
971 ipPrefix =
972 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
973 assertFalse(ipPrefix.contains(
974 IpAddress.valueOf("1111:2222:3333:4444::")));
975 assertFalse(ipPrefix.contains(
976 IpAddress.valueOf("1111:2222:3333:4444::1")));
977 assertFalse(ipPrefix.contains(
978 IpAddress.valueOf("1111:2222:3333:4445::")));
979 assertFalse(ipPrefix.contains(IpAddress.valueOf("::")));
980 assertTrue(ipPrefix.contains(
981 IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
Pavlin Radoslavovdbeab4c2015-02-23 09:37:49 -0800[diff] [blame]982
983 // Test when there is a mistmatch in the compared IP address families
984 ipPrefix = IpPrefix.valueOf("::/0");
985 assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.0")));
986 ipPrefix = IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
987 assertFalse(ipPrefix.contains(IpAddress.valueOf("255.255.255.255")));
Pavlin Radoslavov34c921a2014-11-03 15:41:22 -0800[diff] [blame]988 }
989
990 /**
991 * Tests equality of {@link IpPrefix} for IPv4.
992 */
993 @Test
994 public void testEqualityIPv4() {
995 new EqualsTester()
996 .addEqualityGroup(IpPrefix.valueOf("1.2.0.0/24"),
997 IpPrefix.valueOf("1.2.0.0/24"),
998 IpPrefix.valueOf("1.2.0.4/24"))
999 .addEqualityGroup(IpPrefix.valueOf("1.2.0.0/16"),
1000 IpPrefix.valueOf("1.2.0.0/16"))
1001 .addEqualityGroup(IpPrefix.valueOf("1.2.0.0/32"),
1002 IpPrefix.valueOf("1.2.0.0/32"))
1003 .addEqualityGroup(IpPrefix.valueOf("1.3.0.0/24"),
1004 IpPrefix.valueOf("1.3.0.0/24"))
1005 .addEqualityGroup(IpPrefix.valueOf("0.0.0.0/0"),
1006 IpPrefix.valueOf("0.0.0.0/0"))
1007 .addEqualityGroup(IpPrefix.valueOf("255.255.255.255/32"),
1008 IpPrefix.valueOf("255.255.255.255/32"))
1009 .testEquals();
1010 }
1011
1012 /**
1013 * Tests equality of {@link IpPrefix} for IPv6.
1014 */
1015 @Test
1016 public void testEqualityIPv6() {
1017 new EqualsTester()
1018 .addEqualityGroup(
1019 IpPrefix.valueOf("1111:2222:3333:4444::/120"),
1020 IpPrefix.valueOf("1111:2222:3333:4444::1/120"),
1021 IpPrefix.valueOf("1111:2222:3333:4444::/120"))
1022 .addEqualityGroup(
1023 IpPrefix.valueOf("1111:2222:3333:4444::/64"),
1024 IpPrefix.valueOf("1111:2222:3333:4444::/64"))
1025 .addEqualityGroup(
1026 IpPrefix.valueOf("1111:2222:3333:4444::/128"),
1027 IpPrefix.valueOf("1111:2222:3333:4444::/128"))
1028 .addEqualityGroup(
1029 IpPrefix.valueOf("1111:2222:3333:4445::/64"),
1030 IpPrefix.valueOf("1111:2222:3333:4445::/64"))
1031 .addEqualityGroup(
1032 IpPrefix.valueOf("::/0"),
1033 IpPrefix.valueOf("::/0"))
1034 .addEqualityGroup(
1035 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"),
1036 IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))
1037 .testEquals();
1038 }
1039
1040 /**
1041 * Tests object string representation for IPv4.
1042 */
1043 @Test
1044 public void testToStringIPv4() {
1045 IpPrefix ipPrefix;
1046
1047 ipPrefix = IpPrefix.valueOf("1.2.3.0/24");
1048 assertThat(ipPrefix.toString(), is("1.2.3.0/24"));
1049
1050 ipPrefix = IpPrefix.valueOf("1.2.3.4/24");
1051 assertThat(ipPrefix.toString(), is("1.2.3.0/24"));
1052
1053 ipPrefix = IpPrefix.valueOf("0.0.0.0/0");
1054 assertThat(ipPrefix.toString(), is("0.0.0.0/0"));
1055
1056 ipPrefix = IpPrefix.valueOf("255.255.255.255/32");
1057 assertThat(ipPrefix.toString(), is("255.255.255.255/32"));
1058 }
1059
1060 /**
1061 * Tests object string representation for IPv6.
1062 */
1063 @Test
1064 public void testToStringIPv6() {
1065 IpPrefix ipPrefix;
1066
1067 ipPrefix = IpPrefix.valueOf("1100::/8");
1068 assertThat(ipPrefix.toString(), is("1100::/8"));
1069
1070 ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/8");
1071 assertThat(ipPrefix.toString(), is("1100::/8"));
1072
1073 ipPrefix = IpPrefix.valueOf("::/0");
1074 assertThat(ipPrefix.toString(), is("::/0"));
1075
1076 ipPrefix = IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128");
1077 assertThat(ipPrefix.toString(),
1078 is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"));
Jonathan Hart70da5122014-10-01 16:37:42 -0700[diff] [blame]1079 }
Ayaka Koshibe16698a32014-09-13 22:19:02 -0700[diff] [blame]1080}