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);
}
}
}