| package net.onrc.onos.apps.sdnip; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class PrefixTest { |
| |
| private List<PrefixTestData> testPrefixes; |
| |
| private class PrefixTestData { |
| public final String dotNotation; |
| public final String binaryNotation; |
| public final int prefixLength; |
| |
| public PrefixTestData(String dotNotation, int prefixLength, |
| String binaryNotation) { |
| this.dotNotation = dotNotation; |
| this.prefixLength = prefixLength; |
| this.binaryNotation = binaryNotation; |
| } |
| } |
| |
| @Before |
| public void setUp() throws Exception { |
| |
| testPrefixes = new LinkedList<>(); |
| |
| testPrefixes.add(new PrefixTestData("0.0.0.0", 0, "")); |
| |
| testPrefixes.add(new PrefixTestData("192.168.166.0", 22, |
| "1100000010101000101001")); |
| |
| testPrefixes.add(new PrefixTestData("192.168.166.0", 23, |
| "11000000101010001010011")); |
| |
| testPrefixes.add(new PrefixTestData("192.168.166.0", 24, |
| "110000001010100010100110")); |
| |
| testPrefixes.add(new PrefixTestData("130.162.10.1", 25, |
| "1000001010100010000010100")); |
| |
| testPrefixes.add(new PrefixTestData("255.255.255.255", 32, |
| "11111111111111111111111111111111")); |
| } |
| |
| @After |
| public void tearDown() throws Exception { |
| } |
| |
| @Test |
| public void testNewPrefixFromByteArray() { |
| byte[] b1 = new byte[]{(byte) 0x8f, (byte) 0xa0, (byte) 0x00, (byte) 0x00}; |
| byte[] b2 = new byte[]{(byte) 0x8f, (byte) 0xa0, (byte) 0xff, (byte) 0xff}; |
| byte[] b3 = new byte[]{(byte) 0x8f, (byte) 0xac, (byte) 0x00, (byte) 0x00}; |
| byte[] b4 = new byte[]{(byte) 0x8f, (byte) 0xa0, (byte) 0x00, (byte) 0x00}; |
| |
| Prefix p1 = new Prefix(b1, 12); |
| Prefix p2 = new Prefix(b2, 12); |
| Prefix p3 = new Prefix(b3, 12); |
| Prefix p4 = new Prefix(b4, 11); |
| |
| // Different input byte arrays, but Prefixes should be equal after |
| // construction |
| assertTrue(p1.equals(p2)); |
| assertTrue(p2.equals(p3)); |
| |
| // Same input byte array, but should be false |
| assertFalse(p1.equals(p4)); |
| |
| assertTrue(Arrays.equals(p1.getAddress(), p3.getAddress())); |
| assertTrue(p1.toString().equals(p2.toString())); |
| assertTrue(Arrays.equals(p1.getAddress(), p4.getAddress())); |
| assertFalse(p1.toString().equals(p4.toString())); |
| } |
| |
| @Test |
| public void testPrefixString() { |
| Prefix p1 = new Prefix("192.168.166.0", 24); |
| Prefix p2 = new Prefix("192.168.166.0", 23); |
| Prefix p3 = new Prefix("192.168.166.128", 24); |
| Prefix p4 = new Prefix("192.168.166.128", 25); |
| |
| assertFalse(p1.equals(p2)); |
| assertTrue(Arrays.equals(p1.getAddress(), p2.getAddress())); |
| |
| assertTrue(p1.equals(p3)); |
| assertTrue(Arrays.equals(p1.getAddress(), p2.getAddress())); |
| |
| assertFalse(p3.equals(p4)); |
| assertFalse(Arrays.equals(p3.getAddress(), p4.getAddress())); |
| |
| assertTrue(p1.toString().equals(p3.toString())); |
| assertEquals(p1.hashCode(), p3.hashCode()); |
| } |
| |
| @Test |
| public void testPrefixReturnsSame() { |
| // Create a prefix of all ones for each prefix length. |
| // Check that Prefix doesn't mangle it |
| for (int prefixLength = 1; prefixLength <= Prefix.MAX_PREFIX_LENGTH; prefixLength++) { |
| byte[] address = new byte[Prefix.ADDRESS_LENGTH_BYTES]; |
| |
| int lastByte = (prefixLength - 1) / Byte.SIZE; |
| int lastBit = (prefixLength - 1) % Byte.SIZE; |
| |
| for (int j = 0; j < address.length; j++) { |
| if (j < lastByte) { |
| address[j] = (byte) 0xff; |
| } else if (j == lastByte) { |
| byte b = 0; |
| byte msb = (byte) 0x80; |
| for (int k = 0; k < Byte.SIZE; k++) { |
| if (k <= lastBit) { |
| b |= (msb >> k); |
| } |
| } |
| address[j] = b; |
| } else { |
| address[j] = 0; |
| } |
| } |
| |
| Prefix p = new Prefix(address, prefixLength); |
| |
| assertTrue(Arrays.equals(address, p.getAddress())); |
| } |
| } |
| |
| @Test |
| public void testToBinaryString() { |
| for (PrefixTestData testPrefix : testPrefixes) { |
| Prefix p = new Prefix(testPrefix.dotNotation, testPrefix.prefixLength); |
| assertEquals(testPrefix.binaryNotation, p.toBinaryString()); |
| assertEquals(p.getPrefixLength(), p.toBinaryString().length()); |
| } |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testStringConstructorPrefixLengthTooSmall() { |
| String s = "255.255.255.255"; |
| |
| // Check the first valid prefix length works |
| Prefix p = new Prefix(s, Prefix.MIN_PREFIX_LENGTH); |
| assertNotNull(p); |
| |
| // Should throw IllegalArgumentException |
| new Prefix(s, Prefix.MIN_PREFIX_LENGTH - 1); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testStringConstructorPrefixLengthTooLarge() { |
| String s = "255.255.255.255"; |
| |
| // Check the last valid prefix length works |
| Prefix p = new Prefix(s, Prefix.MAX_PREFIX_LENGTH); |
| assertNotNull(p); |
| |
| // Should throw IllegalArgumentException |
| new Prefix(s, Prefix.MAX_PREFIX_LENGTH + 1); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testByteConstructorPrefixLengthTooSmall() { |
| byte[] b = new byte[]{(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff}; |
| |
| // Check the first valid prefix length works |
| Prefix p = new Prefix(b, Prefix.MIN_PREFIX_LENGTH); |
| assertNotNull(p); |
| |
| // Should throw IllegalArgumentException |
| new Prefix(b, Prefix.MIN_PREFIX_LENGTH - 1); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testByteConstructorPrefixLengthTooLarge() { |
| byte[] b = new byte[]{(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff}; |
| |
| // Check the last valid prefix length works |
| Prefix p = new Prefix(b, Prefix.MAX_PREFIX_LENGTH); |
| assertNotNull(p); |
| |
| // Should throw IllegalArgumentException |
| new Prefix(b, Prefix.MAX_PREFIX_LENGTH + 1); |
| } |
| |
| @Test |
| public void testFromBinaryString() { |
| Map<String, String> binaryToDecimalDot = new HashMap<>(); |
| |
| binaryToDecimalDot.put("", "0.0.0.0/0"); |
| binaryToDecimalDot.put("1", "128.0.0.0/1"); |
| binaryToDecimalDot.put("10000001", "129.0.0.0/8"); |
| binaryToDecimalDot.put("1011011110", "183.128.0.0/10"); |
| binaryToDecimalDot.put("01001101000000001010010110110101", "77.0.165.181/32"); |
| |
| for (Map.Entry<String, String> entry : binaryToDecimalDot.entrySet()) { |
| Prefix p = Prefix.fromBinaryString(entry.getKey()); |
| assertEquals(entry.getValue(), p.toString()); |
| } |
| } |
| |
| @Test |
| public void testFromBinaryStringInvalidInput() { |
| try { |
| Prefix.fromBinaryString("34102"); |
| fail("Non-binary input should throw an exception"); |
| } catch (IllegalArgumentException e) { |
| assertTrue(true); |
| } |
| |
| try { |
| Prefix.fromBinaryString("-0101"); |
| fail("Non-binary input should throw an exception"); |
| } catch (IllegalArgumentException e) { |
| assertTrue(true); |
| } |
| |
| try { |
| Prefix.fromBinaryString("01010101010101010101010101010102"); |
| fail("Non-binary input should throw an exception"); |
| } catch (IllegalArgumentException e) { |
| assertTrue(true); |
| } |
| |
| try { |
| Prefix.fromBinaryString("010101010101010101010101010101011"); |
| fail("Input too long should throw an exception"); |
| } catch (IllegalArgumentException e) { |
| assertTrue(true); |
| } |
| } |
| } |