X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fadsal%2Fsal%2Fapi%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fcore%2FPathTest.java;fp=opendaylight%2Fadsal%2Fsal%2Fapi%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fcore%2FPathTest.java;h=0ea88558ded7e0113e283b520f61bc426aa735ea;hb=42c32160bfd41de57189bb246fec5ffb48ed8e9e;hp=0000000000000000000000000000000000000000;hpb=edf5bfcee83c750853253ccfd991ba7000f5f65b;p=controller.git

diff --git a/opendaylight/adsal/sal/api/src/test/java/org/opendaylight/controller/sal/core/PathTest.java b/opendaylight/adsal/sal/api/src/test/java/org/opendaylight/controller/sal/core/PathTest.java
new file mode 100644
index 0000000000..0ea88558de
--- /dev/null
+++ b/opendaylight/adsal/sal/api/src/test/java/org/opendaylight/controller/sal/core/PathTest.java
@@ -0,0 +1,341 @@
+
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+/**
+ * @file   PathTest.java
+ *
+ * @brief  Unit Tests for Path element
+ *
+ * Unit Tests for Path element
+ */
+package org.opendaylight.controller.sal.core;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Arrays;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PathTest {
+    @Test
+    public void testPathValid() {
+        List<Edge> edges = null;
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x4), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+            NodeConnector c2 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
+                    new Short((short) 0xCAFE), n1);
+
+            Node n2 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
+            NodeConnector c3 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
+                    new String("towardOF1"), n2);
+            NodeConnector c4 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n2);
+
+            Node n3 = new Node(Node.NodeIDType.ONEPK, new String("Router2"));
+            NodeConnector c5 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n3);
+
+            Edge e0 = new Edge(c0, c1);
+            Edge e1 = new Edge(c1, c2);
+            Edge e2 = new Edge(c2, c3);
+            Edge e3 = new Edge(c3, c4);
+            Edge e4 = new Edge(c4, c5);
+            // actually need a LinkedList because we're going to .remove()
+            edges = new LinkedList<Edge>(Arrays.asList(e0, e1, e2, e3, e4));
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+
+        try {
+            @SuppressWarnings("unused")
+            Path res = new Path(edges);
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+
+        // Now lets disconnect on edge so to create a disconnected
+        // path, the constructor should catch that and should not
+        // create the path
+        edges.remove(2);
+
+        try {
+            @SuppressWarnings("unused")
+            Path res = new Path(edges);
+            // Exception is expected if not raised test will fail
+            Assert.assertTrue(false);
+        } catch (ConstructionException e) {
+        }
+    }
+
+    @Test
+    public void testPathComparison() {
+        List<Edge> edges1 = null;
+        Path path1 = null;
+        List<Edge> edges2 = null;
+        Path path2 = null;
+        List<Edge> edges3 = null;
+        Path path3 = null;
+
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x4), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+            NodeConnector c2 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
+                    new Short((short) 0xCAFE), n1);
+
+            Node n2 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
+            NodeConnector c3 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
+                    new String("towardOF1"), n2);
+            NodeConnector c4 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n2);
+
+            Node n3 = new Node(Node.NodeIDType.ONEPK, new String("Router2"));
+            NodeConnector c5 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n3);
+
+            Edge e0 = new Edge(c0, c1);
+            Edge e1 = new Edge(c1, c2);
+            Edge e2 = new Edge(c2, c3);
+            Edge e3 = new Edge(c3, c4);
+            Edge e4 = new Edge(c4, c5);
+            edges1 = Arrays.asList(e0, e1, e2, e3, e4);
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x4), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+            NodeConnector c2 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
+                    new Short((short) 0xCAFE), n1);
+
+            Node n2 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
+            NodeConnector c3 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
+                    new String("towardOF1"), n2);
+            NodeConnector c4 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n2);
+
+            Node n3 = new Node(Node.NodeIDType.ONEPK, new String("Router2"));
+            NodeConnector c5 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n3);
+
+            Edge e0 = new Edge(c0, c1);
+            Edge e1 = new Edge(c1, c2);
+            Edge e2 = new Edge(c2, c3);
+            Edge e3 = new Edge(c3, c4);
+            Edge e4 = new Edge(c4, c5);
+            edges2 = Arrays.asList(e0, e1, e2, e3, e4);
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x5), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+            NodeConnector c2 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
+                    new Short((short) 0xCAFE), n1);
+
+            Node n2 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
+            NodeConnector c3 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
+                    new String("towardOF1"), n2);
+            NodeConnector c4 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n2);
+
+            Node n3 = new Node(Node.NodeIDType.ONEPK, new String("Router2"));
+            NodeConnector c5 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n3);
+
+            Edge e0 = new Edge(c0, c1);
+            Edge e1 = new Edge(c1, c2);
+            Edge e2 = new Edge(c2, c3);
+            Edge e3 = new Edge(c3, c4);
+            Edge e4 = new Edge(c4, c5);
+            edges3 = Arrays.asList(e0, e1, e2, e3, e4);
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+
+        try {
+            path1 = new Path(edges1);
+            path2 = new Path(edges2);
+            path3 = new Path(edges3);
+
+            System.out.println("Path1: " + path1);
+            System.out.println("Path2: " + path2);
+            System.out.println("Path3: " + path3);
+
+            // Make sure the path are equals
+            Assert.assertTrue(path1.equals(path2));
+
+            // Make sure the path are marked as different
+            Assert.assertTrue(!path1.equals(path3));
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+    }
+
+    @Test
+    public void testPathEmpty() {
+        try {
+            @SuppressWarnings("unused")
+            Path path = new Path(new LinkedList<Edge>());
+            // Exception is expected if not raised test will fail
+            Assert.assertTrue(false);
+        } catch (ConstructionException e) {
+        }
+    }
+
+    @Test
+    public void testPathOneElement() {
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x5), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+
+            Edge e0 = new Edge(c0, c1);
+
+            @SuppressWarnings("unused")
+            Path path = new Path(Arrays.asList(e0));
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+    }
+
+    @Test
+    public void testPathGetNodes() {
+        // Test on >2 edges paths
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x4), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+            NodeConnector c2 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
+                    new Short((short) 0xCAFE), n1);
+
+            Node n2 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
+            NodeConnector c3 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
+                    new String("towardOF1"), n2);
+            NodeConnector c4 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n2);
+
+            Node n3 = new Node(Node.NodeIDType.ONEPK, new String("Router2"));
+            NodeConnector c5 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
+                            "Gi1/0/1"), n3);
+
+            Edge e0 = new Edge(c0, c1);
+            Edge e1 = new Edge(c1, c2);
+            Edge e2 = new Edge(c2, c3);
+            Edge e3 = new Edge(c3, c4);
+            Edge e4 = new Edge(c4, c5);
+            List<Edge> edges = Arrays.asList(e0, e1, e2, e3, e4);
+            Path path = new Path(edges);
+
+            // Test start node
+            Assert.assertTrue(path.getStartNode().equals(n0));
+
+            // Test end node
+            Assert.assertTrue(path.getEndNode().equals(n3));
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+
+        // Test on 1 edge path
+        try {
+            Node n0 = new Node(Node.NodeIDType.OPENFLOW, new Long(40L));
+            NodeConnector c0 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x4), n0);
+
+            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
+            NodeConnector c1 = new NodeConnector(
+                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
+                            (short) 0x1), n1);
+
+            Edge e0 = new Edge(c0, c1);
+            List<Edge> edges = Arrays.asList(e0);
+            Path path = new Path(edges);
+
+            // Test start node
+            Assert.assertTrue(path.getStartNode().equals(n0));
+
+            // Test end node
+            Assert.assertTrue(path.getEndNode().equals(n1));
+        } catch (ConstructionException e) {
+            // Exception is NOT expected if raised test will fail
+            Assert.assertTrue(false);
+        }
+    }
+}