diff options
author | Ashlee Young <ashlee@onosfw.com> | 2015-09-09 22:15:21 -0700 |
---|---|---|
committer | Ashlee Young <ashlee@onosfw.com> | 2015-09-09 22:15:21 -0700 |
commit | 13d05bc8458758ee39cb829098241e89616717ee (patch) | |
tree | 22a4d1ce65f15952f07a3df5af4b462b4697cb3a /framework/src/onos/utils/misc/src/test/java/org/onlab | |
parent | 6139282e1e93c2322076de4b91b1c85d0bc4a8b3 (diff) |
ONOS checkin based on commit tag e796610b1f721d02f9b0e213cf6f7790c10ecd60
Change-Id: Ife8810491034fe7becdba75dda20de4267bd15cd
Diffstat (limited to 'framework/src/onos/utils/misc/src/test/java/org/onlab')
64 files changed, 10154 insertions, 0 deletions
diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AbstractEdgeTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AbstractEdgeTest.java new file mode 100644 index 00000000..6e8635dd --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AbstractEdgeTest.java @@ -0,0 +1,37 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +/** + * Test of the base edge implementation. + */ +public class AbstractEdgeTest { + + @Test + public void equality() { + TestVertex v1 = new TestVertex("1"); + TestVertex v2 = new TestVertex("2"); + new EqualsTester() + .addEqualityGroup(new TestEdge(v1, v2, 1), + new TestEdge(v1, v2, 1)) + .addEqualityGroup(new TestEdge(v2, v1, 1)) + .testEquals(); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AbstractGraphPathSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AbstractGraphPathSearchTest.java new file mode 100644 index 00000000..b42cacf6 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AbstractGraphPathSearchTest.java @@ -0,0 +1,61 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; + +import static com.google.common.collect.ImmutableSet.of; +import static org.junit.Assert.assertEquals; + +/** + * Base for all graph search tests. + */ +public abstract class AbstractGraphPathSearchTest extends GraphTest { + + /** + * Creates a test-specific graph search to exercise. + * + * @return graph search + */ + protected abstract AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch(); + + @Test(expected = IllegalArgumentException.class) + public void noSuchSourceArgument() { + graphSearch().search(new AdjacencyListsGraph<>(of(B, C), + of(new TestEdge(B, C, 1))), + A, H, weight, 1); + } + + @Test(expected = NullPointerException.class) + public void nullGraphArgument() { + graphSearch().search(null, A, H, weight, 1); + } + + @Test(expected = NullPointerException.class) + public void nullSourceArgument() { + graphSearch().search(new AdjacencyListsGraph<>(of(B, C), + of(new TestEdge(B, C, 1))), + null, H, weight, 1); + } + + @Test + public void samenessThreshold() { + AbstractGraphPathSearch<TestVertex, TestEdge> search = graphSearch(); + search.setSamenessThreshold(0.3); + assertEquals("incorrect threshold", 0.3, search.samenessThreshold(), 0.01); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AdjacencyListsGraphTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AdjacencyListsGraphTest.java new file mode 100644 index 00000000..1f22b5c4 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/AdjacencyListsGraphTest.java @@ -0,0 +1,72 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import com.google.common.collect.ImmutableSet; +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.Set; + +import static org.junit.Assert.assertEquals; + +/** + * Tests of the graph implementation. + */ +public class AdjacencyListsGraphTest { + + private static final TestVertex A = new TestVertex("A"); + private static final TestVertex B = new TestVertex("B"); + private static final TestVertex C = new TestVertex("C"); + private static final TestVertex D = new TestVertex("D"); + private static final TestVertex E = new TestVertex("E"); + private static final TestVertex F = new TestVertex("F"); + private static final TestVertex G = new TestVertex("G"); + + private final Set<TestEdge> edges = + ImmutableSet.of(new TestEdge(A, B, 1), new TestEdge(B, C, 1), + new TestEdge(C, D, 1), new TestEdge(D, A, 1), + new TestEdge(B, D, 1)); + + @Test + public void equality() { + Set<TestVertex> vertexes = ImmutableSet.of(A, B, C, D, E, F); + Set<TestVertex> vertexes2 = ImmutableSet.of(A, B, C, D, E, F, G); + + AdjacencyListsGraph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(vertexes, edges); + AdjacencyListsGraph<TestVertex, TestEdge> same = new AdjacencyListsGraph<>(vertexes, edges); + AdjacencyListsGraph<TestVertex, TestEdge> different = new AdjacencyListsGraph<>(vertexes2, edges); + + new EqualsTester() + .addEqualityGroup(graph, same) + .addEqualityGroup(different) + .testEquals(); + } + + @Test + public void basics() { + Set<TestVertex> vertexes = ImmutableSet.of(A, B, C, D, E, F); + AdjacencyListsGraph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(vertexes, edges); + assertEquals("incorrect vertex count", 6, graph.getVertexes().size()); + assertEquals("incorrect edge count", 5, graph.getEdges().size()); + + assertEquals("incorrect egress edge count", 1, graph.getEdgesFrom(A).size()); + assertEquals("incorrect ingress edge count", 1, graph.getEdgesTo(A).size()); + assertEquals("incorrect ingress edge count", 1, graph.getEdgesTo(C).size()); + assertEquals("incorrect egress edge count", 2, graph.getEdgesFrom(B).size()); + assertEquals("incorrect ingress edge count", 2, graph.getEdgesTo(D).size()); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/BellmanFordGraphSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/BellmanFordGraphSearchTest.java new file mode 100644 index 00000000..ff363bfb --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/BellmanFordGraphSearchTest.java @@ -0,0 +1,77 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; + +import java.util.HashSet; +import java.util.Set; + +import static org.junit.Assert.assertEquals; +import static org.onlab.graph.GraphPathSearch.ALL_PATHS; + +/** + * Test of the Bellman-Ford algorithm. + */ +public class BellmanFordGraphSearchTest extends BreadthFirstSearchTest { + + @Override + protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() { + return new BellmanFordGraphSearch<>(); + } + + @Test + @Override + public void defaultGraphTest() { + executeDefaultTest(7, 5, 5.0); + } + + @Test + public void defaultHopCountWeight() { + weight = null; + executeDefaultTest(10, 3, 3.0); + } + + @Test + public void searchGraphWithNegativeCycles() { + Set<TestVertex> vertexes = new HashSet<>(vertexes()); + vertexes.add(Z); + + Set<TestEdge> edges = new HashSet<>(edges()); + edges.add(new TestEdge(G, Z, 1.0)); + edges.add(new TestEdge(Z, G, -2.0)); + + graph = new AdjacencyListsGraph<>(vertexes, edges); + + GraphPathSearch<TestVertex, TestEdge> search = graphSearch(); + Set<Path<TestVertex, TestEdge>> paths = search.search(graph, A, H, weight, ALL_PATHS).paths(); + assertEquals("incorrect paths count", 1, paths.size()); + + Path p = paths.iterator().next(); + assertEquals("incorrect src", A, p.src()); + assertEquals("incorrect dst", H, p.dst()); + assertEquals("incorrect path length", 5, p.edges().size()); + assertEquals("incorrect path cost", 5.0, p.cost(), 0.1); + + paths = search.search(graph, A, G, weight, ALL_PATHS).paths(); + assertEquals("incorrect paths count", 0, paths.size()); + + paths = search.search(graph, A, null, weight, ALL_PATHS).paths(); + printPaths(paths); + assertEquals("incorrect paths count", 6, paths.size()); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java new file mode 100644 index 00000000..0b574aff --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/BreadthFirstSearchTest.java @@ -0,0 +1,100 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; + +import java.util.Set; + +import static org.junit.Assert.assertEquals; +import static org.onlab.graph.GraphPathSearch.ALL_PATHS; + +/** + * Test of the BFS and similar path search algorithms. + */ +public class BreadthFirstSearchTest extends AbstractGraphPathSearchTest { + + @Override + protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() { + return new BreadthFirstSearch<>(); + } + + @Test + public void defaultGraphTest() { + executeDefaultTest(7, 3, 8.0); + } + + @Test + public void defaultHopCountWeight() { + weight = null; + executeDefaultTest(7, 3, 3.0); + } + + // Executes the default test + protected void executeDefaultTest(int pathCount, int pathLength, double pathCost) { + graph = new AdjacencyListsGraph<>(vertexes(), edges()); + + GraphPathSearch<TestVertex, TestEdge> search = graphSearch(); + Set<Path<TestVertex, TestEdge>> paths = + search.search(graph, A, H, weight, ALL_PATHS).paths(); + assertEquals("incorrect paths count", 1, paths.size()); + + Path p = paths.iterator().next(); + assertEquals("incorrect src", A, p.src()); + assertEquals("incorrect dst", H, p.dst()); + assertEquals("incorrect path length", pathLength, p.edges().size()); + assertEquals("incorrect path cost", pathCost, p.cost(), 0.1); + + paths = search.search(graph, A, null, weight, ALL_PATHS).paths(); + printPaths(paths); + assertEquals("incorrect paths count", pathCount, paths.size()); + } + + // Executes the search and validates its results. + protected void executeSearch(GraphPathSearch<TestVertex, TestEdge> search, + Graph<TestVertex, TestEdge> graph, + TestVertex src, TestVertex dst, + EdgeWeight<TestVertex, TestEdge> weight, + int pathCount, double pathCost) { + GraphPathSearch.Result<TestVertex, TestEdge> result = + search.search(graph, src, dst, weight, ALL_PATHS); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + printPaths(paths); + assertEquals("incorrect paths count", pathCount, paths.size()); + if (pathCount > 0) { + Path<TestVertex, TestEdge> path = paths.iterator().next(); + assertEquals("incorrect path cost", pathCost, path.cost(), 0.1); + } + } + + // Executes the single-path search and validates its results. + protected void executeSinglePathSearch(GraphPathSearch<TestVertex, TestEdge> search, + Graph<TestVertex, TestEdge> graph, + TestVertex src, TestVertex dst, + EdgeWeight<TestVertex, TestEdge> weight, + int pathCount, double pathCost) { + GraphPathSearch.Result<TestVertex, TestEdge> result = + search.search(graph, src, dst, weight, 1); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + printPaths(paths); + assertEquals("incorrect paths count", Math.min(pathCount, 1), paths.size()); + if (pathCount > 0) { + Path<TestVertex, TestEdge> path = paths.iterator().next(); + assertEquals("incorrect path cost", pathCost, path.cost(), 0.1); + } + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DefaultMutablePathTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DefaultMutablePathTest.java new file mode 100644 index 00000000..8eb09df6 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DefaultMutablePathTest.java @@ -0,0 +1,110 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import static com.google.common.collect.ImmutableList.of; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * Test of the default mutable path. + */ +public class DefaultMutablePathTest extends DefaultPathTest { + + @Test + public void equality() { + DefaultPath<TestVertex, TestEdge> p1 = + new DefaultPath<>(of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1)), 2.0); + DefaultPath<TestVertex, TestEdge> p2 = + new DefaultPath<>(of(new TestEdge(A, B, 1), + new TestEdge(B, D, 1)), 2.0); + new EqualsTester().addEqualityGroup(new DefaultMutablePath<>(p1), + new DefaultMutablePath<>(p1)) + .addEqualityGroup(new DefaultMutablePath<>(p2)) + .testEquals(); + } + + @Test + public void empty() { + MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>(); + assertNull("src should be null", p.src()); + assertNull("dst should be null", p.dst()); + assertEquals("incorrect edge count", 0, p.edges().size()); + assertEquals("incorrect path cost", 0.0, p.cost(), 0.1); + } + + @Test + public void pathCost() { + MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>(); + p.setCost(4); + assertEquals("incorrect path cost", 4.0, p.cost(), 0.1); + } + + private void validatePath(Path<TestVertex, TestEdge> p, + TestVertex src, TestVertex dst, int length) { + validatePath(p, src, dst, length, 0.0); + } + + @Test + public void insertEdge() { + MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>(); + p.insertEdge(new TestEdge(B, C, 1)); + p.insertEdge(new TestEdge(A, B, 1)); + validatePath(p, A, C, 2); + } + + @Test + public void appendEdge() { + MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>(); + p.appendEdge(new TestEdge(A, B, 1)); + p.appendEdge(new TestEdge(B, C, 1)); + validatePath(p, A, C, 2); + } + + @Test + public void removeEdge() { + MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>(); + p.appendEdge(new TestEdge(A, B, 1)); + p.appendEdge(new TestEdge(B, C, 1)); + p.appendEdge(new TestEdge(C, C, 2)); + p.appendEdge(new TestEdge(C, D, 1)); + validatePath(p, A, D, 4); + + p.removeEdge(new TestEdge(A, B, 1)); + validatePath(p, B, D, 3); + + p.removeEdge(new TestEdge(C, C, 2)); + validatePath(p, B, D, 2); + + p.removeEdge(new TestEdge(C, D, 1)); + validatePath(p, B, C, 1); + } + + @Test + public void toImmutable() { + MutablePath<TestVertex, TestEdge> p = new DefaultMutablePath<>(); + p.appendEdge(new TestEdge(A, B, 1)); + p.appendEdge(new TestEdge(B, C, 1)); + validatePath(p, A, C, 2); + + assertEquals("immutables should equal", p.toImmutable(), p.toImmutable()); + validatePath(p.toImmutable(), A, C, 2); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DefaultPathTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DefaultPathTest.java new file mode 100644 index 00000000..92befbfe --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DefaultPathTest.java @@ -0,0 +1,57 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.List; + +import static com.google.common.collect.ImmutableList.of; +import static org.junit.Assert.assertEquals; + +/** + * Test of the default path. + */ +public class DefaultPathTest extends GraphTest { + + @Test + public void equality() { + List<TestEdge> edges = of(new TestEdge(A, B, 1), new TestEdge(B, C, 1)); + new EqualsTester().addEqualityGroup(new DefaultPath<>(edges, 2.0), + new DefaultPath<>(edges, 2.0)) + .addEqualityGroup(new DefaultPath<>(edges, 3.0)) + .testEquals(); + } + + @Test + public void basics() { + Path<TestVertex, TestEdge> p = new DefaultPath<>(of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1)), 2.0); + validatePath(p, A, C, 2, 2.0); + } + + // Validates the path against expected attributes + protected void validatePath(Path<TestVertex, TestEdge> p, + TestVertex src, TestVertex dst, + int length, double cost) { + assertEquals("incorrect path length", length, p.edges().size()); + assertEquals("incorrect source", src, p.src()); + assertEquals("incorrect destination", dst, p.dst()); + assertEquals("incorrect path cost", cost, p.cost(), 0.1); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DepthFirstSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DepthFirstSearchTest.java new file mode 100644 index 00000000..3977ebf1 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DepthFirstSearchTest.java @@ -0,0 +1,97 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; + +import java.util.Set; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.onlab.graph.DepthFirstSearch.EdgeType; +import static org.onlab.graph.GraphPathSearch.ALL_PATHS; + +/** + * Test of the DFS algorithm. + */ +public class DepthFirstSearchTest extends AbstractGraphPathSearchTest { + + @Override + protected DepthFirstSearch<TestVertex, TestEdge> graphSearch() { + return new DepthFirstSearch<>(); + } + + @Test + public void defaultGraphTest() { + executeDefaultTest(3, 6, 5.0, 12.0); + executeBroadSearch(); + } + + @Test + public void defaultHopCountWeight() { + weight = null; + executeDefaultTest(3, 6, 3.0, 6.0); + executeBroadSearch(); + } + + protected void executeDefaultTest(int minLength, int maxLength, + double minCost, double maxCost) { + graph = new AdjacencyListsGraph<>(vertexes(), edges()); + DepthFirstSearch<TestVertex, TestEdge> search = graphSearch(); + + DepthFirstSearch<TestVertex, TestEdge>.SpanningTreeResult result = + search.search(graph, A, H, weight, 1); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + assertEquals("incorrect path count", 1, paths.size()); + + Path path = paths.iterator().next(); + System.out.println(path); + assertEquals("incorrect src", A, path.src()); + assertEquals("incorrect dst", H, path.dst()); + + int l = path.edges().size(); + assertTrue("incorrect path length " + l, + minLength <= l && l <= maxLength); + assertTrue("incorrect path cost " + path.cost(), + minCost <= path.cost() && path.cost() <= maxCost); + + System.out.println(result.edges()); + printPaths(paths); + } + + public void executeBroadSearch() { + graph = new AdjacencyListsGraph<>(vertexes(), edges()); + DepthFirstSearch<TestVertex, TestEdge> search = graphSearch(); + + // Perform narrow path search to a specific destination. + DepthFirstSearch<TestVertex, TestEdge>.SpanningTreeResult result = + search.search(graph, A, null, weight, ALL_PATHS); + assertEquals("incorrect paths count", 7, result.paths().size()); + + int[] types = new int[]{0, 0, 0, 0}; + for (EdgeType t : result.edges().values()) { + types[t.ordinal()] += 1; + } + assertEquals("incorrect tree-edge count", 7, + types[EdgeType.TREE_EDGE.ordinal()]); + assertEquals("incorrect back-edge count", 1, + types[EdgeType.BACK_EDGE.ordinal()]); + assertEquals("incorrect cross-edge & forward-edge count", 4, + types[EdgeType.FORWARD_EDGE.ordinal()] + + types[EdgeType.CROSS_EDGE.ordinal()]); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java new file mode 100644 index 00000000..17f08225 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/DijkstraGraphSearchTest.java @@ -0,0 +1,165 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; + +import java.text.DecimalFormat; +import java.util.HashSet; +import java.util.Set; + +import static com.google.common.collect.ImmutableSet.of; +import static org.junit.Assert.assertEquals; + +/** + * Test of the Dijkstra algorithm. + */ +public class DijkstraGraphSearchTest extends BreadthFirstSearchTest { + + @Override + protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() { + return new DijkstraGraphSearch<>(); + } + + @Test + @Override + public void defaultGraphTest() { + executeDefaultTest(7, 5, 5.0); + } + + @Test + @Override + public void defaultHopCountWeight() { + weight = null; + executeDefaultTest(10, 3, 3.0); + } + + @Test + public void noPath() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, A, 1), + new TestEdge(C, D, 1), + new TestEdge(D, C, 1))); + GraphPathSearch<TestVertex, TestEdge> gs = graphSearch(); + Set<Path<TestVertex, TestEdge>> paths = gs.search(graph, A, B, weight, 1).paths(); + printPaths(paths); + assertEquals("incorrect paths count", 1, paths.size()); + assertEquals("incorrect path cost", 1.0, paths.iterator().next().cost(), 0.1); + + paths = gs.search(graph, A, D, weight, 1).paths(); + printPaths(paths); + assertEquals("incorrect paths count", 0, paths.size()); + + paths = gs.search(graph, A, null, weight, 1).paths(); + printPaths(paths); + assertEquals("incorrect paths count", 1, paths.size()); + assertEquals("incorrect path cost", 1.0, paths.iterator().next().cost(), 0.1); + } + + @Test + public void simpleMultiplePath() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(A, C, 1), + new TestEdge(B, D, 1), + new TestEdge(C, D, 1))); + executeSearch(graphSearch(), graph, A, D, weight, 2, 2.0); + executeSinglePathSearch(graphSearch(), graph, A, D, weight, 1, 2.0); + } + + @Test + public void denseMultiplePath() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D, E, F, G), + of(new TestEdge(A, B, 1), + new TestEdge(A, C, 1), + new TestEdge(B, D, 1), + new TestEdge(C, D, 1), + new TestEdge(D, E, 1), + new TestEdge(D, F, 1), + new TestEdge(E, G, 1), + new TestEdge(F, G, 1), + new TestEdge(A, G, 4))); + executeSearch(graphSearch(), graph, A, G, weight, 5, 4.0); + executeSinglePathSearch(graphSearch(), graph, A, G, weight, 1, 4.0); + } + + @Test + public void dualEdgeMultiplePath() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D, E, F, G, H), + of(new TestEdge(A, B, 1), new TestEdge(A, C, 3), + new TestEdge(B, D, 2), new TestEdge(B, C, 1), + new TestEdge(B, E, 4), new TestEdge(C, E, 1), + new TestEdge(D, H, 5), new TestEdge(D, E, 1), + new TestEdge(E, F, 1), new TestEdge(F, D, 1), + new TestEdge(F, G, 1), new TestEdge(F, H, 1), + new TestEdge(A, E, 3), new TestEdge(B, D, 1))); + executeSearch(graphSearch(), graph, A, E, weight, 3, 3.0); + executeSinglePathSearch(graphSearch(), graph, A, E, weight, 1, 3.0); + } + + @Test + public void negativeWeights() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D, E, F, G), + of(new TestEdge(A, B, 1), + new TestEdge(A, C, -1), + new TestEdge(B, D, 1), + new TestEdge(D, A, -2), + new TestEdge(C, D, 1), + new TestEdge(D, E, 1), + new TestEdge(D, F, 1), + new TestEdge(E, G, 1), + new TestEdge(F, G, 1), + new TestEdge(G, A, -5), + new TestEdge(A, G, 4))); + executeSearch(graphSearch(), graph, A, G, weight, 3, 4.0); + executeSinglePathSearch(graphSearch(), graph, A, G, weight, 1, 4.0); + } + + @Test + public void disconnectedPerf() { + disconnected(); + disconnected(); + disconnected(); + disconnected(); + disconnected(); + disconnected(); + disconnected(); + disconnected(); + disconnected(); + disconnected(); + } + + + @Test + public void disconnected() { + Set<TestVertex> vertexes = new HashSet<>(); + for (int i = 0; i < 200; i++) { + vertexes.add(new TestVertex("v" + i)); + } + + graph = new AdjacencyListsGraph<>(vertexes, of()); + + long start = System.nanoTime(); + for (TestVertex src : vertexes) { + executeSearch(graphSearch(), graph, src, null, null, 0, 0); + } + long end = System.nanoTime(); + DecimalFormat fmt = new DecimalFormat("#,###"); + System.out.println("Compute cost is " + fmt.format(end - start) + " nanos"); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/GraphTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/GraphTest.java new file mode 100644 index 00000000..d29282fc --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/GraphTest.java @@ -0,0 +1,66 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import java.util.Set; + +import static com.google.common.collect.ImmutableSet.of; + +/** + * Base class for various graph-related tests. + */ +public class GraphTest { + + static final TestVertex A = new TestVertex("A"); + static final TestVertex B = new TestVertex("B"); + static final TestVertex C = new TestVertex("C"); + static final TestVertex D = new TestVertex("D"); + static final TestVertex E = new TestVertex("E"); + static final TestVertex F = new TestVertex("F"); + static final TestVertex G = new TestVertex("G"); + static final TestVertex H = new TestVertex("H"); + static final TestVertex Z = new TestVertex("Z"); + + protected Graph<TestVertex, TestEdge> graph; + + protected EdgeWeight<TestVertex, TestEdge> weight = + new EdgeWeight<TestVertex, TestEdge>() { + @Override + public double weight(TestEdge edge) { + return edge.weight(); + } + }; + + protected void printPaths(Set<Path<TestVertex, TestEdge>> paths) { + for (Path p : paths) { + System.out.println(p); + } + } + + protected Set<TestVertex> vertexes() { + return of(A, B, C, D, E, F, G, H); + } + + protected Set<TestEdge> edges() { + return of(new TestEdge(A, B, 1), new TestEdge(A, C, 3), + new TestEdge(B, D, 2), new TestEdge(B, C, 1), + new TestEdge(B, E, 4), new TestEdge(C, E, 1), + new TestEdge(D, H, 5), new TestEdge(D, E, 1), + new TestEdge(E, F, 1), new TestEdge(F, D, 1), + new TestEdge(F, G, 1), new TestEdge(F, H, 1)); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/HeapTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/HeapTest.java new file mode 100644 index 00000000..f34185e2 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/HeapTest.java @@ -0,0 +1,97 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import com.google.common.collect.Ordering; +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Comparator; + +import static com.google.common.collect.ImmutableList.of; +import static org.junit.Assert.*; + +/** + * Heap data structure tests. + */ +public class HeapTest { + + private ArrayList<Integer> data = + new ArrayList<>(of(6, 4, 5, 9, 8, 3, 2, 1, 7, 0)); + + private static final Comparator<Integer> MIN = Ordering.natural().reverse(); + private static final Comparator<Integer> MAX = Ordering.natural(); + + @Test + public void equality() { + new EqualsTester() + .addEqualityGroup(new Heap<>(data, MIN), + new Heap<>(data, MIN)) + .addEqualityGroup(new Heap<>(data, MAX)) + .testEquals(); + } + + @Test + public void empty() { + Heap<Integer> h = new Heap<>(new ArrayList<Integer>(), MIN); + assertTrue("should be empty", h.isEmpty()); + assertEquals("incorrect size", 0, h.size()); + assertNull("no item expected", h.extreme()); + assertNull("no item expected", h.extractExtreme()); + } + + @Test + public void insert() { + Heap<Integer> h = new Heap<>(data, MIN); + assertEquals("incorrect size", 10, h.size()); + h.insert(3); + assertEquals("incorrect size", 11, h.size()); + } + + @Test + public void minQueue() { + Heap<Integer> h = new Heap<>(data, MIN); + assertFalse("should not be empty", h.isEmpty()); + assertEquals("incorrect size", 10, h.size()); + assertEquals("incorrect extreme", (Integer) 0, h.extreme()); + + for (int i = 0, n = h.size(); i < n; i++) { + assertEquals("incorrect element", (Integer) i, h.extractExtreme()); + } + assertTrue("should be empty", h.isEmpty()); + } + + @Test + public void maxQueue() { + Heap<Integer> h = new Heap<>(data, MAX); + assertFalse("should not be empty", h.isEmpty()); + assertEquals("incorrect size", 10, h.size()); + assertEquals("incorrect extreme", (Integer) 9, h.extreme()); + + for (int i = h.size(); i > 0; i--) { + assertEquals("incorrect element", (Integer) (i - 1), h.extractExtreme()); + } + assertTrue("should be empty", h.isEmpty()); + } + + @Test + public void iterator() { + Heap<Integer> h = new Heap<>(data, MIN); + assertTrue("should have next element", h.iterator().hasNext()); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/KshortestPathSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/KshortestPathSearchTest.java new file mode 100644 index 00000000..3e8900b8 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/KshortestPathSearchTest.java @@ -0,0 +1,197 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import static com.google.common.collect.ImmutableSet.of; +import static org.junit.Assert.*; + +import java.io.ByteArrayOutputStream; +//import java.io.PrintStream; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +public class KshortestPathSearchTest extends BreadthFirstSearchTest { + + private final ByteArrayOutputStream outContent = new ByteArrayOutputStream(); + + @Test + public void noPath() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, A, 1), + new TestEdge(C, D, 1), + new TestEdge(D, C, 1))); + KshortestPathSearch<TestVertex, TestEdge> gs = new KshortestPathSearch<TestVertex, TestEdge>(graph); + List<List<TestEdge>> result = gs.search(A, D, weight, 1); + List<Path> paths = new ArrayList<>(); + Iterator<List<TestEdge>> itr = result.iterator(); + while (itr.hasNext()) { + System.out.println(itr.next().toString()); + } + assertEquals("incorrect paths count", 0, result.size()); + } + + @Test + public void test2Path() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, A, 1), + new TestEdge(B, D, 1), + new TestEdge(D, B, 1), + new TestEdge(A, C, 1), + new TestEdge(C, A, 1), + new TestEdge(C, D, 1), + new TestEdge(D, C, 1))); + KshortestPathSearch<TestVertex, TestEdge> gs = new KshortestPathSearch<TestVertex, TestEdge>(graph); + List<List<TestEdge>> result = gs.search(A, D, weight, 2); + List<Path> paths = new ArrayList<>(); + Iterator<List<TestEdge>> itr = result.iterator(); + while (itr.hasNext()) { + System.out.println(itr.next().toString()); + } + assertEquals("incorrect paths count", 2, result.size()); + // assertEquals("printing the paths", outContent.toString()); + } + + @Test + public void test3Path() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, A, 1), + new TestEdge(A, D, 1), + new TestEdge(D, A, 1), + new TestEdge(B, D, 1), + new TestEdge(D, B, 1), + new TestEdge(A, C, 1), + new TestEdge(C, A, 1), + new TestEdge(C, D, 1), + new TestEdge(D, C, 1))); + KshortestPathSearch<TestVertex, TestEdge> gs = new KshortestPathSearch<TestVertex, TestEdge>(graph); + List<List<TestEdge>> result = gs.search(A, D, weight, 3); + List<Path> paths = new ArrayList<>(); + Iterator<List<TestEdge>> itr = result.iterator(); + while (itr.hasNext()) { + System.out.println(itr.next().toString()); + } + assertEquals("incorrect paths count", 3, result.size()); + // assertEquals("printing the paths", outContent.toString()); + } + + @Test + public void test4Path() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D, E, F), + of(new TestEdge(A, B, 1), + new TestEdge(B, A, 1), + new TestEdge(A, C, 1), + new TestEdge(C, A, 1), + new TestEdge(B, D, 1), + new TestEdge(D, B, 1), + new TestEdge(C, E, 1), + new TestEdge(E, C, 1), + new TestEdge(D, F, 1), + new TestEdge(F, D, 1), + new TestEdge(F, E, 1), + new TestEdge(E, F, 1), + new TestEdge(C, D, 1), + new TestEdge(D, C, 1))); + KshortestPathSearch<TestVertex, TestEdge> gs = new KshortestPathSearch<TestVertex, TestEdge>(graph); + List<List<TestEdge>> result = gs.search(A, F, weight, 4); + List<Path> paths = new ArrayList<>(); + Iterator<List<TestEdge>> itr = result.iterator(); + while (itr.hasNext()) { + System.out.println(itr.next().toString()); + } + assertEquals("incorrect paths count", 4, result.size()); + // assertEquals("printing the paths", outContent.toString()); + } + + @Test + public void test6Path() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D, E, F), + of(new TestEdge(A, B, 1), + new TestEdge(B, A, 1), + new TestEdge(A, C, 1), + new TestEdge(C, A, 1), + new TestEdge(B, D, 1), + new TestEdge(D, B, 1), + new TestEdge(B, C, 1), + new TestEdge(C, B, 1), + new TestEdge(D, E, 1), + new TestEdge(E, D, 1), + new TestEdge(C, E, 1), + new TestEdge(E, C, 1), + new TestEdge(D, F, 1), + new TestEdge(F, D, 1), + new TestEdge(E, F, 1), + new TestEdge(F, E, 1))); + KshortestPathSearch<TestVertex, TestEdge> gs = new KshortestPathSearch<TestVertex, TestEdge>(graph); + List<List<TestEdge>> result = gs.search(A, F, weight, 6); + List<Path> paths = new ArrayList<>(); + Iterator<List<TestEdge>> itr = result.iterator(); + while (itr.hasNext()) { + System.out.println(itr.next().toString()); + } + assertEquals("incorrect paths count", 6, result.size()); + // assertEquals("printing the paths", outContent.toString()); + } + + @Test + public void dualEdgePath() { + graph = new AdjacencyListsGraph<>(of(A, B, C, D, E, F, G, H), + of(new TestEdge(A, B, 1), new TestEdge(A, C, 3), + new TestEdge(B, D, 2), new TestEdge(B, C, 1), + new TestEdge(B, E, 4), new TestEdge(C, E, 1), + new TestEdge(D, H, 5), new TestEdge(D, E, 1), + new TestEdge(E, F, 1), new TestEdge(F, D, 1), + new TestEdge(F, G, 1), new TestEdge(F, H, 1), + new TestEdge(A, E, 3), new TestEdge(B, D, 1))); + KshortestPathSearch<TestVertex, TestEdge> gs = new KshortestPathSearch<TestVertex, TestEdge>(graph); + List<List<TestEdge>> result = gs.search(A, G, weight, 6); + List<Path> paths = new ArrayList<>(); + Iterator<List<TestEdge>> itr = result.iterator(); + while (itr.hasNext()) { + System.out.println(itr.next().toString()); + } + assertEquals("incorrect paths count", 6, result.size()); + // assertEquals("printing the paths", outContent.toString()); + } + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + } + + @Before + public void setUp() throws Exception { + // System.setOut(new PrintStream(outContent)); + } + + @After + public void tearDown() throws Exception { + // System.setOut(null); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/SRLGGraphSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/SRLGGraphSearchTest.java new file mode 100644 index 00000000..885fbe5c --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/SRLGGraphSearchTest.java @@ -0,0 +1,183 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.graph; + +import org.junit.Test; +import java.util.Set; +import java.util.HashSet; +import java.util.Map; +import java.util.HashMap; + +import static com.google.common.collect.ImmutableSet.of; +import static org.junit.Assert.assertTrue; + + + +/** + * Test of the Suurballe backup path algorithm. + */ +public class SRLGGraphSearchTest extends BreadthFirstSearchTest { + @Override + protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() { + return new SRLGGraphSearch<TestVertex, TestEdge>(null); + } + + public void setWeights() { + weight = new EdgeWeight<TestVertex, TestEdge>() { + @Override + public double weight(TestEdge edge) { + return edge.weight(); + } + }; + } + public void setDefaultWeights() { + weight = null; + } + @Override + public void defaultGraphTest() { + + } + + @Override + public void defaultHopCountWeight() { + + } + + @Test + public void onePathPair() { + setDefaultWeights(); + TestEdge aB = new TestEdge(A, B, 1); + TestEdge bC = new TestEdge(B, C, 1); + TestEdge aD = new TestEdge(A, D, 1); + TestEdge dC = new TestEdge(D, C, 1); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(aB, bC, aD, dC)); + Map<TestEdge, Integer> riskProfile = new HashMap<TestEdge, Integer>(); + riskProfile.put(aB, 0); + riskProfile.put(bC, 0); + riskProfile.put(aD, 1); + riskProfile.put(dC, 1); + SRLGGraphSearch<TestVertex, TestEdge> search = + new SRLGGraphSearch<TestVertex, TestEdge>(2, riskProfile); + Set<Path<TestVertex, TestEdge>> paths = search.search(graph, A, C, weight, GraphPathSearch.ALL_PATHS).paths(); + System.out.println("\n\n\n" + paths + "\n\n\n"); + assertTrue("one disjoint path pair found", paths.size() == 1); + checkIsDisjoint(paths.iterator().next(), riskProfile); + } + public void checkIsDisjoint(Path<TestVertex, TestEdge> p, Map<TestEdge, Integer> risks) { + assertTrue("The path is not a DisjointPathPair", (p instanceof DisjointPathPair)); + DisjointPathPair<TestVertex, TestEdge> q = (DisjointPathPair) p; + Set<Integer> p1Risks = new HashSet<Integer>(); + Set<Integer> p2Risks = new HashSet<Integer>(); + for (TestEdge e: q.edges()) { + p1Risks.add(risks.get(e)); + } + if (!q.hasBackup()) { + return; + } + Path<TestVertex, TestEdge> pq = q.path2; + for (TestEdge e: pq.edges()) { + assertTrue("The paths are not disjoint", !p1Risks.contains(risks.get(e))); + } + } + @Test + public void complexGraphTest() { + setDefaultWeights(); + TestEdge aB = new TestEdge(A, B, 1); + TestEdge bC = new TestEdge(B, C, 1); + TestEdge aD = new TestEdge(A, D, 1); + TestEdge dC = new TestEdge(D, C, 1); + TestEdge cE = new TestEdge(C, E, 1); + TestEdge bE = new TestEdge(B, E, 1); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D, E), + of(aB, bC, aD, dC, cE, bE)); + Map<TestEdge, Integer> riskProfile = new HashMap<TestEdge, Integer>(); + riskProfile.put(aB, 0); + riskProfile.put(bC, 0); + riskProfile.put(aD, 1); + riskProfile.put(dC, 1); + riskProfile.put(cE, 2); + riskProfile.put(bE, 3); + SRLGGraphSearch<TestVertex, TestEdge> search = + new SRLGGraphSearch<TestVertex, TestEdge>(4, riskProfile); + Set<Path<TestVertex, TestEdge>> paths = search.search(graph, A, E, weight, GraphPathSearch.ALL_PATHS).paths(); + } + + @Test + public void multiplePathGraphTest() { + setDefaultWeights(); + TestEdge aB = new TestEdge(A, B, 1); + TestEdge bE = new TestEdge(B, E, 1); + TestEdge aD = new TestEdge(A, D, 1); + TestEdge dE = new TestEdge(D, E, 1); + TestEdge aC = new TestEdge(A, C, 1); + TestEdge cE = new TestEdge(C, E, 1); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D, E), + of(aB, bE, aD, dE, aC, cE)); + Map<TestEdge, Integer> riskProfile = new HashMap<TestEdge, Integer>(); + riskProfile.put(aB, 0); + riskProfile.put(bE, 1); + riskProfile.put(aD, 2); + riskProfile.put(dE, 3); + riskProfile.put(aC, 4); + riskProfile.put(cE, 5); + SRLGGraphSearch<TestVertex, TestEdge> search = + new SRLGGraphSearch<TestVertex, TestEdge>(6, riskProfile); + Set<Path<TestVertex, TestEdge>> paths = search.search(graph, A, E, weight, GraphPathSearch.ALL_PATHS).paths(); + assertTrue("> one disjoint path pair found", paths.size() >= 1); + checkIsDisjoint(paths.iterator().next(), riskProfile); + } + @Test + public void onePath() { + setDefaultWeights(); + TestEdge aB = new TestEdge(A, B, 1); + TestEdge bC = new TestEdge(B, C, 1); + TestEdge aD = new TestEdge(A, D, 1); + TestEdge dC = new TestEdge(D, C, 1); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(aB, bC, aD, dC)); + Map<TestEdge, Integer> riskProfile = new HashMap<TestEdge, Integer>(); + riskProfile.put(aB, 0); + riskProfile.put(bC, 0); + riskProfile.put(aD, 1); + riskProfile.put(dC, 0); + SRLGGraphSearch<TestVertex, TestEdge> search = + new SRLGGraphSearch<TestVertex, TestEdge>(2, riskProfile); + Set<Path<TestVertex, TestEdge>> paths = search.search(graph, A, C, weight, GraphPathSearch.ALL_PATHS).paths(); + System.out.println(paths); + assertTrue("no disjoint path pairs found", paths.size() == 0); + } + @Test + public void noPath() { + setDefaultWeights(); + TestEdge aB = new TestEdge(A, B, 1); + TestEdge bC = new TestEdge(B, C, 1); + TestEdge aD = new TestEdge(A, D, 1); + TestEdge dC = new TestEdge(D, C, 1); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D, E), + of(aB, bC, aD, dC)); + Map<TestEdge, Integer> riskProfile = new HashMap<>(); + riskProfile.put(aB, 0); + riskProfile.put(bC, 0); + riskProfile.put(aD, 1); + riskProfile.put(dC, 0); + SRLGGraphSearch<TestVertex, TestEdge> search = + new SRLGGraphSearch<>(2, riskProfile); + Set<Path<TestVertex, TestEdge>> paths = search.search(graph, A, E, weight, GraphPathSearch.ALL_PATHS).paths(); + assertTrue("no disjoint path pairs found", paths.size() == 0); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/SuurballeGraphSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/SuurballeGraphSearchTest.java new file mode 100644 index 00000000..0d2d13b0 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/SuurballeGraphSearchTest.java @@ -0,0 +1,154 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; +import java.util.Set; + +import static com.google.common.collect.ImmutableSet.of; +import static org.junit.Assert.assertEquals; +//import static org.junit.Assert.assertTrue; + + + +/** + * Test of the Suurballe backup path algorithm. + */ +public class SuurballeGraphSearchTest extends BreadthFirstSearchTest { + + @Override + protected AbstractGraphPathSearch<TestVertex, TestEdge> graphSearch() { + return new SuurballeGraphSearch<>(); + } + + public void setWeights() { + weight = new EdgeWeight<TestVertex, TestEdge>() { + @Override + public double weight(TestEdge edge) { + return edge.weight(); + } + }; + } + public void setDefaultWeights() { + weight = null; + } + @Override + public void defaultGraphTest() { + + } + + @Override + public void defaultHopCountWeight() { + + } + + @Test + public void basicGraphTest() { + setDefaultWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(A, D, 1), + new TestEdge(D, C, 1))); + executeSearch(graphSearch(), graph, A, C, weight, 1, 4.0); + } + + @Test + public void multiplePathOnePairGraphTest() { + setWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D, E), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(A, D, 1), + new TestEdge(D, C, 1), + new TestEdge(B, E, 2), + new TestEdge(C, E, 1))); + executeSearch(graphSearch(), graph, A, E, weight, 1, 6.0); + } + + @Test + public void multiplePathsMultiplePairs() { + setWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D, E), + of(new TestEdge(A, B, 1), + new TestEdge(B, E, 1), + new TestEdge(A, C, 1), + new TestEdge(C, E, 1), + new TestEdge(A, D, 1), + new TestEdge(D, E, 1), + new TestEdge(A, E, 2))); + GraphPathSearch.Result<TestVertex, TestEdge> result = + graphSearch().search(graph, A, E, weight, GraphPathSearch.ALL_PATHS); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + System.out.println("\n\n" + paths + "\n\n\ndone\n"); + assertEquals("incorrect paths count", 3, paths.size()); + DisjointPathPair<TestVertex, TestEdge> dpp = (DisjointPathPair<TestVertex, TestEdge>) paths.iterator().next(); + assertEquals("incorrect disjoint paths per path", 2, dpp.size()); + } + + @Test + public void differingPrimaryAndBackupPathLengths() { + setWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D, E), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(A, D, 1), + new TestEdge(D, C, 1), + new TestEdge(B, E, 1), + new TestEdge(C, E, 1))); + executeSearch(graphSearch(), graph, A, E, weight, 1, 5.0); + } + + @Test + public void onePath() { + setWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(A, C, 4), + new TestEdge(C, D, 1))); + GraphPathSearch.Result<TestVertex, TestEdge> result = + graphSearch().search(graph, A, D, weight, GraphPathSearch.ALL_PATHS); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + assertEquals("incorrect paths count", 1, paths.size()); + DisjointPathPair<TestVertex, TestEdge> dpp = (DisjointPathPair<TestVertex, TestEdge>) paths.iterator().next(); + assertEquals("incorrect disjoint paths count", 1, dpp.size()); + } + + @Test + public void noPath() { + setWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(A, C, 4))); + GraphPathSearch.Result<TestVertex, TestEdge> result = + graphSearch().search(graph, A, D, weight, GraphPathSearch.ALL_PATHS); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + assertEquals("incorrect paths count", paths.size(), 0); + } + + @Test + public void disconnected() { + setWeights(); + Graph<TestVertex, TestEdge> graph = new AdjacencyListsGraph<>(of(A, B, C, D), + of()); + GraphPathSearch.Result<TestVertex, TestEdge> result = + graphSearch().search(graph, A, D, weight, GraphPathSearch.ALL_PATHS); + Set<Path<TestVertex, TestEdge>> paths = result.paths(); + assertEquals("incorrect paths count", 0, paths.size()); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TarjanGraphSearchTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TarjanGraphSearchTest.java new file mode 100644 index 00000000..624c5781 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TarjanGraphSearchTest.java @@ -0,0 +1,125 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import org.junit.Test; + +import static com.google.common.collect.ImmutableSet.of; +import static org.junit.Assert.assertEquals; +import static org.onlab.graph.TarjanGraphSearch.SCCResult; + +/** + * Tarjan graph search tests. + */ +public class TarjanGraphSearchTest extends GraphTest { + + private void validate(SCCResult<TestVertex, TestEdge> result, int cc) { + System.out.println("Cluster count: " + result.clusterVertexes().size()); + System.out.println("Clusters: " + result.clusterVertexes()); + assertEquals("incorrect cluster count", cc, result.clusterCount()); + } + + private void validate(SCCResult<TestVertex, TestEdge> result, + int i, int vc, int ec) { + assertEquals("incorrect cluster count", vc, result.clusterVertexes().get(i).size()); + assertEquals("incorrect edge count", ec, result.clusterEdges().get(i).size()); + } + + @Test + public void basic() { + graph = new AdjacencyListsGraph<>(vertexes(), edges()); + TarjanGraphSearch<TestVertex, TestEdge> gs = new TarjanGraphSearch<>(); + SCCResult<TestVertex, TestEdge> result = gs.search(graph, null); + validate(result, 6); + } + + @Test + public void singleCluster() { + graph = new AdjacencyListsGraph<>(vertexes(), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(C, D, 1), + new TestEdge(D, E, 1), + new TestEdge(E, F, 1), + new TestEdge(F, G, 1), + new TestEdge(G, H, 1), + new TestEdge(H, A, 1))); + + TarjanGraphSearch<TestVertex, TestEdge> gs = new TarjanGraphSearch<>(); + SCCResult<TestVertex, TestEdge> result = gs.search(graph, null); + validate(result, 1); + validate(result, 0, 8, 8); + } + + @Test + public void twoUnconnectedCluster() { + graph = new AdjacencyListsGraph<>(vertexes(), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(C, D, 1), + new TestEdge(D, A, 1), + new TestEdge(E, F, 1), + new TestEdge(F, G, 1), + new TestEdge(G, H, 1), + new TestEdge(H, E, 1))); + TarjanGraphSearch<TestVertex, TestEdge> gs = new TarjanGraphSearch<>(); + SCCResult<TestVertex, TestEdge> result = gs.search(graph, null); + validate(result, 2); + validate(result, 0, 4, 4); + validate(result, 1, 4, 4); + } + + @Test + public void twoWeaklyConnectedClusters() { + graph = new AdjacencyListsGraph<>(vertexes(), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(C, D, 1), + new TestEdge(D, A, 1), + new TestEdge(E, F, 1), + new TestEdge(F, G, 1), + new TestEdge(G, H, 1), + new TestEdge(H, E, 1), + new TestEdge(B, E, 1))); + TarjanGraphSearch<TestVertex, TestEdge> gs = new TarjanGraphSearch<>(); + SCCResult<TestVertex, TestEdge> result = gs.search(graph, null); + validate(result, 2); + validate(result, 0, 4, 4); + validate(result, 1, 4, 4); + } + + @Test + public void twoClustersConnectedWithIgnoredEdges() { + graph = new AdjacencyListsGraph<>(vertexes(), + of(new TestEdge(A, B, 1), + new TestEdge(B, C, 1), + new TestEdge(C, D, 1), + new TestEdge(D, A, 1), + new TestEdge(E, F, 1), + new TestEdge(F, G, 1), + new TestEdge(G, H, 1), + new TestEdge(H, E, 1), + new TestEdge(B, E, -1), + new TestEdge(E, B, -1))); + + TarjanGraphSearch<TestVertex, TestEdge> gs = new TarjanGraphSearch<>(); + SCCResult<TestVertex, TestEdge> result = gs.search(graph, weight); + validate(result, 2); + validate(result, 0, 4, 4); + validate(result, 1, 4, 4); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TestEdge.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TestEdge.java new file mode 100644 index 00000000..951f655b --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TestEdge.java @@ -0,0 +1,73 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import java.util.Objects; + +import static com.google.common.base.MoreObjects.toStringHelper; + +/** + * Test edge. + */ +public class TestEdge extends AbstractEdge<TestVertex> { + + private final double weight; + + /** + * Creates a new edge between the specified source and destination vertexes. + * + * @param src source vertex + * @param dst destination vertex + * @param weight edge weight + */ + public TestEdge(TestVertex src, TestVertex dst, double weight) { + super(src, dst); + this.weight = weight; + } + + /** + * Returns the edge weight. + * + * @return edge weight + */ + public double weight() { + return weight; + } + + @Override + public int hashCode() { + return 31 * super.hashCode() + Objects.hash(weight); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof TestEdge) { + final TestEdge other = (TestEdge) obj; + return super.equals(obj) && Objects.equals(this.weight, other.weight); + } + return false; + } + + @Override + public String toString() { + return toStringHelper(this).add("src", src()).add("dst", dst()). + add("weight", weight).toString(); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TestVertex.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TestVertex.java new file mode 100644 index 00000000..be92bd27 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/graph/TestVertex.java @@ -0,0 +1,53 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.graph; + +import java.util.Objects; + +/** + * Test vertex. + */ +public class TestVertex implements Vertex { + + private final String name; + + public TestVertex(String name) { + this.name = name; + } + + @Override + public int hashCode() { + return Objects.hash(name); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof TestVertex) { + final TestVertex other = (TestVertex) obj; + return Objects.equals(this.name, other.name); + } + return false; + } + + @Override + public String toString() { + return name; + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ArpTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ArpTest.java new file mode 100644 index 00000000..62246245 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ArpTest.java @@ -0,0 +1,88 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Unit tests for the ARP class. + */ +public class ArpTest { + + private Deserializer<ARP> deserializer = ARP.deserializer(); + + private final byte hwAddressLength = 6; + private final byte protoAddressLength = 4; + + private MacAddress srcMac = MacAddress.valueOf(1); + private MacAddress targetMac = MacAddress.valueOf(2); + private Ip4Address srcIp = Ip4Address.valueOf(1); + private Ip4Address targetIp = Ip4Address.valueOf(2); + + private byte[] byteHeader; + + @Before + public void setUp() { + ByteBuffer bb = ByteBuffer.allocate(ARP.INITIAL_HEADER_LENGTH + + 2 * hwAddressLength + 2 * protoAddressLength); + bb.putShort(ARP.HW_TYPE_ETHERNET); + bb.putShort(ARP.PROTO_TYPE_IP); + bb.put(hwAddressLength); + bb.put(protoAddressLength); + bb.putShort(ARP.OP_REPLY); + + bb.put(srcMac.toBytes()); + bb.put(srcIp.toOctets()); + bb.put(targetMac.toBytes()); + bb.put(targetIp.toOctets()); + + byteHeader = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, byteHeader); + } + + @Test + public void testDeserialize() throws Exception { + ARP arp = deserializer.deserialize(byteHeader, 0, byteHeader.length); + + assertEquals(ARP.HW_TYPE_ETHERNET, arp.getHardwareType()); + assertEquals(ARP.PROTO_TYPE_IP, arp.getProtocolType()); + assertEquals(hwAddressLength, arp.getHardwareAddressLength()); + assertEquals(protoAddressLength, arp.getProtocolAddressLength()); + assertEquals(ARP.OP_REPLY, arp.getOpCode()); + + assertTrue(Arrays.equals(srcMac.toBytes(), arp.getSenderHardwareAddress())); + assertTrue(Arrays.equals(srcIp.toOctets(), arp.getSenderProtocolAddress())); + assertTrue(Arrays.equals(targetMac.toBytes(), arp.getTargetHardwareAddress())); + assertTrue(Arrays.equals(targetIp.toOctets(), arp.getTargetProtocolAddress())); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/DhcpTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/DhcpTest.java new file mode 100644 index 00000000..aac81412 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/DhcpTest.java @@ -0,0 +1,137 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import com.google.common.base.Charsets; +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Unit tests for DHCP class. + */ +public class DhcpTest { + + private Deserializer<DHCP> deserializer = DHCP.deserializer(); + + private byte opCode = 1; + private byte hardwareType = 1; + private byte hardwareAddressLength = Ethernet.DATALAYER_ADDRESS_LENGTH; + private byte hops = 0; + private int transactionId = 0x2ed4eb50; + private short seconds = 0; + private short flags = 0; + private int clientIpAddress = 1; + private int yourIpAddress = 2; + private int serverIpAddress = 3; + private int gatewayIpAddress = 4; + private byte[] clientHardwareAddress = MacAddress.valueOf(500).toBytes(); + private String serverName = "test-server"; + private String bootFileName = "test-file"; + + private String hostName = "test-host"; + private DHCPOption hostNameOption = new DHCPOption(); + + private byte[] byteHeader; + + @Before + public void setUp() { + hostNameOption.setCode((byte) 55); + hostNameOption.setLength((byte) hostName.length()); + hostNameOption.setData(hostName.getBytes(Charsets.US_ASCII)); + + // Packet length is the fixed DHCP header plus option length plus an + // extra byte to indicate 'end of options'. + ByteBuffer bb = ByteBuffer.allocate(DHCP.MIN_HEADER_LENGTH + + 2 + hostNameOption.getLength() + 1); + + bb.put(opCode); + bb.put(hardwareType); + bb.put(hardwareAddressLength); + bb.put(hops); + bb.putInt(transactionId); + bb.putShort(seconds); + bb.putShort(flags); + bb.putInt(clientIpAddress); + bb.putInt(yourIpAddress); + bb.putInt(serverIpAddress); + bb.putInt(gatewayIpAddress); + bb.put(clientHardwareAddress); + + // need 16 bytes of zeros to pad out the client hardware address field + bb.put(new byte[16 - hardwareAddressLength]); + + // Put server name and pad out to 64 bytes + bb.put(serverName.getBytes(Charsets.US_ASCII)); + bb.put(new byte[64 - serverName.length()]); + + // Put boot file name and pad out to 128 bytes + bb.put(bootFileName.getBytes(Charsets.US_ASCII)); + bb.put(new byte[128 - bootFileName.length()]); + + // Magic cookie + bb.put("DHCP".getBytes(Charsets.US_ASCII)); + + bb.put(hostNameOption.getCode()); + bb.put(hostNameOption.getLength()); + bb.put(hostNameOption.getData()); + + // End of options marker + bb.put((byte) (0xff & 255)); + + byteHeader = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, byteHeader); + } + + @Test + public void testDeserialize() throws Exception { + DHCP dhcp = deserializer.deserialize(byteHeader, 0, byteHeader.length); + + assertEquals(opCode, dhcp.opCode); + assertEquals(hardwareType, dhcp.hardwareType); + assertEquals(hardwareAddressLength, dhcp.hardwareAddressLength); + assertEquals(hops, dhcp.hops); + assertEquals(transactionId, dhcp.transactionId); + assertEquals(seconds, dhcp.seconds); + assertEquals(flags, dhcp.flags); + assertEquals(clientIpAddress, dhcp.clientIPAddress); + assertEquals(yourIpAddress, dhcp.yourIPAddress); + assertEquals(serverIpAddress, dhcp.serverIPAddress); + assertEquals(gatewayIpAddress, dhcp.gatewayIPAddress); + assertTrue(Arrays.equals(clientHardwareAddress, dhcp.clientHardwareAddress)); + + assertEquals(serverName, dhcp.serverName); + assertEquals(bootFileName, dhcp.bootFileName); + assertEquals(2, dhcp.options.size()); + assertEquals(hostNameOption, dhcp.options.get(0)); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/EthernetTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/EthernetTest.java new file mode 100644 index 00000000..15a01fc3 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/EthernetTest.java @@ -0,0 +1,103 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; + +import static org.junit.Assert.assertEquals; + +/** + * Unit tests for the Ethernet class. + */ +public class EthernetTest { + + private MacAddress dstMac; + private MacAddress srcMac; + private short ethertype = 6; + private short vlan = 5; + + private Deserializer<Ethernet> deserializer; + + private byte[] byteHeader; + private byte[] vlanByteHeader; + + @Before + public void setUp() { + deserializer = Ethernet.deserializer(); + + byte[] dstMacBytes = { + (byte) 0x88, (byte) 0x88, (byte) 0x88, (byte) 0x88, (byte) 0x88, + (byte) 0x88 }; + dstMac = MacAddress.valueOf(dstMacBytes); + byte[] srcMacBytes = { + (byte) 0xaa, (byte) 0xaa, (byte) 0xaa, (byte) 0xaa, (byte) 0xaa, + (byte) 0xaa }; + srcMac = MacAddress.valueOf(srcMacBytes); + + // Create Ethernet byte array with no VLAN header + ByteBuffer bb = ByteBuffer.allocate(Ethernet.ETHERNET_HEADER_LENGTH); + bb.put(dstMacBytes); + bb.put(srcMacBytes); + bb.putShort(ethertype); + + byteHeader = bb.array(); + + // Create Ethernet byte array with a VLAN header + bb = ByteBuffer.allocate(Ethernet.ETHERNET_HEADER_LENGTH + Ethernet.VLAN_HEADER_LENGTH); + bb.put(dstMacBytes); + bb.put(srcMacBytes); + bb.putShort(Ethernet.TYPE_VLAN); + bb.putShort(vlan); + bb.putShort(ethertype); + + vlanByteHeader = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws DeserializationException { + PacketTestUtils.testDeserializeTruncated(deserializer, vlanByteHeader); + } + + @Test + public void testDeserializeNoVlan() throws Exception { + Ethernet eth = deserializer.deserialize(byteHeader, 0, byteHeader.length); + + assertEquals(dstMac, eth.getDestinationMAC()); + assertEquals(srcMac, eth.getSourceMAC()); + assertEquals(Ethernet.VLAN_UNTAGGED, eth.getVlanID()); + assertEquals(ethertype, eth.getEtherType()); + } + + @Test + public void testDeserializeWithVlan() throws Exception { + Ethernet eth = deserializer.deserialize(vlanByteHeader, 0, vlanByteHeader.length); + + assertEquals(dstMac, eth.getDestinationMAC()); + assertEquals(srcMac, eth.getSourceMAC()); + assertEquals(vlan, eth.getVlanID()); + assertEquals(ethertype, eth.getEtherType()); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ICMP6Test.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ICMP6Test.java new file mode 100644 index 00000000..39ddc24c --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ICMP6Test.java @@ -0,0 +1,110 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +package org.onlab.packet; + +import org.junit.BeforeClass; +import org.junit.Test; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link ICMP6}. + */ +public class ICMP6Test { + private static final byte[] IPV6_SOURCE_ADDRESS = { + (byte) 0xfe, (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01 + }; + private static final byte[] IPV6_DESTINATION_ADDRESS = { + (byte) 0xfe, (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x02 + }; + + private static IPv6 ipv6 = new IPv6(); + private static byte[] bytePacket = { + ICMP6.ECHO_REQUEST, // type + (byte) 0x00, // code + (byte) 0x82, (byte) 0xbc, // checksum + }; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + ipv6.setSourceAddress(IPV6_SOURCE_ADDRESS); + ipv6.setDestinationAddress(IPV6_DESTINATION_ADDRESS); + ipv6.setNextHeader(IPv6.PROTOCOL_ICMP6); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + ICMP6 icmp6 = new ICMP6(); + icmp6.setIcmpType(ICMP6.ECHO_REQUEST); + icmp6.setIcmpCode((byte) 0); + icmp6.setParent(ipv6); + + assertArrayEquals(bytePacket, icmp6.serialize()); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(ICMP6.deserializer()); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(ICMP6.deserializer(), bytePacket); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws Exception { + ICMP6 icmp6 = ICMP6.deserializer().deserialize(bytePacket, 0, bytePacket.length); + + assertThat(icmp6.getIcmpType(), is(ICMP6.ECHO_REQUEST)); + assertThat(icmp6.getIcmpCode(), is((byte) 0x00)); + assertThat(icmp6.getChecksum(), is((short) 0x82bc)); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + ICMP6 icmp61 = new ICMP6(); + icmp61.setIcmpType(ICMP6.ECHO_REQUEST); + icmp61.setIcmpCode((byte) 0); + icmp61.setChecksum((short) 0); + + ICMP6 icmp62 = new ICMP6(); + icmp62.setIcmpType(ICMP6.ECHO_REPLY); + icmp62.setIcmpCode((byte) 0); + icmp62.setChecksum((short) 0); + + assertTrue(icmp61.equals(icmp61)); + assertFalse(icmp61.equals(icmp62)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ICMPTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ICMPTest.java new file mode 100644 index 00000000..8514aa59 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ICMPTest.java @@ -0,0 +1,70 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; + +import static org.junit.Assert.assertEquals; + +/** + * Unit tests for the ICMP class. + */ +public class ICMPTest { + + private Deserializer<ICMP> deserializer; + + private byte icmpType = ICMP.TYPE_ECHO_REQUEST; + private byte icmpCode = 4; + private short checksum = 870; + + private byte[] headerBytes; + + @Before + public void setUp() throws Exception { + deserializer = ICMP.deserializer(); + + ByteBuffer bb = ByteBuffer.allocate(ICMP.ICMP_HEADER_LENGTH); + + bb.put(icmpType); + bb.put(icmpCode); + bb.putShort(checksum); + + headerBytes = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, headerBytes); + } + + @Test + public void testDeserialize() throws Exception { + ICMP icmp = deserializer.deserialize(headerBytes, 0, headerBytes.length); + + assertEquals(icmpType, icmp.getIcmpType()); + assertEquals(icmpCode, icmp.getIcmpCode()); + assertEquals(checksum, icmp.getChecksum()); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IGMPTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IGMPTest.java new file mode 100644 index 00000000..a25f7217 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IGMPTest.java @@ -0,0 +1,96 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import static junit.framework.Assert.assertTrue; + +/** + * Unit tests for IGMP class. + */ +public class IGMPTest { + private Deserializer<IGMP> deserializer; + + private IGMP igmpQuery; + private IGMP igmpMembership; + + private Ip4Address gaddr1; + private Ip4Address gaddr2; + private Ip4Address saddr1; + private Ip4Address saddr2; + + @Before + public void setUp() throws Exception { + gaddr1 = Ip4Address.valueOf(0xe1010101); + gaddr2 = Ip4Address.valueOf(0xe2020202); + saddr1 = Ip4Address.valueOf(0x0a010101); + saddr2 = Ip4Address.valueOf(0x0b020202); + + deserializer = IGMP.deserializer(); + + // Create an IGMP Query object + igmpQuery = new IGMP(); + igmpQuery.setIgmpType(IGMP.TYPE_IGMPV3_MEMBERSHIP_QUERY); + igmpQuery.setMaxRespCode((byte) 0x7f); + IGMPQuery q = new IGMPQuery(gaddr1, (byte) 0x7f); + q.addSource(saddr1); + q.addSource(saddr2); + q.setSbit(false); + igmpQuery.groups.add(q); + + // Create an IGMP Membership Object + igmpMembership = new IGMP(); + igmpMembership.setIgmpType(IGMP.TYPE_IGMPV3_MEMBERSHIP_REPORT); + IGMPMembership g1 = new IGMPMembership(gaddr1); + g1.addSource(saddr1); + g1.addSource(saddr2); + igmpMembership.groups.add(g1); + IGMPMembership g2 = new IGMPMembership(gaddr2); + g2.addSource(saddr1); + g2.addSource(saddr2); + igmpMembership.groups.add(g2); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + byte [] bits = igmpQuery.serialize(); + PacketTestUtils.testDeserializeTruncated(deserializer, bits); + + bits = igmpMembership.serialize(); + PacketTestUtils.testDeserializeTruncated(deserializer, bits); + } + + @Test + public void testDeserializeQuery() throws Exception { + byte [] data = igmpQuery.serialize(); + IGMP igmp = deserializer.deserialize(data, 0, data.length); + assertTrue(igmp.equals(igmpQuery)); + } + + @Test + public void testDeserializeMembership() throws Exception { + byte [] data = igmpMembership.serialize(); + IGMP igmp = deserializer.deserialize(data, 0, data.length); + assertTrue(igmp.equals(igmpMembership)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IPv4Test.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IPv4Test.java new file mode 100644 index 00000000..1bacf2a2 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IPv4Test.java @@ -0,0 +1,99 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Unit tests for IPv4 class. + */ +public class IPv4Test { + + private Deserializer<IPv4> deserializer; + + private byte version = 4; + private byte headerLength = 6; + private byte diffServ = 2; + private short totalLength = 20; + private short identification = 1; + private byte flags = 1; + private short fragmentOffset = 1; + private byte ttl = 60; + private byte protocol = 4; + private short checksum = 4; + private int sourceAddress = 1; + private int destinationAddress = 2; + private byte[] options = new byte[] {0x1, 0x2, 0x3, 0x4}; + + private byte[] headerBytes; + + @Before + public void setUp() throws Exception { + deserializer = IPv4.deserializer(); + + ByteBuffer bb = ByteBuffer.allocate(headerLength * 4); + + bb.put((byte) ((version & 0xf) << 4 | headerLength & 0xf)); + bb.put(diffServ); + bb.putShort(totalLength); + bb.putShort(identification); + bb.putShort((short) ((flags & 0x7) << 13 | fragmentOffset & 0x1fff)); + bb.put(ttl); + bb.put(protocol); + bb.putShort(checksum); + bb.putInt(sourceAddress); + bb.putInt(destinationAddress); + bb.put(options); + + headerBytes = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, headerBytes); + } + + @Test + public void testDeserialize() throws Exception { + IPv4 ipv4 = deserializer.deserialize(headerBytes, 0, headerBytes.length); + + assertEquals(version, ipv4.getVersion()); + assertEquals(headerLength, ipv4.getHeaderLength()); + assertEquals(diffServ, ipv4.getDiffServ()); + assertEquals(totalLength, ipv4.getTotalLength()); + assertEquals(identification, ipv4.getIdentification()); + assertEquals(flags, ipv4.getFlags()); + assertEquals(fragmentOffset, ipv4.getFragmentOffset()); + assertEquals(ttl, ipv4.getTtl()); + assertEquals(protocol, ipv4.getProtocol()); + assertEquals(checksum, ipv4.getChecksum()); + assertEquals(sourceAddress, ipv4.getSourceAddress()); + assertEquals(destinationAddress, ipv4.getDestinationAddress()); + assertTrue(ipv4.isTruncated()); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IPv6Test.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IPv6Test.java new file mode 100644 index 00000000..720a4d20 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IPv6Test.java @@ -0,0 +1,154 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + +import java.nio.ByteBuffer; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link IPv6}. + */ +public class IPv6Test { + private static final byte[] SOURCE_ADDRESS = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce + }; + private static final byte[] DESTINATION_ADDRESS = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xe6, (byte) 0xce, (byte) 0x8f, (byte) 0xff, (byte) 0xfe, (byte) 0x54, (byte) 0x37, (byte) 0xc8 + }; + private static Data data; + private static UDP udp; + private static byte[] bytePacket; + + private Deserializer<IPv6> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + data = new Data(); + data.setData("testSerialize".getBytes()); + udp = new UDP(); + udp.setPayload(data); + + byte[] bytePayload = udp.serialize(); + byte[] byteHeader = { + (byte) 0x69, (byte) 0x31, (byte) 0x35, (byte) 0x79, + (byte) (bytePayload.length >> 8 & 0xff), (byte) (bytePayload.length & 0xff), + (byte) 0x11, (byte) 0x20, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xe6, (byte) 0xce, (byte) 0x8f, (byte) 0xff, (byte) 0xfe, (byte) 0x54, (byte) 0x37, (byte) 0xc8, + }; + bytePacket = new byte[byteHeader.length + bytePayload.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length); + } + + @Before + public void setUp() { + deserializer = IPv6.deserializer(); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + IPv6 ipv6 = new IPv6(); + ipv6.setPayload(udp); + ipv6.setVersion((byte) 6); + ipv6.setTrafficClass((byte) 0x93); + ipv6.setFlowLabel(0x13579); + ipv6.setNextHeader(IPv6.PROTOCOL_UDP); + ipv6.setHopLimit((byte) 32); + ipv6.setSourceAddress(SOURCE_ADDRESS); + ipv6.setDestinationAddress(DESTINATION_ADDRESS); + + assertArrayEquals(ipv6.serialize(), bytePacket); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + // Run the truncation test only on the IPv6 header + byte[] ipv6Header = new byte[IPv6.FIXED_HEADER_LENGTH]; + ByteBuffer.wrap(bytePacket).get(ipv6Header); + + PacketTestUtils.testDeserializeTruncated(deserializer, ipv6Header); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + IPv6 ipv6 = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(ipv6.getVersion(), is((byte) 6)); + assertThat(ipv6.getTrafficClass(), is((byte) 0x93)); + assertThat(ipv6.getFlowLabel(), is(0x13579)); + assertThat(ipv6.getNextHeader(), is(IPv6.PROTOCOL_UDP)); + assertThat(ipv6.getHopLimit(), is((byte) 32)); + assertArrayEquals(ipv6.getSourceAddress(), SOURCE_ADDRESS); + assertArrayEquals(ipv6.getDestinationAddress(), DESTINATION_ADDRESS); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + IPv6 packet1 = new IPv6(); + packet1.setPayload(udp); + packet1.setVersion((byte) 6); + packet1.setTrafficClass((byte) 0x93); + packet1.setFlowLabel(0x13579); + packet1.setNextHeader(IPv6.PROTOCOL_UDP); + packet1.setHopLimit((byte) 32); + packet1.setSourceAddress(SOURCE_ADDRESS); + packet1.setDestinationAddress(DESTINATION_ADDRESS); + + IPv6 packet2 = new IPv6(); + packet2.setPayload(udp); + packet2.setVersion((byte) 6); + packet2.setTrafficClass((byte) 0x93); + packet2.setFlowLabel(0x13579); + packet2.setNextHeader(IPv6.PROTOCOL_UDP); + packet2.setHopLimit((byte) 32); + packet2.setSourceAddress(DESTINATION_ADDRESS); + packet2.setDestinationAddress(SOURCE_ADDRESS); + + assertTrue(packet1.equals(packet1)); + assertFalse(packet1.equals(packet2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip4AddressTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip4AddressTest.java new file mode 100644 index 00000000..3bbf0009 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip4AddressTest.java @@ -0,0 +1,432 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import com.google.common.net.InetAddresses; +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.net.InetAddress; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable; + +/** + * Tests for class {@link Ip4Address}. + */ +public class Ip4AddressTest { + /** + * Tests the immutability of {@link Ip4Address}. + */ + @Test + public void testImmutable() { + assertThatClassIsImmutable(Ip4Address.class); + } + + /** + * Tests the IPv4 address version constant. + */ + @Test + public void testAddressVersion() { + assertThat(Ip4Address.VERSION, is(IpAddress.Version.INET)); + } + + /** + * Tests the length of the address in bytes (octets). + */ + @Test + public void testAddrByteLength() { + assertThat(Ip4Address.BYTE_LENGTH, is(4)); + } + + /** + * Tests the length of the address in bits. + */ + @Test + public void testAddrBitLength() { + assertThat(Ip4Address.BIT_LENGTH, is(32)); + } + + /** + * Tests returning the IP address version. + */ + @Test + public void testVersion() { + Ip4Address ipAddress; + + // IPv4 + ipAddress = Ip4Address.valueOf("0.0.0.0"); + assertThat(ipAddress.version(), is(IpAddress.Version.INET)); + } + + /** + * Tests returning an IPv4 address as a byte array. + */ + @Test + public void testAddressToOctetsIPv4() { + Ip4Address ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipAddress = Ip4Address.valueOf("1.2.3.4"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {0, 0, 0, 0}; + ipAddress = Ip4Address.valueOf("0.0.0.0"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = Ip4Address.valueOf("255.255.255.255"); + assertThat(ipAddress.toOctets(), is(value)); + } + + /** + * Tests returning an IPv4 address as an integer. + */ + @Test + public void testToInt() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.valueOf("1.2.3.4"); + assertThat(ipAddress.toInt(), is(0x01020304)); + + ipAddress = Ip4Address.valueOf("0.0.0.0"); + assertThat(ipAddress.toInt(), is(0)); + + ipAddress = Ip4Address.valueOf("255.255.255.255"); + assertThat(ipAddress.toInt(), is(-1)); + } + + /** + * Tests valueOf() converter for IPv4 integer value. + */ + @Test + public void testValueOfForIntegerIPv4() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.valueOf(0x01020304); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + ipAddress = Ip4Address.valueOf(0); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = Ip4Address.valueOf(0xffffffff); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv4 byte array. + */ + @Test + public void testValueOfByteArrayIPv4() { + Ip4Address ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipAddress = Ip4Address.valueOf(value); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + value = new byte[] {0, 0, 0, 0}; + ipAddress = Ip4Address.valueOf(value); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = Ip4Address.valueOf(value); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv4. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv4() { + Ip4Address ipAddress; + byte[] value; + + value = null; + ipAddress = Ip4Address.valueOf(value); + } + + /** + * Tests invalid valueOf() converger for an array that is too short for + * IPv4. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv4() { + Ip4Address ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3}; + ipAddress = Ip4Address.valueOf(value); + } + + /** + * Tests valueOf() converter for IPv4 byte array and an offset. + */ + @Test + public void testValueOfByteArrayOffsetIPv4() { + Ip4Address ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 1, 2, 3, 4, + 44, 55}; // Extra bytes + ipAddress = Ip4Address.valueOf(value, 3); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + value = new byte[] {11, 22, // Preamble + 0, 0, 0, 0, + 33}; // Extra bytes + ipAddress = Ip4Address.valueOf(value, 2); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + value = new byte[] {11, 22, // Preamble + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + 33}; // Extra bytes + ipAddress = Ip4Address.valueOf(value, 2); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests invalid valueOf() converger for an array and an invalid offset + * for IPv4. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfArrayInvalidOffsetIPv4() { + Ip4Address ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 1, 2, 3, 4, + 44, 55}; // Extra bytes + ipAddress = Ip4Address.valueOf(value, 6); + } + + /** + * Tests valueOf() converter for IPv4 InetAddress. + */ + @Test + public void testValueOfInetAddressIPv4() { + Ip4Address ipAddress; + InetAddress inetAddress; + + inetAddress = InetAddresses.forString("1.2.3.4"); + ipAddress = Ip4Address.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + inetAddress = InetAddresses.forString("0.0.0.0"); + ipAddress = Ip4Address.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + inetAddress = InetAddresses.forString("255.255.255.255"); + ipAddress = Ip4Address.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv4 string. + */ + @Test + public void testValueOfStringIPv4() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.valueOf("1.2.3.4"); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + ipAddress = Ip4Address.valueOf("0.0.0.0"); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = Ip4Address.valueOf("255.255.255.255"); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests invalid valueOf() converter for a null string. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullString() { + Ip4Address ipAddress; + + String fromString = null; + ipAddress = Ip4Address.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an empty string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfEmptyString() { + Ip4Address ipAddress; + + String fromString = ""; + ipAddress = Ip4Address.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an incorrect string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIncorrectString() { + Ip4Address ipAddress; + + String fromString = "NoSuchIpAddress"; + ipAddress = Ip4Address.valueOf(fromString); + } + + /** + * Tests making a mask prefix for a given prefix length for IPv4. + */ + @Test + public void testMakeMaskPrefixIPv4() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.makeMaskPrefix(25); + assertThat(ipAddress.toString(), is("255.255.255.128")); + + ipAddress = Ip4Address.makeMaskPrefix(0); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = Ip4Address.makeMaskPrefix(32); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv4: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskPrefixIPv4() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.makeMaskPrefix(-1); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv4: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskPrefixIPv4() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.makeMaskPrefix(33); + } + + /** + * Tests making of a masked address for IPv4. + */ + @Test + public void testMakeMaskedAddressIPv4() { + Ip4Address ipAddress = Ip4Address.valueOf("1.2.3.5"); + Ip4Address ipAddressMasked; + + ipAddressMasked = Ip4Address.makeMaskedAddress(ipAddress, 24); + assertThat(ipAddressMasked.toString(), is("1.2.3.0")); + + ipAddressMasked = Ip4Address.makeMaskedAddress(ipAddress, 0); + assertThat(ipAddressMasked.toString(), is("0.0.0.0")); + + ipAddressMasked = Ip4Address.makeMaskedAddress(ipAddress, 32); + assertThat(ipAddressMasked.toString(), is("1.2.3.5")); + } + + /** + * Tests making of a masked address for invalid prefix length for IPv4: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskedAddressIPv4() { + Ip4Address ipAddress = Ip4Address.valueOf("1.2.3.5"); + Ip4Address ipAddressMasked; + + ipAddressMasked = Ip4Address.makeMaskedAddress(ipAddress, -1); + } + + /** + * Tests making of a masked address for an invalid prefix length for IPv4: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskedAddressIPv4() { + Ip4Address ipAddress = Ip4Address.valueOf("1.2.3.5"); + Ip4Address ipAddressMasked; + + ipAddressMasked = Ip4Address.makeMaskedAddress(ipAddress, 33); + } + + /** + * Tests comparison of {@link Ip4Address} for IPv4. + */ + @Test + public void testComparisonIPv4() { + Ip4Address addr1, addr2, addr3, addr4; + + addr1 = Ip4Address.valueOf("1.2.3.4"); + addr2 = Ip4Address.valueOf("1.2.3.4"); + addr3 = Ip4Address.valueOf("1.2.3.3"); + addr4 = Ip4Address.valueOf("1.2.3.5"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + + addr1 = Ip4Address.valueOf("255.2.3.4"); + addr2 = Ip4Address.valueOf("255.2.3.4"); + addr3 = Ip4Address.valueOf("255.2.3.3"); + addr4 = Ip4Address.valueOf("255.2.3.5"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + } + + /** + * Tests equality of {@link Ip4Address} for IPv4. + */ + @Test + public void testEqualityIPv4() { + new EqualsTester() + .addEqualityGroup(Ip4Address.valueOf("1.2.3.4"), + Ip4Address.valueOf("1.2.3.4")) + .addEqualityGroup(Ip4Address.valueOf("1.2.3.5"), + Ip4Address.valueOf("1.2.3.5")) + .addEqualityGroup(Ip4Address.valueOf("0.0.0.0"), + Ip4Address.valueOf("0.0.0.0")) + .addEqualityGroup(Ip4Address.valueOf("255.255.255.255"), + Ip4Address.valueOf("255.255.255.255")) + .testEquals(); + } + + /** + * Tests object string representation for IPv4. + */ + @Test + public void testToStringIPv4() { + Ip4Address ipAddress; + + ipAddress = Ip4Address.valueOf("1.2.3.4"); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + ipAddress = Ip4Address.valueOf("0.0.0.0"); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = Ip4Address.valueOf("255.255.255.255"); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip4PrefixTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip4PrefixTest.java new file mode 100644 index 00000000..c731ed66 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip4PrefixTest.java @@ -0,0 +1,534 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable; + +/** + * Tests for class {@link Ip4Prefix}. + */ +public class Ip4PrefixTest { + /** + * Tests the immutability of {@link Ip4Prefix}. + */ + @Test + public void testImmutable() { + assertThatClassIsImmutable(Ip4Prefix.class); + } + + /** + * Tests the IPv4 prefix address version constant. + */ + @Test + public void testAddressVersion() { + assertThat(Ip4Prefix.VERSION, is(IpAddress.Version.INET)); + } + + /** + * Tests the maximum mask length. + */ + @Test + public void testMaxMaskLength() { + assertThat(Ip4Prefix.MAX_MASK_LENGTH, is(32)); + } + + /** + * Tests returning the IP version of the prefix. + */ + @Test + public void testVersion() { + Ip4Prefix ipPrefix; + + // IPv4 + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.version(), is(IpAddress.Version.INET)); + } + + /** + * Tests returning the IP address value and IP address prefix length of + * an IPv4 prefix. + */ + @Test + public void testAddressAndPrefixLengthIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.3.0/24"); + assertThat(ipPrefix.address(), equalTo(Ip4Address.valueOf("1.2.3.0"))); + assertThat(ipPrefix.prefixLength(), is(24)); + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/24"); + assertThat(ipPrefix.address(), equalTo(Ip4Address.valueOf("1.2.3.0"))); + assertThat(ipPrefix.prefixLength(), is(24)); + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/32"); + assertThat(ipPrefix.address(), equalTo(Ip4Address.valueOf("1.2.3.4"))); + assertThat(ipPrefix.prefixLength(), is(32)); + + ipPrefix = Ip4Prefix.valueOf("1.2.3.5/32"); + assertThat(ipPrefix.address(), equalTo(Ip4Address.valueOf("1.2.3.5"))); + assertThat(ipPrefix.prefixLength(), is(32)); + + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.address(), equalTo(Ip4Address.valueOf("0.0.0.0"))); + assertThat(ipPrefix.prefixLength(), is(0)); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/32"); + assertThat(ipPrefix.address(), + equalTo(Ip4Address.valueOf("255.255.255.255"))); + assertThat(ipPrefix.prefixLength(), is(32)); + } + + /** + * Tests valueOf() converter for IPv4 integer value. + */ + @Test + public void testValueOfForIntegerIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf(0x01020304, 24); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = Ip4Prefix.valueOf(0x01020304, 32); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + ipPrefix = Ip4Prefix.valueOf(0x01020305, 32); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + ipPrefix = Ip4Prefix.valueOf(0, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf(0, 32); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + ipPrefix = Ip4Prefix.valueOf(0xffffffff, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf(0xffffffff, 16); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = Ip4Prefix.valueOf(0xffffffff, 32); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests invalid valueOf() converter for IPv4 integer value and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIntegerNegativePrefixLengthIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf(0x01020304, -1); + } + + /** + * Tests invalid valueOf() converter for IPv4 integer value and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIntegerTooLongPrefixLengthIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf(0x01020304, 33); + } + + /** + * Tests valueOf() converter for IPv4 byte array. + */ + @Test + public void testValueOfByteArrayIPv4() { + Ip4Prefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipPrefix = Ip4Prefix.valueOf(value, 24); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = Ip4Prefix.valueOf(value, 32); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + value = new byte[] {1, 2, 3, 5}; + ipPrefix = Ip4Prefix.valueOf(value, 32); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + value = new byte[] {0, 0, 0, 0}; + ipPrefix = Ip4Prefix.valueOf(value, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf(value, 32); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipPrefix = Ip4Prefix.valueOf(value, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf(value, 16); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = Ip4Prefix.valueOf(value, 32); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv4. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv4() { + Ip4Prefix ipPrefix; + byte[] value; + + value = null; + ipPrefix = Ip4Prefix.valueOf(value, 24); + } + + /** + * Tests invalid valueOf() converter for a short array for IPv4. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv4() { + Ip4Prefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3}; + ipPrefix = Ip4Prefix.valueOf(value, 24); + } + + /** + * Tests invalid valueOf() converter for IPv4 byte array and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayNegativePrefixLengthIPv4() { + Ip4Prefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipPrefix = Ip4Prefix.valueOf(value, -1); + } + + /** + * Tests invalid valueOf() converter for IPv4 byte array and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayTooLongPrefixLengthIPv4() { + Ip4Prefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipPrefix = Ip4Prefix.valueOf(value, 33); + } + + /** + * Tests valueOf() converter for IPv4 address. + */ + @Test + public void testValueOfAddressIPv4() { + Ip4Address ipAddress; + Ip4Prefix ipPrefix; + + ipAddress = Ip4Address.valueOf("1.2.3.4"); + ipPrefix = Ip4Prefix.valueOf(ipAddress, 24); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = Ip4Prefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + ipAddress = Ip4Address.valueOf("1.2.3.5"); + ipPrefix = Ip4Prefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + ipAddress = Ip4Address.valueOf("0.0.0.0"); + ipPrefix = Ip4Prefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + ipAddress = Ip4Address.valueOf("255.255.255.255"); + ipPrefix = Ip4Prefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf(ipAddress, 16); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = Ip4Prefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests invalid valueOf() converter for a null IP address. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullAddress() { + Ip4Address ipAddress; + Ip4Prefix ipPrefix; + + ipAddress = null; + ipPrefix = Ip4Prefix.valueOf(ipAddress, 24); + } + + /** + * Tests invalid valueOf() converter for IPv4 address and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressNegativePrefixLengthIPv4() { + Ip4Address ipAddress; + Ip4Prefix ipPrefix; + + ipAddress = Ip4Address.valueOf("1.2.3.4"); + ipPrefix = Ip4Prefix.valueOf(ipAddress, -1); + } + + /** + * Tests invalid valueOf() converter for IPv4 address and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressTooLongPrefixLengthIPv4() { + Ip4Address ipAddress; + Ip4Prefix ipPrefix; + + ipAddress = Ip4Address.valueOf("1.2.3.4"); + ipPrefix = Ip4Prefix.valueOf(ipAddress, 33); + } + + /** + * Tests valueOf() converter for IPv4 string. + */ + @Test + public void testValueOfStringIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/24"); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/32"); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + ipPrefix = Ip4Prefix.valueOf("1.2.3.5/32"); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/32"); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/0"); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/16"); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/32"); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests invalid valueOf() converter for a null string. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullString() { + Ip4Prefix ipPrefix; + String fromString; + + fromString = null; + ipPrefix = Ip4Prefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an empty string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfEmptyString() { + Ip4Prefix ipPrefix; + String fromString; + + fromString = ""; + ipPrefix = Ip4Prefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an incorrect string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIncorrectString() { + Ip4Prefix ipPrefix; + String fromString; + + fromString = "NoSuchIpPrefix"; + ipPrefix = Ip4Prefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for IPv4 string and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringNegativePrefixLengthIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/-1"); + } + + /** + * Tests invalid valueOf() converter for IPv4 string and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringTooLongPrefixLengthIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/33"); + } + + /** + * Tests IP prefix contains another IP prefix for IPv4. + */ + @Test + public void testContainsIpPrefixIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.0.0/24"); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/24"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/32"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.4/32"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/16"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.3.0.0/24"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/16"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/0"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("255.255.255.255/32"))); + + ipPrefix = Ip4Prefix.valueOf("1.2.0.0/32"); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/24"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/32"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.4/32"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/16"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.3.0.0/24"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/16"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/0"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("255.255.255.255/32"))); + + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/24"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/32"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.4/32"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/16"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("1.3.0.0/24"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/16"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/0"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("255.255.255.255/32"))); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/32"); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/24"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/32"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.4/32"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.2.0.0/16"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("1.3.0.0/24"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/16"))); + assertFalse(ipPrefix.contains(Ip4Prefix.valueOf("0.0.0.0/0"))); + assertTrue(ipPrefix.contains(Ip4Prefix.valueOf("255.255.255.255/32"))); + } + + /** + * Tests IP prefix contains IP address for IPv4. + */ + @Test + public void testContainsIpAddressIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.0.0/24"); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("1.2.0.0"))); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("1.2.0.4"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("1.3.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("0.0.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("255.255.255.255"))); + + ipPrefix = Ip4Prefix.valueOf("1.2.0.0/32"); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("1.2.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("1.2.0.4"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("1.3.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("0.0.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("255.255.255.255"))); + + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("1.2.0.0"))); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("1.2.0.4"))); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("1.3.0.0"))); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("0.0.0.0"))); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("255.255.255.255"))); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/32"); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("1.2.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("1.2.0.4"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("1.3.0.0"))); + assertFalse(ipPrefix.contains(Ip4Address.valueOf("0.0.0.0"))); + assertTrue(ipPrefix.contains(Ip4Address.valueOf("255.255.255.255"))); + } + + /** + * Tests equality of {@link Ip4Prefix} for IPv4. + */ + @Test + public void testEqualityIPv4() { + new EqualsTester() + .addEqualityGroup(Ip4Prefix.valueOf("1.2.0.0/24"), + Ip4Prefix.valueOf("1.2.0.0/24"), + Ip4Prefix.valueOf("1.2.0.4/24")) + .addEqualityGroup(Ip4Prefix.valueOf("1.2.0.0/16"), + Ip4Prefix.valueOf("1.2.0.0/16")) + .addEqualityGroup(Ip4Prefix.valueOf("1.2.0.0/32"), + Ip4Prefix.valueOf("1.2.0.0/32")) + .addEqualityGroup(Ip4Prefix.valueOf("1.3.0.0/24"), + Ip4Prefix.valueOf("1.3.0.0/24")) + .addEqualityGroup(Ip4Prefix.valueOf("0.0.0.0/0"), + Ip4Prefix.valueOf("0.0.0.0/0")) + .addEqualityGroup(Ip4Prefix.valueOf("255.255.255.255/32"), + Ip4Prefix.valueOf("255.255.255.255/32")) + .testEquals(); + } + + /** + * Tests object string representation for IPv4. + */ + @Test + public void testToStringIPv4() { + Ip4Prefix ipPrefix; + + ipPrefix = Ip4Prefix.valueOf("1.2.3.0/24"); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = Ip4Prefix.valueOf("1.2.3.4/24"); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = Ip4Prefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = Ip4Prefix.valueOf("255.255.255.255/32"); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip6AddressTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip6AddressTest.java new file mode 100644 index 00000000..e7d017d1 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip6AddressTest.java @@ -0,0 +1,499 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import com.google.common.net.InetAddresses; +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import java.net.InetAddress; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable; + +/** + * Tests for class {@link Ip6Address}. + */ +public class Ip6AddressTest { + /** + * Tests the immutability of {@link Ip6Address}. + */ + @Test + public void testImmutable() { + assertThatClassIsImmutable(Ip6Address.class); + } + + /** + * Tests the IPv4 address version constant. + */ + @Test + public void testAddressVersion() { + assertThat(Ip6Address.VERSION, is(IpAddress.Version.INET6)); + } + + /** + * Tests the length of the address in bytes (octets). + */ + @Test + public void testAddrByteLength() { + assertThat(Ip6Address.BYTE_LENGTH, is(16)); + } + + /** + * Tests the length of the address in bits. + */ + @Test + public void testAddrBitLength() { + assertThat(Ip6Address.BIT_LENGTH, is(128)); + } + + /** + * Tests returning the IP address version. + */ + @Test + public void testVersion() { + IpAddress ipAddress; + + // IPv6 + ipAddress = IpAddress.valueOf("::"); + assertThat(ipAddress.version(), is(IpAddress.Version.INET6)); + } + + /** + * Tests returning an IPv6 address as a byte array. + */ + @Test + public void testAddressToOctetsIPv6() { + Ip6Address ipAddress; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88}; + ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + ipAddress = Ip6Address.valueOf("::"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + assertThat(ipAddress.toOctets(), is(value)); + } + + /** + * Tests valueOf() converter for IPv6 byte array. + */ + @Test + public void testValueOfByteArrayIPv6() { + Ip6Address ipAddress; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88}; + ipAddress = Ip6Address.valueOf(value); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + value = new byte[] {0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + ipAddress = Ip6Address.valueOf(value); + assertThat(ipAddress.toString(), is("::")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = Ip6Address.valueOf(value); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv6. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv6() { + Ip6Address ipAddress; + byte[] value; + + value = null; + ipAddress = Ip6Address.valueOf(value); + } + + /** + * Tests invalid valueOf() converger for an array that is too short for + * IPv6. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv6() { + Ip6Address ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9}; + ipAddress = Ip6Address.valueOf(value); + } + + /** + * Tests valueOf() converter for IPv6 byte array and an offset. + */ + @Test + public void testValueOfByteArrayOffsetIPv6() { + Ip6Address ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88, + 44, 55}; // Extra bytes + ipAddress = Ip6Address.valueOf(value, 3); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + value = new byte[] {11, 22, // Preamble + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 33}; // Extra bytes + ipAddress = Ip6Address.valueOf(value, 2); + assertThat(ipAddress.toString(), is("::")); + + value = new byte[] {11, 22, // Preamble + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + 33}; // Extra bytes + ipAddress = Ip6Address.valueOf(value, 2); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests invalid valueOf() converger for an array and an invalid offset + * for IPv6. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfArrayInvalidOffsetIPv6() { + Ip6Address ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88, + 44, 55}; // Extra bytes + ipAddress = Ip6Address.valueOf(value, 6); + } + + /** + * Tests valueOf() converter for IPv6 InetAddress. + */ + @Test + public void testValueOfInetAddressIPv6() { + Ip6Address ipAddress; + InetAddress inetAddress; + + inetAddress = + InetAddresses.forString("1111:2222:3333:4444:5555:6666:7777:8888"); + ipAddress = Ip6Address.valueOf(inetAddress); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + inetAddress = InetAddresses.forString("::"); + ipAddress = Ip6Address.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("::")); + + inetAddress = + InetAddresses.forString("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + ipAddress = Ip6Address.valueOf(inetAddress); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests valueOf() converter for IPv6 string. + */ + @Test + public void testValueOfStringIPv6() { + Ip6Address ipAddress; + + ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + ipAddress = Ip6Address.valueOf("::"); + assertThat(ipAddress.toString(), is("::")); + + ipAddress = + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests invalid valueOf() converter for a null string. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullString() { + Ip6Address ipAddress; + + String fromString = null; + ipAddress = Ip6Address.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an empty string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfEmptyString() { + Ip6Address ipAddress; + + String fromString = ""; + ipAddress = Ip6Address.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an incorrect string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIncorrectString() { + Ip6Address ipAddress; + + String fromString = "NoSuchIpAddress"; + ipAddress = Ip6Address.valueOf(fromString); + } + + /** + * Tests making a mask prefix for a given prefix length for IPv6. + */ + @Test + public void testMakeMaskPrefixIPv6() { + Ip6Address ipAddress; + + ipAddress = Ip6Address.makeMaskPrefix(8); + assertThat(ipAddress.toString(), is("ff00::")); + + ipAddress = Ip6Address.makeMaskPrefix(120); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00")); + + ipAddress = Ip6Address.makeMaskPrefix(0); + assertThat(ipAddress.toString(), is("::")); + + ipAddress = Ip6Address.makeMaskPrefix(128); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + + ipAddress = Ip6Address.makeMaskPrefix(64); + assertThat(ipAddress.toString(), is("ffff:ffff:ffff:ffff::")); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv6: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskPrefixIPv6() { + Ip6Address ipAddress; + + ipAddress = Ip6Address.makeMaskPrefix(-1); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv6: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskPrefixIPv6() { + Ip6Address ipAddress; + + ipAddress = Ip6Address.makeMaskPrefix(129); + } + + /** + * Tests making of a masked address for IPv6. + */ + @Test + public void testMakeMaskedAddressIPv6() { + Ip6Address ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"); + Ip6Address ipAddressMasked; + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, 8); + assertThat(ipAddressMasked.toString(), is("1100::")); + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, 120); + assertThat(ipAddressMasked.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800")); + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, 0); + assertThat(ipAddressMasked.toString(), is("::")); + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, 128); + assertThat(ipAddressMasked.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8885")); + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, 64); + assertThat(ipAddressMasked.toString(), is("1111:2222:3333:4444::")); + } + + /** + * Tests making of a masked address for invalid prefix length for IPv6: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskedAddressIPv6() { + Ip6Address ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"); + Ip6Address ipAddressMasked; + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, -1); + } + + /** + * Tests making of a masked address for an invalid prefix length for IPv6: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskedAddressIPv6() { + Ip6Address ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"); + Ip6Address ipAddressMasked; + + ipAddressMasked = Ip6Address.makeMaskedAddress(ipAddress, 129); + } + + /** + * Tests comparison of {@link Ip6Address} for IPv6. + */ + @Test + public void testComparisonIPv6() { + Ip6Address addr1, addr2, addr3, addr4; + + addr1 = Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + addr2 = Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + addr3 = Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8887"); + addr4 = Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8889"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + + addr1 = Ip6Address.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr2 = Ip6Address.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr3 = Ip6Address.valueOf("ffff:2222:3333:4444:5555:6666:7777:8887"); + addr4 = Ip6Address.valueOf("ffff:2222:3333:4444:5555:6666:7777:8889"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + + addr1 = Ip6Address.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr2 = Ip6Address.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr3 = Ip6Address.valueOf("ffff:2222:3333:4443:5555:6666:7777:8888"); + addr4 = Ip6Address.valueOf("ffff:2222:3333:4445:5555:6666:7777:8888"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + } + + /** + * Tests equality of {@link Ip6Address} for IPv6. + */ + @Test + public void testEqualityIPv6() { + new EqualsTester() + .addEqualityGroup( + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"), + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888")) + .addEqualityGroup( + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:888a"), + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:888a")) + .addEqualityGroup( + Ip6Address.valueOf("::"), + Ip6Address.valueOf("::")) + .addEqualityGroup( + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")) + .testEquals(); + } + + /** + * Tests object string representation for IPv6. + */ + @Test + public void testToStringIPv6() { + Ip6Address ipAddress; + + ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + ipAddress = Ip6Address.valueOf("1111::8888"); + assertThat(ipAddress.toString(), is("1111::8888")); + + ipAddress = Ip6Address.valueOf("1111::"); + assertThat(ipAddress.toString(), is("1111::")); + + ipAddress = Ip6Address.valueOf("::8888"); + assertThat(ipAddress.toString(), is("::8888")); + + ipAddress = Ip6Address.valueOf("::"); + assertThat(ipAddress.toString(), is("::")); + + ipAddress = + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip6PrefixTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip6PrefixTest.java new file mode 100644 index 00000000..dceeb840 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/Ip6PrefixTest.java @@ -0,0 +1,568 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable; + +/** + * Tests for class {@link Ip6Prefix}. + */ +public class Ip6PrefixTest { + /** + * Tests the immutability of {@link Ip6Prefix}. + */ + @Test + public void testImmutable() { + assertThatClassIsImmutable(Ip6Prefix.class); + } + + /** + * Tests the IPv4 prefix address version constant. + */ + @Test + public void testAddressVersion() { + assertThat(Ip6Prefix.VERSION, is(IpAddress.Version.INET6)); + } + + /** + * Tests the maximum mask length. + */ + @Test + public void testMaxMaskLength() { + assertThat(Ip6Prefix.MAX_MASK_LENGTH, is(128)); + } + + /** + * Tests returning the IP version of the prefix. + */ + @Test + public void testVersion() { + Ip6Prefix ipPrefix; + + // IPv6 + ipPrefix = Ip6Prefix.valueOf("::/0"); + assertThat(ipPrefix.version(), is(IpAddress.Version.INET6)); + } + + /** + * Tests returning the IP address value and IP address prefix length of + * an IPv6 prefix. + */ + @Test + public void testAddressAndPrefixLengthIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = Ip6Prefix.valueOf("1100::/8"); + assertThat(ipPrefix.address(), equalTo(Ip6Address.valueOf("1100::"))); + assertThat(ipPrefix.prefixLength(), is(8)); + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/8"); + assertThat(ipPrefix.address(), equalTo(Ip6Address.valueOf("1100::"))); + assertThat(ipPrefix.prefixLength(), is(8)); + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8800/120"); + assertThat(ipPrefix.address(), + equalTo(Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8800"))); + assertThat(ipPrefix.prefixLength(), is(120)); + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/128"); + assertThat(ipPrefix.address(), + equalTo(Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"))); + assertThat(ipPrefix.prefixLength(), is(128)); + + ipPrefix = Ip6Prefix.valueOf("::/0"); + assertThat(ipPrefix.address(), equalTo(Ip6Address.valueOf("::"))); + assertThat(ipPrefix.prefixLength(), is(0)); + + ipPrefix = + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertThat(ipPrefix.address(), + equalTo(Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + assertThat(ipPrefix.prefixLength(), is(128)); + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/64"); + assertThat(ipPrefix.address(), + equalTo(Ip6Address.valueOf("1111:2222:3333:4444::"))); + assertThat(ipPrefix.prefixLength(), is(64)); + } + + /** + * Tests valueOf() converter for IPv6 byte array. + */ + @Test + public void testValueOfByteArrayIPv6() { + Ip6Prefix ipPrefix; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, (byte) 0x88, (byte) 0x88}; + ipPrefix = Ip6Prefix.valueOf(value, 120); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800/120")); + + ipPrefix = Ip6Prefix.valueOf(value, 128); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888/128")); + + value = new byte[] {0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + ipPrefix = Ip6Prefix.valueOf(value, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = Ip6Prefix.valueOf(value, 128); + assertThat(ipPrefix.toString(), is("::/128")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipPrefix = Ip6Prefix.valueOf(value, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = Ip6Prefix.valueOf(value, 64); + assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64")); + + ipPrefix = Ip6Prefix.valueOf(value, 128); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv6. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv6() { + Ip6Prefix ipPrefix; + byte[] value; + + value = null; + ipPrefix = Ip6Prefix.valueOf(value, 120); + } + + /** + * Tests invalid valueOf() converter for a short array for IPv6. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv6() { + Ip6Prefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9}; + ipPrefix = Ip6Prefix.valueOf(value, 120); + } + + /** + * Tests invalid valueOf() converter for IPv6 byte array and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayNegativePrefixLengthIPv6() { + Ip6Prefix ipPrefix; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, (byte) 0x88, (byte) 0x88}; + ipPrefix = Ip6Prefix.valueOf(value, -1); + } + + /** + * Tests invalid valueOf() converter for IPv6 byte array and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayTooLongPrefixLengthIPv6() { + Ip6Prefix ipPrefix; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, (byte) 0x88, (byte) 0x88}; + ipPrefix = Ip6Prefix.valueOf(value, 129); + } + + /** + * Tests valueOf() converter for IPv6 address. + */ + @Test + public void testValueOfAddressIPv6() { + Ip6Address ipAddress; + Ip6Prefix ipPrefix; + + ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + ipPrefix = Ip6Prefix.valueOf(ipAddress, 120); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800/120")); + + ipPrefix = Ip6Prefix.valueOf(ipAddress, 128); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888/128")); + + ipAddress = Ip6Address.valueOf("::"); + ipPrefix = Ip6Prefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = Ip6Prefix.valueOf(ipAddress, 128); + assertThat(ipPrefix.toString(), is("::/128")); + + ipAddress = + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + ipPrefix = Ip6Prefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = Ip6Prefix.valueOf(ipAddress, 64); + assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64")); + + ipPrefix = Ip6Prefix.valueOf(ipAddress, 128); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } + + /** + * Tests invalid valueOf() converter for a null IP address. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullAddress() { + Ip6Address ipAddress; + Ip6Prefix ipPrefix; + + ipAddress = null; + ipPrefix = Ip6Prefix.valueOf(ipAddress, 24); + } + + /** + * Tests invalid valueOf() converter for IPv6 address and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressNegativePrefixLengthIPv6() { + Ip6Address ipAddress; + Ip6Prefix ipPrefix; + + ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + ipPrefix = Ip6Prefix.valueOf(ipAddress, -1); + } + + /** + * Tests invalid valueOf() converter for IPv6 address and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressTooLongPrefixLengthIPv6() { + Ip6Address ipAddress; + Ip6Prefix ipPrefix; + + ipAddress = + Ip6Address.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + ipPrefix = Ip6Prefix.valueOf(ipAddress, 129); + } + + /** + * Tests valueOf() converter for IPv6 string. + */ + @Test + public void testValueOfStringIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/120"); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800/120")); + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/128"); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888/128")); + + ipPrefix = Ip6Prefix.valueOf("::/0"); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = Ip6Prefix.valueOf("::/128"); + assertThat(ipPrefix.toString(), is("::/128")); + + ipPrefix = + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/0"); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64"); + assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64")); + + ipPrefix = + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } + + /** + * Tests invalid valueOf() converter for a null string. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullString() { + Ip6Prefix ipPrefix; + String fromString; + + fromString = null; + ipPrefix = Ip6Prefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an empty string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfEmptyString() { + Ip6Prefix ipPrefix; + String fromString; + + fromString = ""; + ipPrefix = Ip6Prefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an incorrect string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIncorrectString() { + Ip6Prefix ipPrefix; + String fromString; + + fromString = "NoSuchIpPrefix"; + ipPrefix = Ip6Prefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for IPv6 string and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringNegativePrefixLengthIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/-1"); + } + + /** + * Tests invalid valueOf() converter for IPv6 string and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringTooLongPrefixLengthIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = + Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/129"); + } + + /** + * Tests IP prefix contains another IP prefix for IPv6. + */ + @Test + public void testContainsIpPrefixIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = Ip6Prefix.valueOf("1111:2222:3333:4444::/120"); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/120"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/128"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::1/128"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/64"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4445::/120"))); + assertFalse(ipPrefix.contains(Ip6Prefix.valueOf("::/64"))); + assertFalse(ipPrefix.contains(Ip6Prefix.valueOf("::/0"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + ipPrefix = Ip6Prefix.valueOf("1111:2222:3333:4444::/128"); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/120"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/128"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::1/128"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/64"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4445::/120"))); + assertFalse(ipPrefix.contains(Ip6Prefix.valueOf("::/64"))); + assertFalse(ipPrefix.contains(Ip6Prefix.valueOf("::/0"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + ipPrefix = Ip6Prefix.valueOf("::/0"); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/120"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/128"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::1/128"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/64"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4445::/120"))); + assertTrue(ipPrefix.contains(Ip6Prefix.valueOf("::/64"))); + assertTrue(ipPrefix.contains(Ip6Prefix.valueOf("::/0"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + ipPrefix = + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/120"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/128"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::1/128"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4444::/64"))); + assertFalse(ipPrefix.contains( + Ip6Prefix.valueOf("1111:2222:3333:4445::/120"))); + assertFalse(ipPrefix.contains(Ip6Prefix.valueOf("::/64"))); + assertFalse(ipPrefix.contains(Ip6Prefix.valueOf("::/0"))); + assertTrue(ipPrefix.contains( + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + } + + /** + * Tests IP prefix contains IP address for IPv6. + */ + @Test + public void testContainsIpAddressIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = Ip6Prefix.valueOf("1111:2222:3333:4444::/120"); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::"))); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::1"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4445::"))); + assertFalse(ipPrefix.contains(Ip6Address.valueOf("::"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + ipPrefix = Ip6Prefix.valueOf("1111:2222:3333:4444::/128"); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::1"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4445::"))); + assertFalse(ipPrefix.contains(Ip6Address.valueOf("::"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + ipPrefix = Ip6Prefix.valueOf("::/0"); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::"))); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::1"))); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4445::"))); + assertTrue(ipPrefix.contains(Ip6Address.valueOf("::"))); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + ipPrefix = + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4444::1"))); + assertFalse(ipPrefix.contains( + Ip6Address.valueOf("1111:2222:3333:4445::"))); + assertFalse(ipPrefix.contains(Ip6Address.valueOf("::"))); + assertTrue(ipPrefix.contains( + Ip6Address.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + } + + /** + * Tests equality of {@link Ip6Prefix} for IPv6. + */ + @Test + public void testEqualityIPv6() { + new EqualsTester() + .addEqualityGroup( + Ip6Prefix.valueOf("1111:2222:3333:4444::/120"), + Ip6Prefix.valueOf("1111:2222:3333:4444::1/120"), + Ip6Prefix.valueOf("1111:2222:3333:4444::/120")) + .addEqualityGroup( + Ip6Prefix.valueOf("1111:2222:3333:4444::/64"), + Ip6Prefix.valueOf("1111:2222:3333:4444::/64")) + .addEqualityGroup( + Ip6Prefix.valueOf("1111:2222:3333:4444::/128"), + Ip6Prefix.valueOf("1111:2222:3333:4444::/128")) + .addEqualityGroup( + Ip6Prefix.valueOf("1111:2222:3333:4445::/64"), + Ip6Prefix.valueOf("1111:2222:3333:4445::/64")) + .addEqualityGroup( + Ip6Prefix.valueOf("::/0"), + Ip6Prefix.valueOf("::/0")) + .addEqualityGroup( + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"), + Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")) + .testEquals(); + } + + /** + * Tests object string representation for IPv6. + */ + @Test + public void testToStringIPv6() { + Ip6Prefix ipPrefix; + + ipPrefix = Ip6Prefix.valueOf("1100::/8"); + assertThat(ipPrefix.toString(), is("1100::/8")); + + ipPrefix = Ip6Prefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/8"); + assertThat(ipPrefix.toString(), is("1100::/8")); + + ipPrefix = Ip6Prefix.valueOf("::/0"); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = Ip6Prefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IpAddressTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IpAddressTest.java new file mode 100644 index 00000000..8618c466 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IpAddressTest.java @@ -0,0 +1,946 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import java.net.InetAddress; + +import org.junit.Test; + +import com.google.common.net.InetAddresses; +import com.google.common.testing.EqualsTester; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutableBaseClass; + +/** + * Tests for class {@link IpAddress}. + */ +public class IpAddressTest { + /** + * Tests the immutability of {@link IpAddress}. + */ + @Test + public void testImmutable() { + assertThatClassIsImmutableBaseClass(IpAddress.class); + } + + /** + * Tests the length of the address in bytes (octets). + */ + @Test + public void testAddrByteLength() { + assertThat(IpAddress.INET_BYTE_LENGTH, is(4)); + assertThat(IpAddress.INET6_BYTE_LENGTH, is(16)); + assertThat(IpAddress.byteLength(IpAddress.Version.INET), is(4)); + assertThat(IpAddress.byteLength(IpAddress.Version.INET6), is(16)); + } + + /** + * Tests the length of the address in bits. + */ + @Test + public void testAddrBitLength() { + assertThat(IpAddress.INET_BIT_LENGTH, is(32)); + assertThat(IpAddress.INET6_BIT_LENGTH, is(128)); + } + + /** + * Tests returning the IP address version. + */ + @Test + public void testVersion() { + IpAddress ipAddress; + + // IPv4 + ipAddress = IpAddress.valueOf("0.0.0.0"); + assertThat(ipAddress.version(), is(IpAddress.Version.INET)); + + // IPv6 + ipAddress = IpAddress.valueOf("::"); + assertThat(ipAddress.version(), is(IpAddress.Version.INET6)); + } + + /** + * Tests whether the IP version of an address is IPv4. + */ + @Test + public void testIsIp4() { + IpAddress ipAddress; + + // IPv4 + ipAddress = IpAddress.valueOf("0.0.0.0"); + assertTrue(ipAddress.isIp4()); + + // IPv6 + ipAddress = IpAddress.valueOf("::"); + assertFalse(ipAddress.isIp4()); + } + + /** + * Tests whether the IP version of an address is IPv6. + */ + @Test + public void testIsIp6() { + IpAddress ipAddress; + + // IPv4 + ipAddress = IpAddress.valueOf("0.0.0.0"); + assertFalse(ipAddress.isIp6()); + + // IPv6 + ipAddress = IpAddress.valueOf("::"); + assertTrue(ipAddress.isIp6()); + } + + /** + * Tests getting the Ip4Address and Ip6Address view of the IP address. + */ + @Test + public void testGetIp4AndIp6AddressView() { + IpAddress ipAddress; + Ip4Address ip4Address; + Ip6Address ip6Address; + + // Pure IPv4 IpAddress + ipAddress = IpAddress.valueOf("1.2.3.4"); + ip4Address = ipAddress.getIp4Address(); + ip6Address = ipAddress.getIp6Address(); + assertThat(ip4Address.toString(), is("1.2.3.4")); + assertNull(ip6Address); + + // IPv4 IpAddress that is Ip4Address + ipAddress = Ip4Address.valueOf("1.2.3.4"); + ip4Address = ipAddress.getIp4Address(); + ip6Address = ipAddress.getIp6Address(); + assertThat(ip4Address.toString(), is("1.2.3.4")); + assertNull(ip6Address); + + // Pure IPv6 IpAddress + ipAddress = IpAddress.valueOf("1111:2222::"); + ip4Address = ipAddress.getIp4Address(); + ip6Address = ipAddress.getIp6Address(); + assertNull(ip4Address); + assertThat(ip6Address.toString(), is("1111:2222::")); + + // IPv6 IpAddress that is Ip6Address + ipAddress = Ip6Address.valueOf("1111:2222::"); + ip4Address = ipAddress.getIp4Address(); + ip6Address = ipAddress.getIp6Address(); + assertNull(ip4Address); + assertThat(ip6Address.toString(), is("1111:2222::")); + } + + /** + * Tests returning an IPv4 address as a byte array. + */ + @Test + public void testAddressToOctetsIPv4() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipAddress = IpAddress.valueOf("1.2.3.4"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {0, 0, 0, 0}; + ipAddress = IpAddress.valueOf("0.0.0.0"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = IpAddress.valueOf("255.255.255.255"); + assertThat(ipAddress.toOctets(), is(value)); + } + + /** + * Tests returning an IPv6 address as a byte array. + */ + @Test + public void testAddressToOctetsIPv6() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88}; + ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + ipAddress = IpAddress.valueOf("::"); + assertThat(ipAddress.toOctets(), is(value)); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + assertThat(ipAddress.toOctets(), is(value)); + } + + /** + * Tests valueOf() converter for IPv4 integer value. + */ + @Test + public void testValueOfForIntegerIPv4() { + IpAddress ipAddress; + + ipAddress = IpAddress.valueOf(0x01020304); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + ipAddress = IpAddress.valueOf(0); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = IpAddress.valueOf(0xffffffff); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv4 byte array. + */ + @Test + public void testValueOfByteArrayIPv4() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + value = new byte[] {0, 0, 0, 0}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv6 byte array. + */ + @Test + public void testValueOfByteArrayIPv6() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + value = new byte[] {0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value); + assertThat(ipAddress.toString(), is("::")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv4. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv4() { + IpAddress ipAddress; + byte[] value; + + value = null; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv6. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv6() { + IpAddress ipAddress; + byte[] value; + + value = null; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value); + } + + /** + * Tests invalid valueOf() converger for an array that is too short for + * IPv4. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv4() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value); + } + + /** + * Tests invalid valueOf() converger for an array that is too short for + * IPv6. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv6() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9}; + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value); + } + + /** + * Tests valueOf() converter for IPv4 byte array and an offset. + */ + @Test + public void testValueOfByteArrayOffsetIPv4() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 1, 2, 3, 4, + 44, 55}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value, 3); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + value = new byte[] {11, 22, // Preamble + 0, 0, 0, 0, + 33}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value, 2); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + value = new byte[] {11, 22, // Preamble + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + 33}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value, 2); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv6 byte array and an offset. + */ + @Test + public void testValueOfByteArrayOffsetIPv6() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88, + 44, 55}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value, 3); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + value = new byte[] {11, 22, // Preamble + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 33}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value, 2); + assertThat(ipAddress.toString(), is("::")); + + value = new byte[] {11, 22, // Preamble + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + 33}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value, 2); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests invalid valueOf() converger for an array and an invalid offset + * for IPv4. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfArrayInvalidOffsetIPv4() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 1, 2, 3, 4, + 44, 55}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET, value, 6); + } + + /** + * Tests invalid valueOf() converger for an array and an invalid offset + * for IPv6. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfArrayInvalidOffsetIPv6() { + IpAddress ipAddress; + byte[] value; + + value = new byte[] {11, 22, 33, // Preamble + 0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, + (byte) 0x88, (byte) 0x88, + 44, 55}; // Extra bytes + ipAddress = IpAddress.valueOf(IpAddress.Version.INET6, value, 6); + } + + /** + * Tests valueOf() converter for IPv4 InetAddress. + */ + @Test + public void testValueOfInetAddressIPv4() { + IpAddress ipAddress; + InetAddress inetAddress; + + inetAddress = InetAddresses.forString("1.2.3.4"); + ipAddress = IpAddress.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + inetAddress = InetAddresses.forString("0.0.0.0"); + ipAddress = IpAddress.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + inetAddress = InetAddresses.forString("255.255.255.255"); + ipAddress = IpAddress.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv6 InetAddress. + */ + @Test + public void testValueOfInetAddressIPv6() { + IpAddress ipAddress; + InetAddress inetAddress; + + inetAddress = + InetAddresses.forString("1111:2222:3333:4444:5555:6666:7777:8888"); + ipAddress = IpAddress.valueOf(inetAddress); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + inetAddress = InetAddresses.forString("::"); + ipAddress = IpAddress.valueOf(inetAddress); + assertThat(ipAddress.toString(), is("::")); + + inetAddress = + InetAddresses.forString("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + ipAddress = IpAddress.valueOf(inetAddress); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests valueOf() converter for IPv4 string. + */ + @Test + public void testValueOfStringIPv4() { + IpAddress ipAddress; + + ipAddress = IpAddress.valueOf("1.2.3.4"); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + ipAddress = IpAddress.valueOf("0.0.0.0"); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = IpAddress.valueOf("255.255.255.255"); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests valueOf() converter for IPv6 string. + */ + @Test + public void testValueOfStringIPv6() { + IpAddress ipAddress; + + ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + ipAddress = IpAddress.valueOf("::"); + assertThat(ipAddress.toString(), is("::")); + + ipAddress = + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + } + + /** + * Tests invalid valueOf() converter for a null string. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullString() { + IpAddress ipAddress; + + String fromString = null; + ipAddress = IpAddress.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an empty string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfEmptyString() { + IpAddress ipAddress; + + String fromString = ""; + ipAddress = IpAddress.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an incorrect string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIncorrectString() { + IpAddress ipAddress; + + String fromString = "NoSuchIpAddress"; + ipAddress = IpAddress.valueOf(fromString); + } + + /** + * Tests making a mask prefix for a given prefix length for IPv4. + */ + @Test + public void testMakeMaskPrefixIPv4() { + IpAddress ipAddress; + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET, 25); + assertThat(ipAddress.toString(), is("255.255.255.128")); + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET, 0); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET, 32); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests making a mask prefix for a given prefix length for IPv6. + */ + @Test + public void testMakeMaskPrefixIPv6() { + IpAddress ipAddress; + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, 8); + assertThat(ipAddress.toString(), is("ff00::")); + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, 120); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00")); + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, 0); + assertThat(ipAddress.toString(), is("::")); + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, 128); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, 64); + assertThat(ipAddress.toString(), is("ffff:ffff:ffff:ffff::")); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv4: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskPrefixIPv4() { + IpAddress ipAddress; + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET, -1); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv6: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskPrefixIPv6() { + IpAddress ipAddress; + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, -1); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv4: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskPrefixIPv4() { + IpAddress ipAddress; + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET, 33); + } + + /** + * Tests making a mask prefix for an invalid prefix length for IPv6: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskPrefixIPv6() { + IpAddress ipAddress; + + ipAddress = IpAddress.makeMaskPrefix(IpAddress.Version.INET6, 129); + } + + /** + * Tests making of a masked address for IPv4. + */ + @Test + public void testMakeMaskedAddressIPv4() { + IpAddress ipAddress = IpAddress.valueOf("1.2.3.5"); + IpAddress ipAddressMasked; + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 24); + assertThat(ipAddressMasked.toString(), is("1.2.3.0")); + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 0); + assertThat(ipAddressMasked.toString(), is("0.0.0.0")); + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 32); + assertThat(ipAddressMasked.toString(), is("1.2.3.5")); + } + + /** + * Tests making of a masked address for IPv6. + */ + @Test + public void testMakeMaskedAddressIPv6() { + IpAddress ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"); + IpAddress ipAddressMasked; + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 8); + assertThat(ipAddressMasked.toString(), is("1100::")); + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 120); + assertThat(ipAddressMasked.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800")); + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 0); + assertThat(ipAddressMasked.toString(), is("::")); + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 128); + assertThat(ipAddressMasked.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8885")); + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 64); + assertThat(ipAddressMasked.toString(), is("1111:2222:3333:4444::")); + } + + /** + * Tests making of a masked address for invalid prefix length for IPv4: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskedAddressIPv4() { + IpAddress ipAddress = IpAddress.valueOf("1.2.3.5"); + IpAddress ipAddressMasked; + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, -1); + } + + /** + * Tests making of a masked address for invalid prefix length for IPv6: + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeNegativeMaskedAddressIPv6() { + IpAddress ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"); + IpAddress ipAddressMasked; + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, -1); + } + + /** + * Tests making of a masked address for an invalid prefix length for IPv4: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskedAddressIPv4() { + IpAddress ipAddress = IpAddress.valueOf("1.2.3.5"); + IpAddress ipAddressMasked; + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 33); + } + + /** + * Tests making of a masked address for an invalid prefix length for IPv6: + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidMakeTooLongMaskedAddressIPv6() { + IpAddress ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"); + IpAddress ipAddressMasked; + + ipAddressMasked = IpAddress.makeMaskedAddress(ipAddress, 129); + } + + /** + * Tests if address is zero for IPv4. + */ + @Test + public void testIsZeroIPv4() { + IpAddress normalIP = IpAddress.valueOf("10.0.0.1"); + IpAddress zeroIP = IpAddress.valueOf("0.0.0.0"); + assertFalse(normalIP.isZero()); + assertTrue(zeroIP.isZero()); + } + + /** + * Tests if address is zero for IPv6. + */ + @Test + public void testIsZeroIPv6() { + IpAddress normalIP = IpAddress.valueOf("fe80::1"); + IpAddress zeroIP = IpAddress.valueOf("::"); + assertFalse(normalIP.isZero()); + assertTrue(zeroIP.isZero()); + } + + /** + * Tests if address is self-assigned for IPv4. + */ + @Test + public void testIsSelfAssignedIpv4() { + IpAddress normalIP = IpAddress.valueOf("10.0.0.1"); + IpAddress selfAssignedIP = IpAddress.valueOf("169.1.2.3"); + assertFalse(normalIP.isSelfAssigned()); + assertTrue(selfAssignedIP.isSelfAssigned()); + } + + /** + * Tests comparison of {@link IpAddress} for IPv4. + */ + @Test + public void testComparisonIPv4() { + IpAddress addr1, addr2, addr3, addr4; + + addr1 = IpAddress.valueOf("1.2.3.4"); + addr2 = IpAddress.valueOf("1.2.3.4"); + addr3 = IpAddress.valueOf("1.2.3.3"); + addr4 = IpAddress.valueOf("1.2.3.5"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + + addr1 = IpAddress.valueOf("255.2.3.4"); + addr2 = IpAddress.valueOf("255.2.3.4"); + addr3 = IpAddress.valueOf("255.2.3.3"); + addr4 = IpAddress.valueOf("255.2.3.5"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + } + + /** + * Tests comparison of {@link IpAddress} for IPv6. + */ + @Test + public void testComparisonIPv6() { + IpAddress addr1, addr2, addr3, addr4; + + addr1 = IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + addr2 = IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + addr3 = IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8887"); + addr4 = IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8889"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + + addr1 = IpAddress.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr2 = IpAddress.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr3 = IpAddress.valueOf("ffff:2222:3333:4444:5555:6666:7777:8887"); + addr4 = IpAddress.valueOf("ffff:2222:3333:4444:5555:6666:7777:8889"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + + addr1 = IpAddress.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr2 = IpAddress.valueOf("ffff:2222:3333:4444:5555:6666:7777:8888"); + addr3 = IpAddress.valueOf("ffff:2222:3333:4443:5555:6666:7777:8888"); + addr4 = IpAddress.valueOf("ffff:2222:3333:4445:5555:6666:7777:8888"); + assertTrue(addr1.compareTo(addr2) == 0); + assertTrue(addr1.compareTo(addr3) > 0); + assertTrue(addr1.compareTo(addr4) < 0); + } + + /** + * Tests equality of {@link IpAddress} for IPv4. + */ + @Test + public void testEqualityIPv4() { + new EqualsTester() + .addEqualityGroup(IpAddress.valueOf("1.2.3.4"), + IpAddress.valueOf("1.2.3.4")) + .addEqualityGroup(IpAddress.valueOf("1.2.3.5"), + IpAddress.valueOf("1.2.3.5")) + .addEqualityGroup(IpAddress.valueOf("0.0.0.0"), + IpAddress.valueOf("0.0.0.0")) + .addEqualityGroup(IpAddress.valueOf("255.255.255.255"), + IpAddress.valueOf("255.255.255.255")) + .testEquals(); + } + + /** + * Tests equality of {@link IpAddress} for IPv6. + */ + @Test + public void testEqualityIPv6() { + new EqualsTester() + .addEqualityGroup( + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"), + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888")) + .addEqualityGroup( + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:888a"), + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:888a")) + .addEqualityGroup( + IpAddress.valueOf("::"), + IpAddress.valueOf("::")) + .addEqualityGroup( + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")) + .testEquals(); + } + + /** + * Tests object string representation for IPv4. + */ + @Test + public void testToStringIPv4() { + IpAddress ipAddress; + + ipAddress = IpAddress.valueOf("1.2.3.4"); + assertThat(ipAddress.toString(), is("1.2.3.4")); + + ipAddress = IpAddress.valueOf("0.0.0.0"); + assertThat(ipAddress.toString(), is("0.0.0.0")); + + ipAddress = IpAddress.valueOf("255.255.255.255"); + assertThat(ipAddress.toString(), is("255.255.255.255")); + } + + /** + * Tests object string representation for IPv6. + */ + @Test + public void testToStringIPv6() { + IpAddress ipAddress; + + ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + assertThat(ipAddress.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888")); + + ipAddress = IpAddress.valueOf("1111::8888"); + assertThat(ipAddress.toString(), is("1111::8888")); + + ipAddress = IpAddress.valueOf("1111::"); + assertThat(ipAddress.toString(), is("1111::")); + + ipAddress = IpAddress.valueOf("::8888"); + assertThat(ipAddress.toString(), is("::8888")); + + ipAddress = IpAddress.valueOf("::"); + assertThat(ipAddress.toString(), is("::")); + + ipAddress = + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + assertThat(ipAddress.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")); + + ipAddress = + IpAddress.valueOf("::1111:2222"); + assertThat(ipAddress.toString(), + is("::1111:2222")); + + ipAddress = + IpAddress.valueOf("1:0:0:1:0:0:2:3"); + assertThat(ipAddress.toString(), + is("1::1:0:0:2:3")); + + ipAddress = + IpAddress.valueOf("::0123:0004"); + assertThat(ipAddress.toString(), + is("::123:4")); + + ipAddress = + IpAddress.valueOf("0:0:1:1:0:0:1:1"); + assertThat(ipAddress.toString(), + is("::1:1:0:0:1:1")); + + ipAddress = + IpAddress.valueOf("1:1a2b::"); + assertThat(ipAddress.toString(), + is("1:1a2b::")); + + ipAddress = + IpAddress.valueOf("0:0:00:00:0000:00:00:000"); + assertThat(ipAddress.toString(), + is("::")); + + ipAddress = + IpAddress.valueOf("0:0:0:1:0:0:0:0"); + assertThat(ipAddress.toString(), + is("0:0:0:1::")); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IpPrefixTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IpPrefixTest.java new file mode 100644 index 00000000..052a4cbb --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/IpPrefixTest.java @@ -0,0 +1,1080 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import org.junit.Test; + +import com.google.common.testing.EqualsTester; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutableBaseClass; + +/** + * Tests for class {@link IpPrefix}. + */ +public class IpPrefixTest { + /** + * Tests the immutability of {@link IpPrefix}. + */ + @Test + public void testImmutable() { + assertThatClassIsImmutableBaseClass(IpPrefix.class); + } + + /** + * Tests the maximum mask length. + */ + @Test + public void testMaxMaskLength() { + assertThat(IpPrefix.MAX_INET_MASK_LENGTH, is(32)); + assertThat(IpPrefix.MAX_INET6_MASK_LENGTH, is(128)); + } + + /** + * Tests returning the IP version of the prefix. + */ + @Test + public void testVersion() { + IpPrefix ipPrefix; + + // IPv4 + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.version(), is(IpAddress.Version.INET)); + + // IPv6 + ipPrefix = IpPrefix.valueOf("::/0"); + assertThat(ipPrefix.version(), is(IpAddress.Version.INET6)); + } + + /** + * Tests whether the IP version of a prefix is IPv4. + */ + @Test + public void testIsIp4() { + IpPrefix ipPrefix; + + // IPv4 + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertTrue(ipPrefix.isIp4()); + + // IPv6 + ipPrefix = IpPrefix.valueOf("::/0"); + assertFalse(ipPrefix.isIp4()); + } + + /** + * Tests whether the IP version of a prefix is IPv6. + */ + @Test + public void testIsIp6() { + IpPrefix ipPrefix; + + // IPv4 + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertFalse(ipPrefix.isIp6()); + + // IPv6 + ipPrefix = IpPrefix.valueOf("::/0"); + assertTrue(ipPrefix.isIp6()); + } + + /** + * Tests returning the IP address value and IP address prefix length of + * an IPv4 prefix. + */ + @Test + public void testAddressAndPrefixLengthIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.3.0/24"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.0"))); + assertThat(ipPrefix.prefixLength(), is(24)); + + ipPrefix = IpPrefix.valueOf("1.2.3.4/24"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.0"))); + assertThat(ipPrefix.prefixLength(), is(24)); + + ipPrefix = IpPrefix.valueOf("1.2.3.4/32"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.4"))); + assertThat(ipPrefix.prefixLength(), is(32)); + + ipPrefix = IpPrefix.valueOf("1.2.3.5/32"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1.2.3.5"))); + assertThat(ipPrefix.prefixLength(), is(32)); + + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("0.0.0.0"))); + assertThat(ipPrefix.prefixLength(), is(0)); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertThat(ipPrefix.address(), + equalTo(IpAddress.valueOf("255.255.255.255"))); + assertThat(ipPrefix.prefixLength(), is(32)); + } + + /** + * Tests returning the IP address value and IP address prefix length of + * an IPv6 prefix. + */ + @Test + public void testAddressAndPrefixLengthIPv6() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1100::/8"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1100::"))); + assertThat(ipPrefix.prefixLength(), is(8)); + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/8"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("1100::"))); + assertThat(ipPrefix.prefixLength(), is(8)); + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8800/120"); + assertThat(ipPrefix.address(), + equalTo(IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8800"))); + assertThat(ipPrefix.prefixLength(), is(120)); + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/128"); + assertThat(ipPrefix.address(), + equalTo(IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8885"))); + assertThat(ipPrefix.prefixLength(), is(128)); + + ipPrefix = IpPrefix.valueOf("::/0"); + assertThat(ipPrefix.address(), equalTo(IpAddress.valueOf("::"))); + assertThat(ipPrefix.prefixLength(), is(0)); + + ipPrefix = + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertThat(ipPrefix.address(), + equalTo(IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + assertThat(ipPrefix.prefixLength(), is(128)); + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/64"); + assertThat(ipPrefix.address(), + equalTo(IpAddress.valueOf("1111:2222:3333:4444::"))); + assertThat(ipPrefix.prefixLength(), is(64)); + } + + /** + * Tests getting the Ip4Prefix and Ip6Prefix view of the IP prefix. + */ + @Test + public void testGetIp4AndIp6PrefixView() { + IpPrefix ipPrefix; + Ip4Prefix ip4Prefix; + Ip6Prefix ip6Prefix; + + // Pure IPv4 IpPrefix + ipPrefix = IpPrefix.valueOf("1.2.3.0/24"); + ip4Prefix = ipPrefix.getIp4Prefix(); + ip6Prefix = ipPrefix.getIp6Prefix(); + assertThat(ip4Prefix.toString(), is("1.2.3.0/24")); + assertNull(ip6Prefix); + + // IPv4 IpPrefix that is Ip4Prefix + ipPrefix = Ip4Prefix.valueOf("1.2.3.0/24"); + ip4Prefix = ipPrefix.getIp4Prefix(); + ip6Prefix = ipPrefix.getIp6Prefix(); + assertThat(ip4Prefix.toString(), is("1.2.3.0/24")); + assertNull(ip6Prefix); + + // Pure IPv6 IpPrefix + ipPrefix = IpPrefix.valueOf("1111:2222::/64"); + ip4Prefix = ipPrefix.getIp4Prefix(); + ip6Prefix = ipPrefix.getIp6Prefix(); + assertNull(ip4Prefix); + assertThat(ip6Prefix.toString(), is("1111:2222::/64")); + + // IPv6 IpPrefix that is Ip6Prefix + ipPrefix = Ip6Prefix.valueOf("1111:2222::/64"); + ip4Prefix = ipPrefix.getIp4Prefix(); + ip6Prefix = ipPrefix.getIp6Prefix(); + assertNull(ip4Prefix); + assertThat(ip6Prefix.toString(), is("1111:2222::/64")); + } + + /** + * Tests valueOf() converter for IPv4 integer value. + */ + @Test + public void testValueOfForIntegerIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf(0x01020304, 24); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = IpPrefix.valueOf(0x01020304, 32); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + ipPrefix = IpPrefix.valueOf(0x01020305, 32); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + ipPrefix = IpPrefix.valueOf(0, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf(0, 32); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + ipPrefix = IpPrefix.valueOf(0xffffffff, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf(0xffffffff, 16); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = IpPrefix.valueOf(0xffffffff, 32); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests invalid valueOf() converter for IPv4 integer value and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIntegerNegativePrefixLengthIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf(0x01020304, -1); + } + + /** + * Tests invalid valueOf() converter for IPv4 integer value and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIntegerTooLongPrefixLengthIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf(0x01020304, 33); + } + + /** + * Tests valueOf() converter for IPv4 byte array. + */ + @Test + public void testValueOfByteArrayIPv4() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 24); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + value = new byte[] {1, 2, 3, 5}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + value = new byte[] {0, 0, 0, 0}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 16); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 32); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests valueOf() converter for IPv6 byte array. + */ + @Test + public void testValueOfByteArrayIPv6() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, (byte) 0x88, (byte) 0x88}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 120); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800/120")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 128); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888/128")); + + value = new byte[] {0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 128); + assertThat(ipPrefix.toString(), is("::/128")); + + value = new byte[] {(byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff, + (byte) 0xff, (byte) 0xff}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 64); + assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64")); + + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 128); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv4. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv4() { + IpPrefix ipPrefix; + byte[] value; + + value = null; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 24); + } + + /** + * Tests invalid valueOf() converter for a null array for IPv6. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullArrayIPv6() { + IpPrefix ipPrefix; + byte[] value; + + value = null; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 120); + } + + /** + * Tests invalid valueOf() converter for a short array for IPv4. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv4() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 24); + } + + /** + * Tests invalid valueOf() converter for a short array for IPv6. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfShortArrayIPv6() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 120); + } + + /** + * Tests invalid valueOf() converter for IPv4 byte array and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayNegativePrefixLengthIPv4() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, -1); + } + + /** + * Tests invalid valueOf() converter for IPv6 byte array and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayNegativePrefixLengthIPv6() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, (byte) 0x88, (byte) 0x88}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, -1); + } + + /** + * Tests invalid valueOf() converter for IPv4 byte array and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayTooLongPrefixLengthIPv4() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {1, 2, 3, 4}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET, value, 33); + } + + /** + * Tests invalid valueOf() converter for IPv6 byte array and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfByteArrayTooLongPrefixLengthIPv6() { + IpPrefix ipPrefix; + byte[] value; + + value = new byte[] {0x11, 0x11, 0x22, 0x22, + 0x33, 0x33, 0x44, 0x44, + 0x55, 0x55, 0x66, 0x66, + 0x77, 0x77, (byte) 0x88, (byte) 0x88}; + ipPrefix = IpPrefix.valueOf(IpAddress.Version.INET6, value, 129); + } + + /** + * Tests valueOf() converter for IPv4 address. + */ + @Test + public void testValueOfAddressIPv4() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = IpAddress.valueOf("1.2.3.4"); + ipPrefix = IpPrefix.valueOf(ipAddress, 24); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + ipAddress = IpAddress.valueOf("1.2.3.5"); + ipPrefix = IpPrefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + ipAddress = IpAddress.valueOf("0.0.0.0"); + ipPrefix = IpPrefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + ipAddress = IpAddress.valueOf("255.255.255.255"); + ipPrefix = IpPrefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 16); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 32); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests valueOf() converter for IPv6 address. + */ + @Test + public void testValueOfAddressIPv6() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + ipPrefix = IpPrefix.valueOf(ipAddress, 120); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800/120")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 128); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888/128")); + + ipAddress = IpAddress.valueOf("::"); + ipPrefix = IpPrefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 128); + assertThat(ipPrefix.toString(), is("::/128")); + + ipAddress = + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); + ipPrefix = IpPrefix.valueOf(ipAddress, 0); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 64); + assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64")); + + ipPrefix = IpPrefix.valueOf(ipAddress, 128); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } + + /** + * Tests invalid valueOf() converter for a null IP address. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullAddress() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = null; + ipPrefix = IpPrefix.valueOf(ipAddress, 24); + } + + /** + * Tests invalid valueOf() converter for IPv4 address and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressNegativePrefixLengthIPv4() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = IpAddress.valueOf("1.2.3.4"); + ipPrefix = IpPrefix.valueOf(ipAddress, -1); + } + + /** + * Tests invalid valueOf() converter for IPv6 address and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressNegativePrefixLengthIPv6() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + ipPrefix = IpPrefix.valueOf(ipAddress, -1); + } + + /** + * Tests invalid valueOf() converter for IPv4 address and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressTooLongPrefixLengthIPv4() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = IpAddress.valueOf("1.2.3.4"); + ipPrefix = IpPrefix.valueOf(ipAddress, 33); + } + + /** + * Tests invalid valueOf() converter for IPv6 address and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfAddressTooLongPrefixLengthIPv6() { + IpAddress ipAddress; + IpPrefix ipPrefix; + + ipAddress = + IpAddress.valueOf("1111:2222:3333:4444:5555:6666:7777:8888"); + ipPrefix = IpPrefix.valueOf(ipAddress, 129); + } + + /** + * Tests valueOf() converter for IPv4 string. + */ + @Test + public void testValueOfStringIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.3.4/24"); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = IpPrefix.valueOf("1.2.3.4/32"); + assertThat(ipPrefix.toString(), is("1.2.3.4/32")); + + ipPrefix = IpPrefix.valueOf("1.2.3.5/32"); + assertThat(ipPrefix.toString(), is("1.2.3.5/32")); + + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf("0.0.0.0/32"); + assertThat(ipPrefix.toString(), is("0.0.0.0/32")); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/0"); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/16"); + assertThat(ipPrefix.toString(), is("255.255.0.0/16")); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests valueOf() converter for IPv6 string. + */ + @Test + public void testValueOfStringIPv6() { + IpPrefix ipPrefix; + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/120"); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8800/120")); + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/128"); + assertThat(ipPrefix.toString(), + is("1111:2222:3333:4444:5555:6666:7777:8888/128")); + + ipPrefix = IpPrefix.valueOf("::/0"); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = IpPrefix.valueOf("::/128"); + assertThat(ipPrefix.toString(), is("::/128")); + + ipPrefix = + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/0"); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64"); + assertThat(ipPrefix.toString(), is("ffff:ffff:ffff:ffff::/64")); + + ipPrefix = + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } + + /** + * Tests invalid valueOf() converter for a null string. + */ + @Test(expected = NullPointerException.class) + public void testInvalidValueOfNullString() { + IpPrefix ipPrefix; + String fromString; + + fromString = null; + ipPrefix = IpPrefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an empty string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfEmptyString() { + IpPrefix ipPrefix; + String fromString; + + fromString = ""; + ipPrefix = IpPrefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for an incorrect string. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfIncorrectString() { + IpPrefix ipPrefix; + String fromString; + + fromString = "NoSuchIpPrefix"; + ipPrefix = IpPrefix.valueOf(fromString); + } + + /** + * Tests invalid valueOf() converter for IPv4 string and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringNegativePrefixLengthIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.3.4/-1"); + } + + /** + * Tests invalid valueOf() converter for IPv6 string and + * negative prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringNegativePrefixLengthIPv6() { + IpPrefix ipPrefix; + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/-1"); + } + + /** + * Tests invalid valueOf() converter for IPv4 string and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringTooLongPrefixLengthIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.3.4/33"); + } + + /** + * Tests invalid valueOf() converter for IPv6 string and + * too long prefix length. + */ + @Test(expected = IllegalArgumentException.class) + public void testInvalidValueOfStringTooLongPrefixLengthIPv6() { + IpPrefix ipPrefix; + + ipPrefix = + IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8888/129"); + } + + /** + * Tests IP prefix contains another IP prefix for IPv4. + */ + @Test + public void testContainsIpPrefixIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.0.0/24"); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32"))); + + ipPrefix = IpPrefix.valueOf("1.2.0.0/32"); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32"))); + + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32"))); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/32"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.4/32"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/16"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.3.0.0/24"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/16"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("0.0.0.0/0"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32"))); + + // Test when there is a mistmatch in the compared IP address families + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1111:2222:3333:4444::/120"))); + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + } + + /** + * Tests IP prefix contains another IP prefix for IPv6. + */ + @Test + public void testContainsIpPrefixIPv6() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/120"); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/120"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/128"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::1/128"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/64"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4445::/120"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/64"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/0"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/128"); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/120"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/128"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::1/128"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/64"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4445::/120"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/64"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/0"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + ipPrefix = IpPrefix.valueOf("::/0"); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/120"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/128"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::1/128"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/64"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4445::/120"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("::/64"))); + assertTrue(ipPrefix.contains(IpPrefix.valueOf("::/0"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + ipPrefix = + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/120"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/128"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::1/128"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4444::/64"))); + assertFalse(ipPrefix.contains( + IpPrefix.valueOf("1111:2222:3333:4445::/120"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/64"))); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("::/0"))); + assertTrue(ipPrefix.contains( + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"))); + + // Test when there is a mistmatch in the compared IP address families + ipPrefix = IpPrefix.valueOf("::/0"); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("1.2.0.0/24"))); + ipPrefix = IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertFalse(ipPrefix.contains(IpPrefix.valueOf("255.255.255.255/32"))); + } + + /** + * Tests IP prefix contains IP address for IPv4. + */ + @Test + public void testContainsIpAddressIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.0.0/24"); + assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.0"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.4"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.3.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("0.0.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("255.255.255.255"))); + + ipPrefix = IpPrefix.valueOf("1.2.0.0/32"); + assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.4"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.3.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("0.0.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("255.255.255.255"))); + + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.0"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("1.2.0.4"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("1.3.0.0"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("0.0.0.0"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("255.255.255.255"))); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.4"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.3.0.0"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("0.0.0.0"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("255.255.255.255"))); + + // Test when there is a mistmatch in the compared IP address families + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1111:2222:3333:4444::"))); + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertFalse(ipPrefix.contains(IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + } + + /** + * Tests IP prefix contains IP address for IPv6. + */ + @Test + public void testContainsIpAddressIPv6() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/120"); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::"))); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::1"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4445::"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("::"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444::/128"); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::1"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4445::"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("::"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + ipPrefix = IpPrefix.valueOf("::/0"); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::"))); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::1"))); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4445::"))); + assertTrue(ipPrefix.contains(IpAddress.valueOf("::"))); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + ipPrefix = + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4444::1"))); + assertFalse(ipPrefix.contains( + IpAddress.valueOf("1111:2222:3333:4445::"))); + assertFalse(ipPrefix.contains(IpAddress.valueOf("::"))); + assertTrue(ipPrefix.contains( + IpAddress.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))); + + // Test when there is a mistmatch in the compared IP address families + ipPrefix = IpPrefix.valueOf("::/0"); + assertFalse(ipPrefix.contains(IpAddress.valueOf("1.2.0.0"))); + ipPrefix = IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertFalse(ipPrefix.contains(IpAddress.valueOf("255.255.255.255"))); + } + + /** + * Tests equality of {@link IpPrefix} for IPv4. + */ + @Test + public void testEqualityIPv4() { + new EqualsTester() + .addEqualityGroup(IpPrefix.valueOf("1.2.0.0/24"), + IpPrefix.valueOf("1.2.0.0/24"), + IpPrefix.valueOf("1.2.0.4/24")) + .addEqualityGroup(IpPrefix.valueOf("1.2.0.0/16"), + IpPrefix.valueOf("1.2.0.0/16")) + .addEqualityGroup(IpPrefix.valueOf("1.2.0.0/32"), + IpPrefix.valueOf("1.2.0.0/32")) + .addEqualityGroup(IpPrefix.valueOf("1.3.0.0/24"), + IpPrefix.valueOf("1.3.0.0/24")) + .addEqualityGroup(IpPrefix.valueOf("0.0.0.0/0"), + IpPrefix.valueOf("0.0.0.0/0")) + .addEqualityGroup(IpPrefix.valueOf("255.255.255.255/32"), + IpPrefix.valueOf("255.255.255.255/32")) + .testEquals(); + } + + /** + * Tests equality of {@link IpPrefix} for IPv6. + */ + @Test + public void testEqualityIPv6() { + new EqualsTester() + .addEqualityGroup( + IpPrefix.valueOf("1111:2222:3333:4444::/120"), + IpPrefix.valueOf("1111:2222:3333:4444::1/120"), + IpPrefix.valueOf("1111:2222:3333:4444::/120")) + .addEqualityGroup( + IpPrefix.valueOf("1111:2222:3333:4444::/64"), + IpPrefix.valueOf("1111:2222:3333:4444::/64")) + .addEqualityGroup( + IpPrefix.valueOf("1111:2222:3333:4444::/128"), + IpPrefix.valueOf("1111:2222:3333:4444::/128")) + .addEqualityGroup( + IpPrefix.valueOf("1111:2222:3333:4445::/64"), + IpPrefix.valueOf("1111:2222:3333:4445::/64")) + .addEqualityGroup( + IpPrefix.valueOf("::/0"), + IpPrefix.valueOf("::/0")) + .addEqualityGroup( + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"), + IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")) + .testEquals(); + } + + /** + * Tests object string representation for IPv4. + */ + @Test + public void testToStringIPv4() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1.2.3.0/24"); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = IpPrefix.valueOf("1.2.3.4/24"); + assertThat(ipPrefix.toString(), is("1.2.3.0/24")); + + ipPrefix = IpPrefix.valueOf("0.0.0.0/0"); + assertThat(ipPrefix.toString(), is("0.0.0.0/0")); + + ipPrefix = IpPrefix.valueOf("255.255.255.255/32"); + assertThat(ipPrefix.toString(), is("255.255.255.255/32")); + } + + /** + * Tests object string representation for IPv6. + */ + @Test + public void testToStringIPv6() { + IpPrefix ipPrefix; + + ipPrefix = IpPrefix.valueOf("1100::/8"); + assertThat(ipPrefix.toString(), is("1100::/8")); + + ipPrefix = IpPrefix.valueOf("1111:2222:3333:4444:5555:6666:7777:8885/8"); + assertThat(ipPrefix.toString(), is("1100::/8")); + + ipPrefix = IpPrefix.valueOf("::/0"); + assertThat(ipPrefix.toString(), is("::/0")); + + ipPrefix = IpPrefix.valueOf("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"); + assertThat(ipPrefix.toString(), + is("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/LLCTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/LLCTest.java new file mode 100644 index 00000000..39bb72f4 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/LLCTest.java @@ -0,0 +1,70 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; + +import static org.junit.Assert.assertEquals; + +/** + * Unit tests for LLC class. + */ +public class LLCTest { + + private Deserializer<LLC> deserializer; + + private byte dsap = 10; + private byte ssap = 20; + private byte ctrl = 30; + + private byte[] bytes; + + @Before + public void setUp() throws Exception { + deserializer = LLC.deserializer(); + + ByteBuffer bb = ByteBuffer.allocate(LLC.LLC_HEADER_LENGTH); + + bb.put(dsap); + bb.put(ssap); + bb.put(ctrl); + + bytes = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, bytes); + } + + @Test + public void testDeserialize() throws Exception { + LLC llc = deserializer.deserialize(bytes, 0, bytes.length); + + assertEquals(dsap, llc.getDsap()); + assertEquals(ssap, llc.getSsap()); + assertEquals(ctrl, llc.getCtrl()); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/LLDPTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/LLDPTest.java new file mode 100644 index 00000000..95b0b04a --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/LLDPTest.java @@ -0,0 +1,115 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; +import java.util.Arrays; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Unit tests for the LLDP class. + */ +public class LLDPTest { + + private Deserializer<LLDP> deserializer; + + private byte[] chassisValue = new byte[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7}; + private byte[] portValue = new byte[] {0x1, 0x2, 0x3, 0x4, 0x5}; + private byte[] ttlValue = new byte[] {0x0, 0x20}; + + private short optionalTlvSize = 6; + private byte[] optionalTlvValue = new byte[] {0x6, 0x5, 0x4, 0x3, 0x2, 0x1}; + + private byte[] bytes; + + @Before + public void setUp() throws Exception { + deserializer = LLDP.deserializer(); + + // Each TLV is 2 bytes for the type+length, plus the size of the value + // There are 2 zero-bytes at the end + ByteBuffer bb = ByteBuffer.allocate(2 + LLDP.CHASSIS_TLV_SIZE + + 2 + LLDP.PORT_TLV_SIZE + + 2 + LLDP.TTL_TLV_SIZE + + 2 + optionalTlvSize + + 2); + + // Chassis TLV + bb.putShort(getTypeLength(LLDP.CHASSIS_TLV_TYPE, LLDP.CHASSIS_TLV_SIZE)); + bb.put(chassisValue); + + // Port TLV + bb.putShort(getTypeLength(LLDP.PORT_TLV_TYPE, LLDP.PORT_TLV_SIZE)); + bb.put(portValue); + + // TTL TLV + bb.putShort(getTypeLength(LLDP.TTL_TLV_TYPE, LLDP.TTL_TLV_SIZE)); + bb.put(ttlValue); + + // Optional TLV + bb.putShort(getTypeLength(LLDPOrganizationalTLV.ORGANIZATIONAL_TLV_TYPE, optionalTlvSize)); + bb.put(optionalTlvValue); + + bb.putShort((short) 0); + + bytes = bb.array(); + + } + + private short getTypeLength(byte type, short length) { + return (short) ((0x7f & type) << 9 | 0x1ff & length); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, bytes); + } + + @Test + public void testDeserialize() throws Exception { + LLDP lldp = deserializer.deserialize(bytes, 0, bytes.length); + + assertEquals(LLDP.CHASSIS_TLV_TYPE, lldp.getChassisId().getType()); + assertEquals(LLDP.CHASSIS_TLV_SIZE, lldp.getChassisId().getLength()); + assertTrue(Arrays.equals(chassisValue, lldp.getChassisId().getValue())); + + assertEquals(LLDP.PORT_TLV_TYPE, lldp.getPortId().getType()); + assertEquals(LLDP.PORT_TLV_SIZE, lldp.getPortId().getLength()); + assertTrue(Arrays.equals(portValue, lldp.getPortId().getValue())); + + assertEquals(LLDP.TTL_TLV_TYPE, lldp.getTtl().getType()); + assertEquals(LLDP.TTL_TLV_SIZE, lldp.getTtl().getLength()); + assertTrue(Arrays.equals(ttlValue, lldp.getTtl().getValue())); + + assertEquals(1, lldp.getOptionalTLVList().size()); + LLDPTLV optionalTlv = lldp.getOptionalTLVList().get(0); + + assertEquals(LLDPOrganizationalTLV.ORGANIZATIONAL_TLV_TYPE, optionalTlv.getType()); + assertEquals(optionalTlvSize, optionalTlv.getLength()); + assertTrue(Arrays.equals(optionalTlvValue, optionalTlv.getValue())); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/MplsTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/MplsTest.java new file mode 100644 index 00000000..2ab8ff98 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/MplsTest.java @@ -0,0 +1,74 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import org.junit.Before; +import org.junit.Test; + +import java.nio.ByteBuffer; +import java.util.HashMap; + +import static org.junit.Assert.assertEquals; + +/** + * Unit tests for MPLS class. + */ +public class MplsTest { + + private Deserializer<MPLS> deserializer; + + private int label = 1048575; + private byte bos = 1; + private byte ttl = 20; + private byte protocol = MPLS.PROTOCOL_IPV4; + + private byte[] bytes; + + @Before + public void setUp() throws Exception { + // Replace normal deserializer map with an empty map. This will cause + // the DataDeserializer to be used which will silently handle 0-byte input. + MPLS.protocolDeserializerMap = new HashMap<>(); + + deserializer = MPLS.deserializer(); + + ByteBuffer bb = ByteBuffer.allocate(MPLS.HEADER_LENGTH); + bb.putInt(((label & 0x000fffff) << 12) | ((bos & 0x1) << 8 | (ttl & 0xff))); + + bytes = bb.array(); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, bytes); + } + + @Test + public void testDeserialize() throws Exception { + MPLS mpls = deserializer.deserialize(bytes, 0, bytes.length); + + assertEquals(label, mpls.label); + assertEquals(bos, mpls.bos); + assertEquals(ttl, mpls.ttl); + assertEquals(protocol, mpls.protocol); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/PacketTestUtils.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/PacketTestUtils.java new file mode 100644 index 00000000..209b1d27 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/PacketTestUtils.java @@ -0,0 +1,98 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet; + +import java.nio.ByteBuffer; + +import static junit.framework.TestCase.fail; +import static org.junit.Assert.assertTrue; + +/** + * Utilities for testing packet methods. + */ +public final class PacketTestUtils { + + private PacketTestUtils() { + } + + /** + * Tests that the Deserializer function is resilient to bad input parameters + * such as null input, negative offset and length, etc. + * + * @param deserializer deserializer function to test + */ + public static void testDeserializeBadInput(Deserializer deserializer) { + byte[] bytes = ByteBuffer.allocate(4).array(); + + try { + deserializer.deserialize(null, 0, 4); + fail("NullPointerException was not thrown"); + } catch (NullPointerException e) { + assertTrue(true); + } catch (DeserializationException e) { + fail("NullPointerException was not thrown"); + } + + // input byte array length, offset and length don't make sense + expectDeserializationException(deserializer, bytes, -1, 0); + expectDeserializationException(deserializer, bytes, 0, -1); + expectDeserializationException(deserializer, bytes, 0, 5); + expectDeserializationException(deserializer, bytes, 2, 3); + expectDeserializationException(deserializer, bytes, 5, 0); + } + + /** + * Tests that the Deserializer function is resilient to truncated input, or + * cases where the input byte array does not contain enough bytes to + * deserialize the packet. + * + * @param deserializer deserializer function to test + * @param header byte array of a full-size packet + */ + public static void testDeserializeTruncated(Deserializer deserializer, + byte[] header) { + byte[] truncated; + + for (int i = 0; i < header.length; i++) { + truncated = new byte[i]; + + ByteBuffer.wrap(header).get(truncated); + + expectDeserializationException(deserializer, truncated, 0, truncated.length); + } + } + + /** + * Run the given deserializer function against the given inputs and verify + * that a DeserializationException is thrown. The the test will fail if a + * DeserializationException is not thrown by the deserializer function. + * + * @param deserializer deserializer function to test + * @param bytes input byte array + * @param offset input offset + * @param length input length + */ + public static void expectDeserializationException(Deserializer deserializer, + byte[] bytes, int offset, int length) { + try { + deserializer.deserialize(bytes, offset, length); + fail("DeserializationException was not thrown"); + } catch (DeserializationException e) { + assertTrue(true); + } + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/TCPTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/TCPTest.java new file mode 100644 index 00000000..faab5c2c --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/TCPTest.java @@ -0,0 +1,163 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +package org.onlab.packet; + +import org.junit.BeforeClass; +import org.junit.Test; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link TCP}. + */ +public class TCPTest { + private static final byte[] IPV4_SOURCE_ADDRESS = { + (byte) 192, (byte) 168, (byte) 1, (byte) 1 + }; + private static final byte[] IPV4_DESTINATION_ADDRESS = { + (byte) 192, (byte) 168, (byte) 1, (byte) 2 + }; + private static final byte[] IPV6_SOURCE_ADDRESS = { + (byte) 0xfe, (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01 + }; + private static final byte[] IPV6_DESTINATION_ADDRESS = { + (byte) 0xfe, (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x02 + }; + + private static IPv4 ipv4 = new IPv4(); + private static IPv6 ipv6 = new IPv6(); + private static byte[] bytePacketTCP4 = { + (byte) 0x00, (byte) 0x50, (byte) 0x00, (byte) 0x60, // src,dst port + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x10, // seq + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x20, // ack + (byte) 0x50, (byte) 0x02, // offset,flag + (byte) 0x10, (byte) 0x00, // window + (byte) 0x1b, (byte) 0xae, // checksum + (byte) 0x00, (byte) 0x01 // urgent + }; + private static byte[] bytePacketTCP6 = { + (byte) 0x00, (byte) 0x50, (byte) 0x00, (byte) 0x60, // src,dst port + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x10, // seq + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x20, // ack + (byte) 0x50, (byte) 0x02, // offset,flag + (byte) 0x10, (byte) 0x00, // window + (byte) 0xa1, (byte) 0xfd, // checksum + (byte) 0x00, (byte) 0x01 // urgent + }; + + private static Deserializer<TCP> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + deserializer = TCP.deserializer(); + + ipv4.setSourceAddress(IPv4.toIPv4Address(IPV4_SOURCE_ADDRESS)); + ipv4.setDestinationAddress(IPv4.toIPv4Address(IPV4_DESTINATION_ADDRESS)); + ipv4.setProtocol(IPv4.PROTOCOL_TCP); + + ipv6.setSourceAddress(IPV6_SOURCE_ADDRESS); + ipv6.setDestinationAddress(IPV6_DESTINATION_ADDRESS); + ipv6.setNextHeader(IPv6.PROTOCOL_TCP); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + TCP tcp = new TCP(); + tcp.setSourcePort(0x50); + tcp.setDestinationPort(0x60); + tcp.setSequence(0x10); + tcp.setAcknowledge(0x20); + tcp.setDataOffset((byte) 0x5); + tcp.setFlags((short) 0x2); + tcp.setWindowSize((short) 0x1000); + tcp.setUrgentPointer((short) 0x1); + + tcp.setParent(ipv4); + assertArrayEquals(bytePacketTCP4, tcp.serialize()); + tcp.resetChecksum(); + tcp.setParent(ipv6); + assertArrayEquals(bytePacketTCP6, tcp.serialize()); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, bytePacketTCP4); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws Exception { + TCP tcp = deserializer.deserialize(bytePacketTCP4, 0, bytePacketTCP4.length); + + assertThat(tcp.getSourcePort(), is(0x50)); + assertThat(tcp.getDestinationPort(), is(0x60)); + assertThat(tcp.getSequence(), is(0x10)); + assertThat(tcp.getAcknowledge(), is(0x20)); + assertThat(tcp.getDataOffset(), is((byte) 0x5)); + assertThat(tcp.getFlags(), is((short) 0x2)); + assertThat(tcp.getWindowSize(), is((short) 0x1000)); + assertThat(tcp.getUrgentPointer(), is((short) 0x1)); + assertThat(tcp.getChecksum(), is((short) 0x1bae)); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + TCP tcp1 = new TCP(); + tcp1.setSourcePort(0x50); + tcp1.setDestinationPort(0x60); + tcp1.setSequence(0x10); + tcp1.setAcknowledge(0x20); + tcp1.setDataOffset((byte) 0x5); + tcp1.setFlags((short) 0x2); + tcp1.setWindowSize((short) 0x1000); + tcp1.setUrgentPointer((short) 0x1); + + TCP tcp2 = new TCP(); + tcp2.setSourcePort(0x70); + tcp2.setDestinationPort(0x60); + tcp2.setSequence(0x10); + tcp2.setAcknowledge(0x20); + tcp2.setDataOffset((byte) 0x5); + tcp2.setFlags((short) 0x2); + tcp2.setWindowSize((short) 0x1000); + tcp2.setUrgentPointer((short) 0x1); + + assertTrue(tcp1.equals(tcp1)); + assertFalse(tcp1.equals(tcp2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/UDPTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/UDPTest.java new file mode 100644 index 00000000..ba453f61 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/UDPTest.java @@ -0,0 +1,134 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +package org.onlab.packet; + +import org.junit.BeforeClass; +import org.junit.Test; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link UDP}. + */ +public class UDPTest { + private static final byte[] IPV4_SOURCE_ADDRESS = { + (byte) 192, (byte) 168, (byte) 1, (byte) 1 + }; + private static final byte[] IPV4_DESTINATION_ADDRESS = { + (byte) 192, (byte) 168, (byte) 1, (byte) 2 + }; + private static final byte[] IPV6_SOURCE_ADDRESS = { + (byte) 0xfe, (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01 + }; + private static final byte[] IPV6_DESTINATION_ADDRESS = { + (byte) 0xfe, (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x02 + }; + + private static IPv4 ipv4 = new IPv4(); + private static IPv6 ipv6 = new IPv6(); + private static byte[] bytePacketUDP4 = { + (byte) 0x00, (byte) 0x50, // src port + (byte) 0x00, (byte) 0x60, // dst port + (byte) 0x00, (byte) 0x08, // length + (byte) 0x7b, (byte) 0xda, // checksum + }; + private static byte[] bytePacketUDP6 = { + (byte) 0x00, (byte) 0x50, // src port + (byte) 0x00, (byte) 0x60, // dst port + (byte) 0x00, (byte) 0x08, // length + (byte) 0x02, (byte) 0x2a, // checksum + }; + + private static Deserializer<UDP> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + deserializer = UDP.deserializer(); + + ipv4.setSourceAddress(IPv4.toIPv4Address(IPV4_SOURCE_ADDRESS)); + ipv4.setDestinationAddress(IPv4.toIPv4Address(IPV4_DESTINATION_ADDRESS)); + ipv4.setProtocol(IPv4.PROTOCOL_UDP); + + ipv6.setSourceAddress(IPV6_SOURCE_ADDRESS); + ipv6.setDestinationAddress(IPV6_DESTINATION_ADDRESS); + ipv6.setNextHeader(IPv6.PROTOCOL_UDP); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + UDP udp = new UDP(); + udp.setSourcePort(0x50); + udp.setDestinationPort(0x60); + + udp.setParent(ipv4); + assertArrayEquals(bytePacketUDP4, udp.serialize()); + udp.resetChecksum(); + udp.setParent(ipv6); + assertArrayEquals(bytePacketUDP6, udp.serialize()); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(deserializer); + } + + @Test + public void testDeserializeTruncated() throws Exception { + PacketTestUtils.testDeserializeTruncated(deserializer, bytePacketUDP4); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws Exception { + UDP udp = deserializer.deserialize(bytePacketUDP4, 0, bytePacketUDP4.length); + + assertThat(udp.getSourcePort(), is(0x50)); + assertThat(udp.getDestinationPort(), is(0x60)); + assertThat(udp.getLength(), is((short) 8)); + assertThat(udp.getChecksum(), is((short) 0x7bda)); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + UDP udp1 = new UDP(); + udp1.setSourcePort(0x50); + udp1.setDestinationPort(0x60); + + UDP udp2 = new UDP(); + udp2.setSourcePort(0x70); + udp2.setDestinationPort(0x60); + + assertTrue(udp1.equals(udp1)); + assertFalse(udp1.equals(udp2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/VlanIdTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/VlanIdTest.java new file mode 100644 index 00000000..9ec8ddda --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/VlanIdTest.java @@ -0,0 +1,53 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import com.google.common.testing.EqualsTester; + +public class VlanIdTest { + + @Test + public void testEquality() { + + VlanId vlan1 = VlanId.vlanId((short) -1); + VlanId vlan2 = VlanId.vlanId((short) 100); + VlanId vlan3 = VlanId.vlanId((short) 100); + + new EqualsTester().addEqualityGroup(VlanId.vlanId(), vlan1) + .addEqualityGroup(vlan2, vlan3) + .addEqualityGroup(VlanId.vlanId((short) 10)); + + } + + @Test + public void basics() { + // purposefully create UNTAGGED VLAN + VlanId vlan1 = VlanId.vlanId((short) 10); + VlanId vlan2 = VlanId.vlanId((short) -1); + + assertEquals("incorrect VLAN value", 10, vlan1.toShort()); + assertEquals("invalid untagged value", VlanId.UNTAGGED, vlan2.toShort()); + } + + @Test(expected = IllegalArgumentException.class) + public void testIllicitVLAN() { + VlanId.vlanId((short) 5000); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/AuthenticationTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/AuthenticationTest.java new file mode 100644 index 00000000..39ab9104 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/AuthenticationTest.java @@ -0,0 +1,121 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.Data; +import org.onlab.packet.Deserializer; +import org.onlab.packet.UDP; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link Authentication}. + */ +public class AuthenticationTest { + private static Data data; + private static UDP udp; + private static byte[] icv = { + (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44 + }; + private static byte[] bytePacket; + + private Deserializer<Authentication> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + data = new Data(); + data.setData("testSerialize".getBytes()); + udp = new UDP(); + udp.setPayload(data); + + byte[] bytePayload = udp.serialize(); + byte[] byteHeader = { + (byte) 0x11, (byte) 0x02, (byte) 0x00, (byte) 0x00, + (byte) 0x13, (byte) 0x57, (byte) 0x24, (byte) 0x68, + (byte) 0x00, (byte) 0xff, (byte) 0xff, (byte) 0x00, + (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44 + }; + bytePacket = new byte[byteHeader.length + bytePayload.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length); + } + + @Before + public void setUp() { + deserializer = Authentication.deserializer(); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + Authentication auth = new Authentication(); + auth.setNextHeader((byte) 0x11); + auth.setPayloadLength((byte) 0x02); + auth.setSecurityParamIndex(0x13572468); + auth.setSequence(0xffff00); + auth.setIngegrityCheck(icv); + auth.setPayload(udp); + + assertArrayEquals(auth.serialize(), bytePacket); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws Exception { + Authentication auth = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(auth.getNextHeader(), is((byte) 0x11)); + assertThat(auth.getPayloadLength(), is((byte) 0x02)); + assertThat(auth.getSecurityParamIndex(), is(0x13572468)); + assertThat(auth.getSequence(), is(0xffff00)); + assertArrayEquals(auth.getIntegrityCheck(), icv); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + Authentication auth1 = new Authentication(); + auth1.setNextHeader((byte) 0x11); + auth1.setPayloadLength((byte) 0x02); + auth1.setSecurityParamIndex(0x13572468); + auth1.setSequence(0xffff00); + auth1.setIngegrityCheck(icv); + + Authentication auth2 = new Authentication(); + auth2.setNextHeader((byte) 0x11); + auth2.setPayloadLength((byte) 0x02); + auth2.setSecurityParamIndex(0x13572467); + auth2.setSequence(0xffff00); + auth2.setIngegrityCheck(icv); + + assertTrue(auth1.equals(auth1)); + assertFalse(auth1.equals(auth2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/BaseOptionsTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/BaseOptionsTest.java new file mode 100644 index 00000000..bb91e9e7 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/BaseOptionsTest.java @@ -0,0 +1,115 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.Data; +import org.onlab.packet.Deserializer; +import org.onlab.packet.IPv6; +import org.onlab.packet.UDP; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link BaseOptions}. + */ +public class BaseOptionsTest { + private static Data data; + private static UDP udp; + private static byte[] options = { + (byte) 0x00, (byte) 0x03, + (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0x00 + }; + private static byte[] bytePacket; + + private Deserializer<BaseOptions> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + data = new Data(); + data.setData("testSerialize".getBytes()); + udp = new UDP(); + udp.setPayload(data); + + byte[] bytePayload = udp.serialize(); + byte[] byteHeader = { + (byte) 0x11, (byte) 0x00, (byte) 0x00, (byte) 0x03, + (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0x00 + }; + bytePacket = new byte[byteHeader.length + bytePayload.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length); + } + + @Before + public void setUp() { + deserializer = BaseOptions.deserializer(); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + BaseOptions baseopt = new BaseOptions(); + baseopt.setNextHeader((byte) 0x11); + baseopt.setHeaderExtLength((byte) 0x00); + baseopt.setOptions(options); + baseopt.setPayload(udp); + + assertArrayEquals(baseopt.serialize(), bytePacket); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws Exception { + BaseOptions baseopt = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(baseopt.getNextHeader(), is((byte) 0x11)); + assertThat(baseopt.getHeaderExtLength(), is((byte) 0x00)); + assertArrayEquals(baseopt.getOptions(), options); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + BaseOptions baseopt1 = new BaseOptions(); + baseopt1.setNextHeader((byte) 0x11); + baseopt1.setHeaderExtLength((byte) 0x00); + baseopt1.setOptions(options); + baseopt1.setType(IPv6.PROTOCOL_HOPOPT); + + BaseOptions baseopt2 = new BaseOptions(); + baseopt2.setNextHeader((byte) 0x11); + baseopt2.setHeaderExtLength((byte) 0x00); + baseopt2.setOptions(options); + baseopt1.setType(IPv6.PROTOCOL_DSTOPT); + + assertTrue(baseopt1.equals(baseopt1)); + assertFalse(baseopt1.equals(baseopt2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/DestinationOptionsTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/DestinationOptionsTest.java new file mode 100644 index 00000000..29dd1266 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/DestinationOptionsTest.java @@ -0,0 +1,37 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Test; +import org.onlab.packet.IPv6; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +/** + * Tests for class {@link DestinationOptions}. + */ +public class DestinationOptionsTest { + /** + * Tests constructor. + */ + @Test + public void testConstructor() { + DestinationOptions dstopt = new DestinationOptions(); + assertThat(dstopt.getType(), is(IPv6.PROTOCOL_DSTOPT)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/EncapSecurityPayloadTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/EncapSecurityPayloadTest.java new file mode 100644 index 00000000..e0e99191 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/EncapSecurityPayloadTest.java @@ -0,0 +1,104 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.Data; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; + +import java.util.Arrays; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link EncapSecurityPayload}. + */ +public class EncapSecurityPayloadTest { + private static Data data; + private static byte[] dataByte = new byte[32]; + private static byte[] bytePacket; + + private Deserializer<EncapSecurityPayload> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + Arrays.fill(dataByte, (byte) 0xff); + data = new Data().setData(dataByte); + + byte[] bytePayload = data.serialize(); + byte[] byteHeader = { + (byte) 0x13, (byte) 0x57, (byte) 0x24, (byte) 0x68, + (byte) 0x00, (byte) 0xff, (byte) 0xff, (byte) 0x00 + }; + bytePacket = new byte[byteHeader.length + bytePayload.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length); + } + + @Before + public void setUp() { + deserializer = EncapSecurityPayload.deserializer(); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + EncapSecurityPayload esp = new EncapSecurityPayload(); + esp.setSecurityParamIndex(0x13572468); + esp.setSequence(0xffff00); + esp.setPayload(data); + + assertArrayEquals(esp.serialize(), bytePacket); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + EncapSecurityPayload esp = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(esp.getSecurityParamIndex(), is(0x13572468)); + assertThat(esp.getSequence(), is(0xffff00)); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + EncapSecurityPayload esp1 = new EncapSecurityPayload(); + esp1.setSecurityParamIndex(0x13572468); + esp1.setSequence(0xffff00); + + EncapSecurityPayload esp2 = new EncapSecurityPayload(); + esp2.setSecurityParamIndex(0x13572468); + esp2.setSequence(0xfffff0); + + assertTrue(esp1.equals(esp1)); + assertFalse(esp1.equals(esp2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/FragmentTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/FragmentTest.java new file mode 100644 index 00000000..f2d5e48e --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/FragmentTest.java @@ -0,0 +1,113 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.Data; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; +import org.onlab.packet.UDP; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link Fragment}. + */ +public class FragmentTest { + private static Data data; + private static UDP udp; + private static byte[] bytePacket; + + private Deserializer<Fragment> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + data = new Data(); + data.setData("testSerialize".getBytes()); + udp = new UDP(); + udp.setPayload(data); + + byte[] bytePayload = udp.serialize(); + byte[] byteHeader = { + (byte) 0x11, (byte) 0x00, (byte) 0x00, (byte) 0xf9, + (byte) 0x00, (byte) 0x00, (byte) 0x13, (byte) 0x57 + }; + bytePacket = new byte[byteHeader.length + bytePayload.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length); + } + + @Before + public void setUp() { + deserializer = Fragment.deserializer(); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + Fragment frag = new Fragment(); + frag.setNextHeader((byte) 0x11); + frag.setFragmentOffset((short) 0x1f); + frag.setMoreFragment((byte) 1); + frag.setIdentification(0x1357); + frag.setPayload(udp); + + assertArrayEquals(frag.serialize(), bytePacket); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + Fragment frag = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(frag.getNextHeader(), is((byte) 0x11)); + assertThat(frag.getFragmentOffset(), is((short) 0x1f)); + assertThat(frag.getMoreFragment(), is((byte) 1)); + assertThat(frag.getIdentification(), is(0x1357)); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + Fragment frag1 = new Fragment(); + frag1.setNextHeader((byte) 0x11); + frag1.setFragmentOffset((short) 0x1f); + frag1.setMoreFragment((byte) 1); + frag1.setIdentification(0x1357); + + Fragment frag2 = new Fragment(); + frag2.setNextHeader((byte) 0x11); + frag2.setFragmentOffset((short) 0x1f); + frag2.setMoreFragment((byte) 1); + frag2.setIdentification(0x1358); + + assertTrue(frag1.equals(frag1)); + assertFalse(frag1.equals(frag2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/HopByHopOptionsTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/HopByHopOptionsTest.java new file mode 100644 index 00000000..1e9be2f6 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/HopByHopOptionsTest.java @@ -0,0 +1,37 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Test; +import org.onlab.packet.IPv6; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +/** + * Tests for class {@link HopByHopOptions}. + */ +public class HopByHopOptionsTest { + /** + * Tests constructor. + */ + @Test + public void testConstructor() { + HopByHopOptions hopopt = new HopByHopOptions(); + assertThat(hopopt.getType(), is(IPv6.PROTOCOL_HOPOPT)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/RoutingTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/RoutingTest.java new file mode 100644 index 00000000..a03bacc9 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ipv6/RoutingTest.java @@ -0,0 +1,128 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.packet.ipv6; + +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.Data; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; +import org.onlab.packet.UDP; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link Routing}. + */ +public class RoutingTest { + private static Data data; + private static UDP udp; + private static byte[] routingData = { + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce + }; + private static byte[] bytePacket; + + private Deserializer<Routing> deserializer; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + data = new Data(); + data.setData("testSerialize".getBytes()); + udp = new UDP(); + udp.setPayload(data); + + byte[] bytePayload = udp.serialize(); + byte[] byteHeader = { + (byte) 0x11, (byte) 0x02, (byte) 0x00, (byte) 0x03, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce + }; + bytePacket = new byte[byteHeader.length + bytePayload.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length); + } + + @Before + public void setUp() { + deserializer = Routing.deserializer(); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + Routing routing = new Routing(); + routing.setNextHeader((byte) 0x11); + routing.setHeaderExtLength((byte) 0x02); + routing.setRoutingType((byte) 0x00); + routing.setSegmntsLeft((byte) 0x03); + routing.setRoutingData(routingData); + routing.setPayload(udp); + + assertArrayEquals(routing.serialize(), bytePacket); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + Routing routing = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(routing.getNextHeader(), is((byte) 0x11)); + assertThat(routing.getHeaderExtLength(), is((byte) 0x02)); + assertThat(routing.getRoutingType(), is((byte) 0x00)); + assertThat(routing.getSegmentsLeft(), is((byte) 0x03)); + assertArrayEquals(routing.getRoutingData(), routingData); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + Routing routing1 = new Routing(); + routing1.setNextHeader((byte) 0x11); + routing1.setHeaderExtLength((byte) 0x02); + routing1.setRoutingType((byte) 0x00); + routing1.setSegmntsLeft((byte) 0x03); + routing1.setRoutingData(routingData); + + Routing routing2 = new Routing(); + routing2.setNextHeader((byte) 0x11); + routing2.setHeaderExtLength((byte) 0x02); + routing2.setRoutingType((byte) 0x00); + routing2.setSegmntsLeft((byte) 0x02); + routing2.setRoutingData(routingData); + + assertTrue(routing1.equals(routing1)); + assertFalse(routing1.equals(routing2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/NeighborAdvertisementTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/NeighborAdvertisementTest.java new file mode 100644 index 00000000..d537251c --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/NeighborAdvertisementTest.java @@ -0,0 +1,140 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet.ndp; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; +import org.onlab.packet.MacAddress; +import org.onlab.packet.PacketTestUtils; + +import java.nio.ByteBuffer; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link NeighborAdvertisement}. + */ +public class NeighborAdvertisementTest { + private static final byte[] TARGET_ADDRESS = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce + }; + private static final MacAddress MAC_ADDRESS = + MacAddress.valueOf("11:22:33:44:55:66"); + + private static byte[] bytePacket; + + private Deserializer<NeighborAdvertisement> deserializer + = NeighborAdvertisement.deserializer(); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + byte[] byteHeader = { + (byte) 0xe0, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce, + (byte) 0x02, (byte) 0x01, (byte) 0x11, (byte) 0x22, + (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66 + }; + bytePacket = new byte[byteHeader.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + NeighborAdvertisement na = new NeighborAdvertisement(); + na.setRouterFlag((byte) 1); + na.setSolicitedFlag((byte) 1); + na.setOverrideFlag((byte) 1); + na.setTargetAddress(TARGET_ADDRESS); + na.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertArrayEquals(na.serialize(), bytePacket); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(NeighborAdvertisement.deserializer()); + } + + @Test + public void testDeserializeTruncated() throws Exception { + // Run the truncation test only on the NeighborAdvertisement header + byte[] naHeader = new byte[NeighborAdvertisement.HEADER_LENGTH]; + ByteBuffer.wrap(bytePacket).get(naHeader); + + PacketTestUtils.testDeserializeTruncated(NeighborAdvertisement.deserializer(), naHeader); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + NeighborAdvertisement na = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(na.getRouterFlag(), is((byte) 1)); + assertThat(na.getSolicitedFlag(), is((byte) 1)); + assertThat(na.getOverrideFlag(), is((byte) 1)); + assertArrayEquals(na.getTargetAddress(), TARGET_ADDRESS); + + // Check the option(s) + assertThat(na.getOptions().size(), is(1)); + NeighborDiscoveryOptions.Option option = na.getOptions().get(0); + assertThat(option.type(), + is(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS)); + assertArrayEquals(option.data(), MAC_ADDRESS.toBytes()); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + NeighborAdvertisement na1 = new NeighborAdvertisement(); + na1.setRouterFlag((byte) 1); + na1.setSolicitedFlag((byte) 1); + na1.setOverrideFlag((byte) 1); + na1.setTargetAddress(TARGET_ADDRESS); + na1.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + NeighborAdvertisement na2 = new NeighborAdvertisement(); + na2.setRouterFlag((byte) 1); + na2.setSolicitedFlag((byte) 1); + na2.setOverrideFlag((byte) 0); + na2.setTargetAddress(TARGET_ADDRESS); + na2.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertTrue(na1.equals(na1)); + assertFalse(na1.equals(na2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/NeighborSolicitationTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/NeighborSolicitationTest.java new file mode 100644 index 00000000..03e57f5e --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/NeighborSolicitationTest.java @@ -0,0 +1,134 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet.ndp; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; +import org.onlab.packet.MacAddress; +import org.onlab.packet.PacketTestUtils; + +import java.nio.ByteBuffer; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link NeighborSolicitation}. + */ +public class NeighborSolicitationTest { + private static final byte[] TARGET_ADDRESS = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce + }; + private static final byte[] TARGET_ADDRESS2 = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xe6, (byte) 0xce, (byte) 0x8f, (byte) 0xff, + (byte) 0xfe, (byte) 0x54, (byte) 0x37, (byte) 0xc8 + }; + private static final MacAddress MAC_ADDRESS = + MacAddress.valueOf("11:22:33:44:55:66"); + + private static byte[] bytePacket; + + private Deserializer<NeighborSolicitation> deserializer + = NeighborSolicitation.deserializer(); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + byte[] byteHeader = { + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce, + (byte) 0x02, (byte) 0x01, (byte) 0x11, (byte) 0x22, + (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66 + }; + bytePacket = new byte[byteHeader.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + NeighborSolicitation ns = new NeighborSolicitation(); + ns.setTargetAddress(TARGET_ADDRESS); + ns.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertArrayEquals(ns.serialize(), bytePacket); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(NeighborSolicitation.deserializer()); + } + + @Test + public void testDeserializeTruncated() throws Exception { + // Run the truncation test only on the NeighborSolicitation header + byte[] nsHeader = new byte[NeighborSolicitation.HEADER_LENGTH]; + ByteBuffer.wrap(bytePacket).get(nsHeader); + + PacketTestUtils.testDeserializeTruncated(NeighborSolicitation.deserializer(), nsHeader); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + NeighborSolicitation ns = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertArrayEquals(ns.getTargetAddress(), TARGET_ADDRESS); + + // Check the option(s) + assertThat(ns.getOptions().size(), is(1)); + NeighborDiscoveryOptions.Option option = ns.getOptions().get(0); + assertThat(option.type(), + is(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS)); + assertArrayEquals(option.data(), MAC_ADDRESS.toBytes()); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + NeighborSolicitation ns1 = new NeighborSolicitation(); + ns1.setTargetAddress(TARGET_ADDRESS); + ns1.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + NeighborSolicitation ns2 = new NeighborSolicitation(); + ns2.setTargetAddress(TARGET_ADDRESS2); + ns2.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertTrue(ns1.equals(ns1)); + assertFalse(ns1.equals(ns2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RedirectTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RedirectTest.java new file mode 100644 index 00000000..31157145 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RedirectTest.java @@ -0,0 +1,147 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet.ndp; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; +import org.onlab.packet.MacAddress; +import org.onlab.packet.PacketTestUtils; + +import java.nio.ByteBuffer; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link Redirect}. + */ +public class RedirectTest { + private static final byte[] TARGET_ADDRESS = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 + }; + private static final byte[] DESTINATION_ADDRESS = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce + }; + private static final byte[] DESTINATION_ADDRESS2 = { + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xe6, (byte) 0xce, (byte) 0x8f, (byte) 0xff, + (byte) 0xfe, (byte) 0x54, (byte) 0x37, (byte) 0xc8 + }; + private static final MacAddress MAC_ADDRESS = + MacAddress.valueOf("11:22:33:44:55:66"); + + private static byte[] bytePacket; + + private Deserializer<Redirect> deserializer = Redirect.deserializer(); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + byte[] byteHeader = { + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, + (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15, + (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, + (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce, + (byte) 0x02, (byte) 0x01, (byte) 0x11, (byte) 0x22, + (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66 + }; + bytePacket = new byte[byteHeader.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + Redirect rd = new Redirect(); + rd.setTargetAddress(TARGET_ADDRESS); + rd.setDestinationAddress(DESTINATION_ADDRESS); + rd.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertArrayEquals(rd.serialize(), bytePacket); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(Redirect.deserializer()); + } + + @Test + public void testDeserializeTruncated() throws Exception { + // Run the truncation test only on the Redirect header + byte[] rdHeader = new byte[Redirect.HEADER_LENGTH]; + ByteBuffer.wrap(bytePacket).get(rdHeader); + + PacketTestUtils.testDeserializeTruncated(Redirect.deserializer(), rdHeader); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + Redirect rd = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertArrayEquals(rd.getTargetAddress(), TARGET_ADDRESS); + assertArrayEquals(rd.getDestinationAddress(), DESTINATION_ADDRESS); + + // Check the option(s) + assertThat(rd.getOptions().size(), is(1)); + NeighborDiscoveryOptions.Option option = rd.getOptions().get(0); + assertThat(option.type(), + is(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS)); + assertArrayEquals(option.data(), MAC_ADDRESS.toBytes()); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + Redirect rd1 = new Redirect(); + rd1.setTargetAddress(TARGET_ADDRESS); + rd1.setDestinationAddress(DESTINATION_ADDRESS); + rd1.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + Redirect rd2 = new Redirect(); + rd2.setTargetAddress(TARGET_ADDRESS); + rd2.setDestinationAddress(DESTINATION_ADDRESS2); + rd2.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertTrue(rd1.equals(rd1)); + assertFalse(rd1.equals(rd2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RouterAdvertisementTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RouterAdvertisementTest.java new file mode 100644 index 00000000..ede15747 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RouterAdvertisementTest.java @@ -0,0 +1,140 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet.ndp; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.DeserializationException; +import org.onlab.packet.Deserializer; +import org.onlab.packet.MacAddress; +import org.onlab.packet.PacketTestUtils; + +import java.nio.ByteBuffer; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link RouterAdvertisement}. + */ +public class RouterAdvertisementTest { + private static final MacAddress MAC_ADDRESS = + MacAddress.valueOf("11:22:33:44:55:66"); + + private static byte[] bytePacket; + + private Deserializer<RouterAdvertisement> deserializer + = RouterAdvertisement.deserializer(); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + byte[] byteHeader = { + (byte) 0x03, (byte) 0xc0, (byte) 0x02, (byte) 0x58, + (byte) 0x00, (byte) 0x00, (byte) 0x03, (byte) 0xe8, + (byte) 0x00, (byte) 0x00, (byte) 0x01, (byte) 0xf4, + (byte) 0x02, (byte) 0x01, (byte) 0x11, (byte) 0x22, + (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66 + }; + bytePacket = new byte[byteHeader.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + RouterAdvertisement ra = new RouterAdvertisement(); + ra.setCurrentHopLimit((byte) 3); + ra.setMFlag((byte) 1); + ra.setOFlag((byte) 1); + ra.setRouterLifetime((short) 0x258); + ra.setReachableTime(0x3e8); + ra.setRetransmitTimer(0x1f4); + ra.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertArrayEquals(ra.serialize(), bytePacket); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(RouterAdvertisement.deserializer()); + } + + @Test + public void testDeserializeTruncated() throws Exception { + // Run the truncation test only on the RouterAdvertisement header + byte[] raHeader = new byte[RouterAdvertisement.HEADER_LENGTH]; + ByteBuffer.wrap(bytePacket).get(raHeader); + + PacketTestUtils.testDeserializeTruncated(RouterAdvertisement.deserializer(), raHeader); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws DeserializationException { + RouterAdvertisement ra = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + assertThat(ra.getCurrentHopLimit(), is((byte) 3)); + assertThat(ra.getMFlag(), is((byte) 1)); + assertThat(ra.getOFlag(), is((byte) 1)); + assertThat(ra.getRouterLifetime(), is((short) 0x258)); + assertThat(ra.getReachableTime(), is(0x3e8)); + assertThat(ra.getRetransmitTimer(), is(0x1f4)); + + // Check the option(s) + assertThat(ra.getOptions().size(), is(1)); + NeighborDiscoveryOptions.Option option = ra.getOptions().get(0); + assertThat(option.type(), + is(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS)); + assertArrayEquals(option.data(), MAC_ADDRESS.toBytes()); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + RouterAdvertisement ra1 = new RouterAdvertisement(); + ra1.setCurrentHopLimit((byte) 3); + ra1.setMFlag((byte) 1); + ra1.setOFlag((byte) 1); + ra1.setRouterLifetime((short) 0x258); + ra1.setReachableTime(0x3e8); + ra1.setRetransmitTimer(0x1f4); + ra1.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + RouterAdvertisement ra2 = new RouterAdvertisement(); + ra2.setCurrentHopLimit((byte) 3); + ra2.setMFlag((byte) 0); + ra2.setOFlag((byte) 0); + ra2.setRouterLifetime((short) 0x1f4); + ra2.setReachableTime(0x3e8); + ra2.setRetransmitTimer(0x1f4); + ra2.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS.toBytes()); + + assertTrue(ra1.equals(ra1)); + assertFalse(ra1.equals(ra2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RouterSolicitationTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RouterSolicitationTest.java new file mode 100644 index 00000000..e3b5686c --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/packet/ndp/RouterSolicitationTest.java @@ -0,0 +1,114 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.packet.ndp; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.onlab.packet.Deserializer; +import org.onlab.packet.MacAddress; +import org.onlab.packet.PacketTestUtils; + +import java.nio.ByteBuffer; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests for class {@link RouterSolicitation}. + */ +public class RouterSolicitationTest { + private static final MacAddress MAC_ADDRESS1 = + MacAddress.valueOf("11:22:33:44:55:66"); + private static final MacAddress MAC_ADDRESS2 = + MacAddress.valueOf("11:22:33:44:55:00"); + + private static byte[] bytePacket; + + private Deserializer<RouterSolicitation> deserializer + = RouterSolicitation.deserializer(); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + byte[] byteHeader = { + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x02, (byte) 0x01, (byte) 0x11, (byte) 0x22, + (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66 + }; + bytePacket = new byte[byteHeader.length]; + System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length); + } + + /** + * Tests serialize and setters. + */ + @Test + public void testSerialize() { + RouterSolicitation rs = new RouterSolicitation(); + rs.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS1.toBytes()); + + assertArrayEquals(rs.serialize(), bytePacket); + } + + @Test + public void testDeserializeBadInput() throws Exception { + PacketTestUtils.testDeserializeBadInput(RouterSolicitation.deserializer()); + } + + @Test + public void testDeserializeTruncated() throws Exception { + // Run the truncation test only on the RouterSolicitation header + byte[] rsHeader = new byte[RouterSolicitation.HEADER_LENGTH]; + ByteBuffer.wrap(bytePacket).get(rsHeader); + + PacketTestUtils.testDeserializeTruncated(RouterSolicitation.deserializer(), rsHeader); + } + + /** + * Tests deserialize and getters. + */ + @Test + public void testDeserialize() throws Exception { + RouterSolicitation rs = deserializer.deserialize(bytePacket, 0, bytePacket.length); + + // Check the option(s) + assertThat(rs.getOptions().size(), is(1)); + NeighborDiscoveryOptions.Option option = rs.getOptions().get(0); + assertThat(option.type(), + is(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS)); + assertArrayEquals(option.data(), MAC_ADDRESS1.toBytes()); + } + + /** + * Tests comparator. + */ + @Test + public void testEqual() { + RouterSolicitation rs1 = new RouterSolicitation(); + rs1.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS1.toBytes()); + + RouterSolicitation rs2 = new RouterSolicitation(); + rs2.addOption(NeighborDiscoveryOptions.TYPE_TARGET_LL_ADDRESS, + MAC_ADDRESS2.toBytes()); + + assertTrue(rs1.equals(rs1)); + assertFalse(rs1.equals(rs2)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/AbstractAccumulatorTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/AbstractAccumulatorTest.java new file mode 100644 index 00000000..02f0deb1 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/AbstractAccumulatorTest.java @@ -0,0 +1,184 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.Ignore; +import org.junit.Test; + +import java.util.List; +import java.util.Timer; +import java.util.stream.IntStream; + +import static org.junit.Assert.*; +import static org.onlab.junit.TestTools.assertAfter; +import static org.onlab.junit.TestTools.delay; + +/** + * Tests the operation of the accumulator. + */ +public class AbstractAccumulatorTest { + + private final Timer timer = new Timer(); + + @Test + public void basics() throws Exception { + TestAccumulator accumulator = new TestAccumulator(); + assertEquals("incorrect timer", timer, accumulator.timer()); + assertEquals("incorrect max events", 5, accumulator.maxItems()); + assertEquals("incorrect max ms", 100, accumulator.maxBatchMillis()); + assertEquals("incorrect idle ms", 70, accumulator.maxIdleMillis()); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void eventTrigger() { + TestAccumulator accumulator = new TestAccumulator(); + accumulator.add(new TestItem("a")); + accumulator.add(new TestItem("b")); + accumulator.add(new TestItem("c")); + accumulator.add(new TestItem("d")); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("e")); + delay(20); + assertFalse("should have fired", accumulator.batch.isEmpty()); + assertEquals("incorrect batch", "abcde", accumulator.batch); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void timeTrigger() { + TestAccumulator accumulator = new TestAccumulator(); + accumulator.add(new TestItem("a")); + delay(30); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("b")); + delay(30); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("c")); + delay(30); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("d")); + delay(60); + assertFalse("should have fired", accumulator.batch.isEmpty()); + assertEquals("incorrect batch", "abcd", accumulator.batch); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void idleTrigger() { + TestAccumulator accumulator = new TestAccumulator(); + accumulator.add(new TestItem("a")); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("b")); + delay(80); + assertFalse("should have fired", accumulator.batch.isEmpty()); + assertEquals("incorrect batch", "ab", accumulator.batch); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void readyIdleTrigger() { + TestAccumulator accumulator = new TestAccumulator(); + accumulator.ready = false; + accumulator.add(new TestItem("a")); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("b")); + delay(80); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.ready = true; + delay(80); + assertFalse("should have fired", accumulator.batch.isEmpty()); + assertEquals("incorrect batch", "ab", accumulator.batch); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void readyLongTrigger() { + TestAccumulator accumulator = new TestAccumulator(); + accumulator.ready = false; + delay(120); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.add(new TestItem("a")); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.ready = true; + delay(80); + assertFalse("should have fired", accumulator.batch.isEmpty()); + assertEquals("incorrect batch", "a", accumulator.batch); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void readyMaxTrigger() { + TestAccumulator accumulator = new TestAccumulator(); + accumulator.ready = false; + accumulator.add(new TestItem("a")); + accumulator.add(new TestItem("b")); + accumulator.add(new TestItem("c")); + accumulator.add(new TestItem("d")); + accumulator.add(new TestItem("e")); + accumulator.add(new TestItem("f")); + assertTrue("should not have fired yet", accumulator.batch.isEmpty()); + accumulator.ready = true; + accumulator.add(new TestItem("g")); + delay(5); + assertFalse("should have fired", accumulator.batch.isEmpty()); + assertEquals("incorrect batch", "abcdefg", accumulator.batch); + } + + @Ignore("FIXME: timing sensitive test failing randomly.") + @Test + public void stormTest() { + TestAccumulator accumulator = new TestAccumulator(); + IntStream.range(0, 1000).forEach(i -> accumulator.add(new TestItem("#" + i))); + assertAfter(100, () -> assertEquals("wrong item count", 1000, accumulator.itemCount)); + assertEquals("wrong batch count", 200, accumulator.batchCount); + } + + private class TestItem { + private final String s; + + public TestItem(String s) { + this.s = s; + } + } + + private class TestAccumulator extends AbstractAccumulator<TestItem> { + + String batch = ""; + boolean ready = true; + int batchCount = 0; + int itemCount = 0; + + protected TestAccumulator() { + super(timer, 5, 100, 70); + } + + @Override + public void processItems(List<TestItem> items) { + batchCount++; + itemCount += items.size(); + for (TestItem item : items) { + batch += item.s; + } + } + + @Override + public boolean isReady() { + return ready; + } + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BandwidthTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BandwidthTest.java new file mode 100644 index 00000000..a3baf06c --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BandwidthTest.java @@ -0,0 +1,82 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; + +import static org.hamcrest.Matchers.greaterThan; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.lessThan; +import static org.junit.Assert.assertThat; + +/** + * Unit tests for Bandwidth. + */ +public class BandwidthTest { + + private final Bandwidth small = Bandwidth.kbps(100.0); + private final Bandwidth large = Bandwidth.mbps(1.0); + + /** + * Tests equality of Bandwidth instances. + */ + @Test + public void testEquality() { + new EqualsTester() + .addEqualityGroup(Bandwidth.kbps(1000.0), Bandwidth.kbps(1000.0), Bandwidth.mbps(1.0)) + .addEqualityGroup(Bandwidth.gbps(1.0)) + .testEquals(); + } + + /** + * Tests add operation of two Bandwidths. + */ + @Test + public void testAdd() { + Bandwidth expected = Bandwidth.kbps(1100.0); + + assertThat(small.add(large), is(expected)); + } + + /** + * Tests subtract operation of two Bandwidths. + */ + @Test + public void testSubtract() { + Bandwidth expected = Bandwidth.kbps(900.0); + + assertThat(large.subtract(small), is(expected)); + } + + /** + * Tests if the first object is less than the second object. + */ + @Test + public void testLessThan() { + assertThat(small, is(lessThan(large))); + assertThat(small.isLessThan(large), is(true)); + } + + /** + * Tests if the first object is greater than the second object. + */ + @Test + public void testGreaterThan() { + assertThat(large, is(greaterThan(small))); + assertThat(large.isGreaterThan(small), is(true)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BlockingBooleanTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BlockingBooleanTest.java new file mode 100644 index 00000000..2d8b688e --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BlockingBooleanTest.java @@ -0,0 +1,210 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.apache.commons.lang.mutable.MutableBoolean; +import org.junit.Ignore; +import org.junit.Test; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +import static org.junit.Assert.*; + +/** + * Tests of the BlockingBoolean utility. + */ +public class BlockingBooleanTest { + + private static final int TIMEOUT = 100; //ms + + @Test + public void basics() { + BlockingBoolean b = new BlockingBoolean(false); + assertEquals(false, b.get()); + b.set(true); + assertEquals(true, b.get()); + b.set(true); + assertEquals(true, b.get()); + b.set(false); + assertEquals(false, b.get()); + } + + private void waitChange(boolean value, int numThreads) { + BlockingBoolean b = new BlockingBoolean(!value); + + CountDownLatch latch = new CountDownLatch(numThreads); + ExecutorService exec = Executors.newFixedThreadPool(numThreads); + for (int i = 0; i < numThreads; i++) { + exec.submit(() -> { + try { + b.await(value); + latch.countDown(); + } catch (InterruptedException e) { + fail(); + } + }); + } + b.set(value); + try { + assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + exec.shutdown(); + } + + @Test + public void waitTrueChange() { + waitChange(true, 4); + } + + @Test + public void waitFalseChange() { + waitChange(false, 4); + } + + @Test + public void waitSame() { + BlockingBoolean b = new BlockingBoolean(true); + + CountDownLatch latch = new CountDownLatch(1); + ExecutorService exec = Executors.newSingleThreadExecutor(); + exec.submit(() -> { + try { + b.await(true); + latch.countDown(); + } catch (InterruptedException e) { + fail(); + } + }); + try { + assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + exec.shutdown(); + } + + @Test + public void someWait() { + BlockingBoolean b = new BlockingBoolean(false); + + int numThreads = 4; + CountDownLatch sameLatch = new CountDownLatch(numThreads / 2); + CountDownLatch waitLatch = new CountDownLatch(numThreads / 2); + + ExecutorService exec = Executors.newFixedThreadPool(numThreads); + for (int i = 0; i < numThreads; i++) { + final boolean value = (i % 2 == 1); + exec.submit(() -> { + try { + b.await(value); + if (value) { + waitLatch.countDown(); + } else { + sameLatch.countDown(); + } + } catch (InterruptedException e) { + fail(); + } + }); + } + try { + assertTrue(sameLatch.await(TIMEOUT, TimeUnit.MILLISECONDS)); + assertEquals(waitLatch.getCount(), numThreads / 2); + } catch (InterruptedException e) { + fail(); + } + b.set(true); + try { + assertTrue(waitLatch.await(TIMEOUT, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + exec.shutdown(); + } + + @Test + public void waitTimeout() { + BlockingBoolean b = new BlockingBoolean(true); + + CountDownLatch latch = new CountDownLatch(1); + ExecutorService exec = Executors.newSingleThreadExecutor(); + exec.submit(() -> { + try { + if (!b.await(false, 1, TimeUnit.NANOSECONDS)) { + latch.countDown(); + } else { + fail(); + } + } catch (InterruptedException e) { + fail(); + } + }); + try { + assertTrue(latch.await(TIMEOUT, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + exec.shutdown(); + + } + + @Test + @Ignore + public void samePerf() { + int iters = 10_000; + + BlockingBoolean b1 = new BlockingBoolean(false); + long t1 = System.nanoTime(); + for (int i = 0; i < iters; i++) { + b1.set(false); + } + long t2 = System.nanoTime(); + MutableBoolean b2 = new MutableBoolean(false); + for (int i = 0; i < iters; i++) { + b2.setValue(false); + } + long t3 = System.nanoTime(); + System.out.println((t2 - t1) + " " + (t3 - t2) + " " + ((t2 - t1) <= (t3 - t2))); + } + + @Test + @Ignore + public void changePerf() { + int iters = 10_000; + + BlockingBoolean b1 = new BlockingBoolean(false); + boolean v = true; + long t1 = System.nanoTime(); + for (int i = 0; i < iters; i++) { + b1.set(v); + v = !v; + } + long t2 = System.nanoTime(); + MutableBoolean b2 = new MutableBoolean(false); + for (int i = 0; i < iters; i++) { + b2.setValue(v); + v = !v; + } + long t3 = System.nanoTime(); + System.out.println((t2 - t1) + " " + (t3 - t2) + " " + ((t2 - t1) <= (t3 - t2))); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BoundedThreadPoolTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BoundedThreadPoolTest.java new file mode 100644 index 00000000..c6132de1 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/BoundedThreadPoolTest.java @@ -0,0 +1,227 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import com.google.common.collect.Lists; +import org.junit.Test; + +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; + +import static org.junit.Assert.*; +import static org.onlab.util.BoundedThreadPool.*; +import static org.onlab.util.Tools.namedThreads; + +/** + * Test of BoundedThreadPool. + */ +public final class BoundedThreadPoolTest { + + @Test + public void simpleJob() { + final Thread myThread = Thread.currentThread(); + final AtomicBoolean sameThread = new AtomicBoolean(true); + final CountDownLatch latch = new CountDownLatch(1); + + BoundedThreadPool exec = newSingleThreadExecutor(namedThreads("test")); + exec.submit(() -> { + sameThread.set(myThread.equals(Thread.currentThread())); + latch.countDown(); + }); + + try { + assertTrue("Job not run", latch.await(100, TimeUnit.MILLISECONDS)); + assertFalse("Runnable used caller thread", sameThread.get()); + } catch (InterruptedException e) { + fail(); + } finally { + exec.shutdown(); + } + + // TODO perhaps move to tearDown + try { + assertTrue(exec.awaitTermination(1, TimeUnit.SECONDS)); + } catch (InterruptedException e) { + fail(); + } + } + + private List<CountDownLatch> fillExecutor(BoundedThreadPool exec) { + int numThreads = exec.getMaximumPoolSize(); + List<CountDownLatch> latches = Lists.newArrayList(); + final CountDownLatch started = new CountDownLatch(numThreads); + List<CountDownLatch> finished = Lists.newArrayList(); + + // seed the executor's threads + for (int i = 0; i < numThreads; i++) { + final CountDownLatch latch = new CountDownLatch(1); + final CountDownLatch fin = new CountDownLatch(1); + latches.add(latch); + finished.add(fin); + exec.submit(() -> { + try { + started.countDown(); + latch.await(); + fin.countDown(); + } catch (InterruptedException e) { + fail(); + } + }); + } + try { + assertTrue(started.await(100, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + // fill the queue + CountDownLatch startedBlocked = new CountDownLatch(1); + while (exec.getQueue().remainingCapacity() > 0) { + final CountDownLatch latch = new CountDownLatch(1); + latches.add(latch); + exec.submit(() -> { + try { + startedBlocked.countDown(); + latch.await(); + } catch (InterruptedException e) { + fail(); + } + }); + } + + latches.remove(0).countDown(); // release one of the executors + // ... we need to do this because load is recomputed when jobs are taken + // Note: For this to work, 1 / numThreads must be less than the load threshold (0.2) + + // verify that the old job has terminated + try { + assertTrue("Job didn't finish", + finished.remove(0).await(100, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + + // verify that a previously blocked thread has started + try { + assertTrue(startedBlocked.await(10, TimeUnit.MILLISECONDS)); + } catch (InterruptedException e) { + fail(); + } + + + // add another job to fill the queue + final CountDownLatch latch = new CountDownLatch(1); + latches.add(latch); + exec.submit(() -> { + try { + latch.await(); + } catch (InterruptedException e) { + fail(); + } + }); + assertEquals(exec.getQueue().size(), maxQueueSize); + + return latches; + } + + @Test + public void releaseOneThread() { + maxQueueSize = 10; + BoundedThreadPool exec = newFixedThreadPool(4, namedThreads("test")); + List<CountDownLatch> latches = fillExecutor(exec); + + CountDownLatch myLatch = new CountDownLatch(1); + ExecutorService myExec = Executors.newSingleThreadExecutor(); + Future<Thread> expected = myExec.submit(Thread::currentThread); + + assertEquals(exec.getQueue().size(), maxQueueSize); + long start = System.nanoTime(); + Future<Thread> actual = myExec.submit(() -> { + return exec.submit(() -> { + myLatch.countDown(); + return Thread.currentThread(); + }).get(); + }); + + try { + assertFalse("Thread should still be blocked", + myLatch.await(10, TimeUnit.MILLISECONDS)); + + latches.remove(0).countDown(); // release the first thread + assertFalse("Thread should still be blocked", + myLatch.await(10, TimeUnit.MILLISECONDS)); + latches.remove(0).countDown(); // release the second thread + + assertTrue("Thread should be unblocked", + myLatch.await(10, TimeUnit.MILLISECONDS)); + long delta = System.nanoTime() - start; + double load = exec.getQueue().size() / (double) maxQueueSize; + assertTrue("Load is greater than threshold", load <= 0.8); + assertTrue("Load is less than threshold", load >= 0.6); + assertEquals("Work done on wrong thread", expected.get(), actual.get()); + assertTrue("Took more than one second", delta < Math.pow(10, 9)); + } catch (InterruptedException | ExecutionException e) { + fail(); + } finally { + latches.forEach(CountDownLatch::countDown); + exec.shutdown(); + } + + // TODO perhaps move to tearDown + try { + assertTrue(exec.awaitTermination(1, TimeUnit.SECONDS)); + } catch (InterruptedException e) { + fail(); + } + + } + + @Test + public void highLoadTimeout() { + maxQueueSize = 10; + BoundedThreadPool exec = newFixedThreadPool(2, namedThreads("test")); + List<CountDownLatch> latches = fillExecutor(exec); + + // true if the job is executed and it is done on the test thread + final AtomicBoolean sameThread = new AtomicBoolean(false); + final Thread myThread = Thread.currentThread(); + long start = System.nanoTime(); + exec.submit(() -> { + sameThread.set(myThread.equals(Thread.currentThread())); + }); + + long delta = System.nanoTime() - start; + assertEquals(maxQueueSize, exec.getQueue().size()); + assertTrue("Work done on wrong thread (or didn't happen)", sameThread.get()); + assertTrue("Took less than one second. Actual: " + delta / 1_000_000.0 + "ms", + delta > Math.pow(10, 9)); + assertTrue("Took more than two seconds", delta < 2 * Math.pow(10, 9)); + latches.forEach(CountDownLatch::countDown); + exec.shutdown(); + + // TODO perhaps move to tearDown + try { + assertTrue(exec.awaitTermination(1, TimeUnit.SECONDS)); + } catch (InterruptedException e) { + fail(); + } + } +}
\ No newline at end of file diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/ByteArraySizeHashPrinterTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/ByteArraySizeHashPrinterTest.java new file mode 100644 index 00000000..e3a5e945 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/ByteArraySizeHashPrinterTest.java @@ -0,0 +1,53 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.util; + +import static org.junit.Assert.*; + +import java.util.Arrays; + +import org.junit.Test; + +/** + * Test cases for byte[] pretty printer. + */ +public class ByteArraySizeHashPrinterTest { + + /** + * Test method for {@link org.onlab.util.ByteArraySizeHashPrinter#toString()}. + */ + @Test + public void testToStringNull() { + final byte[] none = null; + + assertEquals("byte[]{null}", String.valueOf(ByteArraySizeHashPrinter.of(none))); + assertNull(ByteArraySizeHashPrinter.orNull(none)); + } + + /** + * Test method for {@link org.onlab.util.ByteArraySizeHashPrinter#toString()}. + */ + @Test + public void testToString() { + final byte[] some = new byte[] {2, 5, 0, 1 }; + final String expected = "byte[]{length=" + some.length + ", hash=" + Arrays.hashCode(some) + "}"; + + assertEquals(expected, String.valueOf(ByteArraySizeHashPrinter.of(some))); + assertNotNull(ByteArraySizeHashPrinter.orNull(some)); + } + +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/CounterTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/CounterTest.java new file mode 100644 index 00000000..d30e1b59 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/CounterTest.java @@ -0,0 +1,86 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.onlab.junit.TestTools.delay; + +/** + * Tests of the Counter utility. + */ +public class CounterTest { + + @Test + public void basics() { + Counter tt = new Counter(); + assertEquals("incorrect number of bytes", 0L, tt.total()); + assertEquals("incorrect throughput", 0.0, tt.throughput(), 0.0001); + tt.add(1234567890L); + assertEquals("incorrect number of bytes", 1234567890L, tt.total()); + assertTrue("incorrect throughput", 1234567890.0 < tt.throughput()); + delay(1500); + tt.add(1L); + assertEquals("incorrect number of bytes", 1234567891L, tt.total()); + assertTrue("incorrect throughput", 1234567891.0 > tt.throughput()); + tt.reset(); + assertEquals("incorrect number of bytes", 0L, tt.total()); + assertEquals("incorrect throughput", 0.0, tt.throughput(), 0.0001); + } + + @Test + public void freeze() { + Counter tt = new Counter(); + tt.add(123L); + assertEquals("incorrect number of bytes", 123L, tt.total()); + delay(1000); + tt.freeze(); + tt.add(123L); + assertEquals("incorrect number of bytes", 123L, tt.total()); + + double d = tt.duration(); + double t = tt.throughput(); + assertEquals("incorrect duration", d, tt.duration(), 0.0001); + assertEquals("incorrect throughput", t, tt.throughput(), 0.0001); + assertEquals("incorrect number of bytes", 123L, tt.total()); + } + + @Test + public void reset() { + Counter tt = new Counter(); + tt.add(123L); + assertEquals("incorrect number of bytes", 123L, tt.total()); + + double d = tt.duration(); + double t = tt.throughput(); + assertEquals("incorrect duration", d, tt.duration(), 0.0001); + assertEquals("incorrect throughput", t, tt.throughput(), 0.0001); + assertEquals("incorrect number of bytes", 123L, tt.total()); + + tt.reset(); + assertEquals("incorrect throughput", 0.0, tt.throughput(), 0.0001); + assertEquals("incorrect number of bytes", 0, tt.total()); + } + + @Test + public void syntheticTracker() { + Counter tt = new Counter(5000, 1000, 6000); + assertEquals("incorrect duration", 1, tt.duration(), 0.1); + assertEquals("incorrect throughput", 1000, tt.throughput(), 1.0); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/FrequencyTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/FrequencyTest.java new file mode 100644 index 00000000..727c0f73 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/FrequencyTest.java @@ -0,0 +1,107 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import com.google.common.testing.EqualsTester; +import org.junit.Test; +import org.onlab.junit.ImmutableClassChecker; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.greaterThan; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.lessThan; + +public class FrequencyTest { + + private final Frequency frequency1 = Frequency.ofMHz(1000); + private final Frequency sameFrequency1 = Frequency.ofMHz(1000); + private final Frequency frequency2 = Frequency.ofGHz(1000); + private final Frequency sameFrequency2 = Frequency.ofGHz(1000); + private final Frequency moreSameFrequency2 = Frequency.ofTHz(1); + private final Frequency frequency3 = Frequency.ofTHz(193.1); + private final Frequency sameFrequency3 = Frequency.ofGHz(193100); + + /** + * Tests immutability of Frequency. + */ + @Test + public void testImmutability() { + ImmutableClassChecker.assertThatClassIsImmutable(Frequency.class); + } + + /** + * Tests equality of Frequency instances. + */ + @Test + public void testEquality() { + new EqualsTester() + .addEqualityGroup(frequency1, sameFrequency1) + .addEqualityGroup(frequency2, sameFrequency2, moreSameFrequency2) + .addEqualityGroup(frequency3, sameFrequency3) + .testEquals(); + } + + /** + * Tests the first object is less than the second object. + */ + @Test + public void testLessThan() { + assertThat(frequency1, is(lessThan(frequency2))); + assertThat(frequency1.isLessThan(frequency2), is(true)); + } + + @Test + public void testGreaterThan() { + assertThat(frequency2, is(greaterThan(frequency1))); + assertThat(frequency2.isGreaterThan(frequency1), is(true)); + } + + /** + * Tests add operation of two Frequencies. + */ + @Test + public void testAdd() { + Frequency low = Frequency.ofMHz(100); + Frequency high = Frequency.ofGHz(1); + Frequency expected = Frequency.ofMHz(1100); + + assertThat(low.add(high), is(expected)); + } + + /** + * Tests subtract operation of two Frequencies. + */ + @Test + public void testSubtract() { + Frequency high = Frequency.ofGHz(1); + Frequency low = Frequency.ofMHz(100); + Frequency expected = Frequency.ofMHz(900); + + assertThat(high.subtract(low), is(expected)); + } + + /** + * Tests multiply operation of Frequency. + */ + @Test + public void testMultiply() { + Frequency frequency = Frequency.ofMHz(1000); + long factor = 5; + Frequency expected = Frequency.ofGHz(5); + + assertThat(frequency.multiply(5), is(expected)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/GroupedThreadFactoryTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/GroupedThreadFactoryTest.java new file mode 100644 index 00000000..5be1cda4 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/GroupedThreadFactoryTest.java @@ -0,0 +1,53 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.Test; +import org.onlab.junit.TestTools; + +import static org.junit.Assert.*; + +/** + * Tests of the group thread factory. + */ +public class GroupedThreadFactoryTest { + + @Test + public void basics() { + GroupedThreadFactory a = GroupedThreadFactory.groupedThreadFactory("foo"); + GroupedThreadFactory b = GroupedThreadFactory.groupedThreadFactory("foo"); + assertSame("factories should be same", a, b); + + assertTrue("wrong toString", a.toString().contains("foo")); + Thread t = a.newThread(() -> TestTools.print("yo")); + assertSame("wrong group", a.threadGroup(), t.getThreadGroup()); + } + + @Test + public void hierarchical() { + GroupedThreadFactory a = GroupedThreadFactory.groupedThreadFactory("foo/bar"); + GroupedThreadFactory b = GroupedThreadFactory.groupedThreadFactory("foo/goo"); + GroupedThreadFactory p = GroupedThreadFactory.groupedThreadFactory("foo"); + + assertSame("groups should be same", p.threadGroup(), a.threadGroup().getParent()); + assertSame("groups should be same", p.threadGroup(), b.threadGroup().getParent()); + + assertEquals("wrong name", "foo/bar", a.threadGroup().getName()); + assertEquals("wrong name", "foo/goo", b.threadGroup().getName()); + assertEquals("wrong name", "foo", p.threadGroup().getName()); + } + +}
\ No newline at end of file diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/HexStringTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/HexStringTest.java new file mode 100644 index 00000000..27652123 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/HexStringTest.java @@ -0,0 +1,85 @@ +/* + * Copyright 2014 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.Test; + +import com.esotericsoftware.minlog.Log; + +import junit.framework.TestCase; + +/** + * Test of the Hexstring. + * + */ + +public class HexStringTest extends TestCase { + + @Test + public void testMarshalling() throws Exception { + String dpidStr = "00:00:00:23:20:2d:16:71"; + long dpid = HexString.toLong(dpidStr); + String testStr = HexString.toHexString(dpid); + TestCase.assertEquals(dpidStr, testStr); + } + + @Test + public void testToLong() { + String dpidStr = "3e:1f:01:fc:72:8c:63:31"; + long valid = 0x3e1f01fc728c6331L; + long testLong = HexString.toLong(dpidStr); + TestCase.assertEquals(valid, testLong); + } + + @Test + public void testToLongMSB() { + String dpidStr = "ca:7c:5e:d1:64:7a:95:9b"; + long valid = -3856102927509056101L; + long testLong = HexString.toLong(dpidStr); + TestCase.assertEquals(valid, testLong); + } + + @Test + public void testToLongError() { + String dpidStr = "09:08:07:06:05:04:03:02:01"; + try { + HexString.toLong(dpidStr); + fail("HexString.toLong() should have thrown a NumberFormatException"); + } catch (NumberFormatException expected) { + Log.info("HexString.toLong() have thrown a NumberFormatException"); + } + } + + @Test + public void testToStringBytes() { + byte[] dpid = {0, 0, 0, 0, 0, 0, 0, -1 }; + String valid = "00:00:00:00:00:00:00:ff"; + String testString = HexString.toHexString(dpid); + TestCase.assertEquals(valid, testString); + } + + @Test + public void testFromHexStringError() { + String invalidStr = "00:00:00:00:00:00:ffff"; + try { + HexString.fromHexString(invalidStr); + fail("HexString.fromHexString() should have thrown a NumberFormatException"); + } catch (NumberFormatException expected) { + Log.info("HexString.toLong() have thrown a NumberFormatException"); + } + } +} + diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/PositionalParameterStringFormatterTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/PositionalParameterStringFormatterTest.java new file mode 100644 index 00000000..9758511f --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/PositionalParameterStringFormatterTest.java @@ -0,0 +1,61 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onlab.util; + +import static org.junit.Assert.*; +import static org.onlab.util.PositionalParameterStringFormatter.format; + +import org.junit.Test; + +public class PositionalParameterStringFormatterTest { + + @Test + public void testFormat0() { + String fmt = "Some string 1 2 3"; + assertEquals("Some string 1 2 3", format(fmt)); + } + + @Test + public void testFormat1() { + String fmt = "Some string {} 2 3"; + assertEquals("Some string 1 2 3", format(fmt, 1)); + } + + @Test + public void testFormat2() { + String fmt = "Some string {} 2 {}"; + assertEquals("Some string 1 2 3", format(fmt, 1, "3")); + } + + @Test + public void testFormatNull() { + String fmt = "Some string {} 2 {}"; + assertEquals("Some string 1 2 null", format(fmt, 1, null)); + } + + @Test + public void testFormatExtraBracket() { + String fmt = "Some string {} 2 {}"; + assertEquals("Some string 1 2 {}", format(fmt, 1)); + } + + @Test + public void testFormatMissingBracket() { + String fmt = "Some string 1 2 3"; + assertEquals("Some string 1 2 3", format(fmt, 7)); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/RetryingFunctionTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/RetryingFunctionTest.java new file mode 100644 index 00000000..4b08d2fc --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/RetryingFunctionTest.java @@ -0,0 +1,94 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Unit tests for RetryingFunction. + * + */ +public class RetryingFunctionTest { + + private int round; + + @Before + public void setUp() { + round = 1; + } + + @After + public void tearDown() { + round = 0; + } + + @Test(expected = RetryableException.class) + public void testNoRetries() { + new RetryingFunction<>(this::succeedAfterOneFailure, RetryableException.class, 0, 10).apply(null); + } + + @Test + public void testSuccessAfterOneRetry() { + new RetryingFunction<>(this::succeedAfterOneFailure, RetryableException.class, 1, 10).apply(null); + } + + @Test(expected = RetryableException.class) + public void testFailureAfterOneRetry() { + new RetryingFunction<>(this::succeedAfterTwoFailures, RetryableException.class, 1, 10).apply(null); + } + + @Test + public void testFailureAfterTwoRetries() { + new RetryingFunction<>(this::succeedAfterTwoFailures, RetryableException.class, 2, 10).apply(null); + } + + @Test(expected = NonRetryableException.class) + public void testFailureWithNonRetryableFailure() { + new RetryingFunction<>(this::failCompletely, RetryableException.class, 2, 10).apply(null); + } + + private String succeedAfterOneFailure(String input) { + if (round++ <= 1) { + throw new RetryableException(); + } else { + return "pass"; + } + } + + private String succeedAfterTwoFailures(String input) { + if (round++ <= 2) { + throw new RetryableException(); + } else { + return "pass"; + } + } + + private String failCompletely(String input) { + if (round++ <= 1) { + throw new NonRetryableException(); + } else { + return "pass"; + } + } + + private class RetryableException extends RuntimeException { + } + + private class NonRetryableException extends RuntimeException { + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/SharedExecutorsTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/SharedExecutorsTest.java new file mode 100644 index 00000000..1730ca1f --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/SharedExecutorsTest.java @@ -0,0 +1,54 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.Test; + +import java.util.concurrent.ExecutorService; + +import static org.junit.Assert.*; + +/** + * Tests of the SharedExecutors Test. + */ +public class SharedExecutorsTest { + + @Test + public void singleThread() { + ExecutorService a = SharedExecutors.getSingleThreadExecutor(); + assertNotNull("ExecutorService must not be null", a); + ExecutorService b = SharedExecutors.getSingleThreadExecutor(); + assertSame("factories should be same", a, b); + + } + + @Test + public void poolThread() { + ExecutorService a = SharedExecutors.getPoolThreadExecutor(); + assertNotNull("ExecutorService must not be null", a); + ExecutorService b = SharedExecutors.getPoolThreadExecutor(); + assertSame("factories should be same", a, b); + + } + + @Test + public void timer() { + java.util.Timer a = SharedExecutors.getTimer(); + assertNotNull("Timer must not be null", a); + java.util.Timer b = SharedExecutors.getTimer(); + assertSame("factories should be same", a, b); + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/SlidingWindowCounterTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/SlidingWindowCounterTest.java new file mode 100644 index 00000000..c15cc8a6 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/SlidingWindowCounterTest.java @@ -0,0 +1,105 @@ +/* + * Copyright 2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.After; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; + +import static junit.framework.TestCase.fail; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +/** + * Unit tests for the sliding window counter. + */ + +@Ignore("Disable these for now because of intermittent load related failures on Jenkins runs.") +public class SlidingWindowCounterTest { + + private SlidingWindowCounter counter; + + @Before + public void setUp() { + counter = new SlidingWindowCounter(2); + } + + @After + public void tearDown() { + counter.destroy(); + } + + @Test + public void testIncrementCount() { + assertEquals(0, counter.get(1)); + assertEquals(0, counter.get(2)); + counter.incrementCount(); + assertEquals(1, counter.get(1)); + assertEquals(1, counter.get(2)); + counter.incrementCount(2); + assertEquals(3, counter.get(2)); + } + + @Test + public void testSlide() { + counter.incrementCount(); + counter.advanceHead(); + assertEquals(0, counter.get(1)); + assertEquals(1, counter.get(2)); + counter.incrementCount(2); + assertEquals(2, counter.get(1)); + assertEquals(3, counter.get(2)); + } + + @Test + public void testWrap() { + counter.incrementCount(); + counter.advanceHead(); + counter.incrementCount(2); + counter.advanceHead(); + assertEquals(0, counter.get(1)); + assertEquals(2, counter.get(2)); + counter.advanceHead(); + assertEquals(0, counter.get(1)); + assertEquals(0, counter.get(2)); + + } + + @Test + public void testCornerCases() { + try { + counter.get(3); + fail("Exception should have been thrown"); + } catch (IllegalArgumentException e) { + assertTrue(true); + } + + try { + new SlidingWindowCounter(0); + fail("Exception should have been thrown"); + } catch (IllegalArgumentException e) { + assertTrue(true); + } + + try { + new SlidingWindowCounter(-1); + fail("Exception should have been thrown"); + } catch (IllegalArgumentException e) { + assertTrue(true); + } + } +} diff --git a/framework/src/onos/utils/misc/src/test/java/org/onlab/util/ToolsTest.java b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/ToolsTest.java new file mode 100644 index 00000000..56f0f957 --- /dev/null +++ b/framework/src/onos/utils/misc/src/test/java/org/onlab/util/ToolsTest.java @@ -0,0 +1,76 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onlab.util; + +import org.junit.Test; +import org.onlab.junit.TestTools; + +import java.util.concurrent.ThreadFactory; + +import static org.junit.Assert.*; +import static org.onlab.junit.TestTools.assertAfter; + +/** + * Test of the miscellaneous tools. + */ +public class ToolsTest { + + @Test + public void fromHex() throws Exception { + assertEquals(15, Tools.fromHex("0f")); + assertEquals(16, Tools.fromHex("10")); + assertEquals(65535, Tools.fromHex("ffff")); + assertEquals(4096, Tools.fromHex("1000")); + assertEquals(0xffffffffffffffffL, Tools.fromHex("ffffffffffffffff")); + } + + @Test + public void toHex() throws Exception { + assertEquals("0f", Tools.toHex(15, 2)); + assertEquals("ffff", Tools.toHex(65535, 4)); + assertEquals("1000", Tools.toHex(4096, 4)); + assertEquals("000000000000000f", Tools.toHex(15)); + assertEquals("ffffffffffffffff", Tools.toHex(0xffffffffffffffffL)); + + } + + @Test + public void namedThreads() { + ThreadFactory f = Tools.namedThreads("foo-%d"); + Thread t = f.newThread(() -> TestTools.print("yo")); + assertTrue("wrong pattern", t.getName().startsWith("foo-")); + } + + @Test + public void groupedThreads() { + ThreadFactory f = Tools.groupedThreads("foo/bar-me", "foo-%d"); + Thread t = f.newThread(() -> TestTools.print("yo")); + assertTrue("wrong pattern", t.getName().startsWith("foo-bar-me-foo-")); + assertTrue("wrong group", t.getThreadGroup().getName().equals("foo/bar-me")); + } + + @Test + public void exceptionHandler() throws InterruptedException { + ThreadFactory f = Tools.namedThreads("foo"); + Thread t = f.newThread(() -> { + throw new IllegalStateException("BOOM!"); + }); + assertNotNull("thread should have exception handler", t.getUncaughtExceptionHandler()); + t.start(); + assertAfter(100, () -> assertEquals("incorrect thread state", Thread.State.TERMINATED, t.getState())); + } + +} |