/*
 * 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   NodeConnectorTest.java
 *
 * @brief  Unit Tests for NodeConnector element
 *
 * Unit Tests for NodeConnector element
 */
package org.opendaylight.controller.sal.core;

import java.util.UUID;

import org.junit.Assert;
import org.junit.Test;

public class NodeConnectorTest {
    @Test
    public void testNodeConnectorOpenFlowOfWrongType() {
        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            @SuppressWarnings("unused")
            NodeConnector of1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new String(
                            "0xDEADBEEFCAFE0001L"), n1);

            // If we reach this point the exception was not raised
            // which should have been the case
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
            // If we reach this point the exception has been raised
            // and so test passed
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(true);
        }
    }

    @Test
    public void testNodeConnectorONEPKOfWrongType() {
        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            @SuppressWarnings("unused")
            NodeConnector onepk1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new Long(
                            0xDEADBEEFCAFE0001L), n1);

            // If we reach this point the exception was not raised
            // which should have been the case
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
            // If we reach this point the exception has been raised
            // and so test passed
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(true);
        }
    }

    @Test
    public void testNodeConnectorPCEPOfWrongType() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            @SuppressWarnings("unused")
            NodeConnector pcep1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Long(
                            0xDEADBEEFCAFE0001L), n1);

            // If we reach this point the exception was not raised
            // which should have been the case
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
            // If we reach this point the exception has been raised
            // and so test passed
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(true);
        }
    }

    @Test
    public void testNodeConnectorOpenFlowOfCorrectType() {
        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector of1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n1);

            // If we reach this point the exception has not been
            // raised so we passed the test
            System.out.println("Got node:" + of1);
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testNodeConnectorONEPKOfCorrectType() {
        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector onepk1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);

            // If we reach this point the exception has not been
            // raised so we passed the test
            System.out.println("Got node:" + onepk1);
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testNodeConnectorPCEPOfCorrectType() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector pcep1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xDEADBEEF), n1);

            // If we reach this point the exception has not been
            // raised so we passed the test
            System.out.println("Got node:" + pcep1);
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoOpenFlowNodeConnectorEquals() {
        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector of1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n1);
            NodeConnector of2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n1);

            Assert.assertTrue(of1.equals(of2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoONEPKNodeConnectorEquals() {
        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector onepk1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);
            NodeConnector onepk2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);

            Assert.assertTrue(onepk1.equals(onepk2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoPCEPNodeConnectorEquals() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector pcep1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xDEADBEEF), n1);
            NodeConnector pcep2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xDEADBEEF), n1);

            Assert.assertTrue(pcep1.equals(pcep2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoOpenFlowNodeConnectorDifferents() {
        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector of1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n1);
            NodeConnector of2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xBEEF), n1);

            Assert.assertTrue(!of1.equals(of2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoONEPKNodeConnectorDifferents() {
        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector onepk1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);
            NodeConnector onepk2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/2"), n1);

            Assert.assertTrue(!onepk1.equals(onepk2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoPCEPNodeConnectorDifferents() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector pcep1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xDEADBEEF), n1);
            NodeConnector pcep2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xCAFECAFE), n1);

            Assert.assertTrue(!pcep1.equals(pcep2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoOpenFlowNodeConnectorDifferentsNodes() {
        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            Node n2 = new Node(Node.NodeIDType.OPENFLOW, new Long(111L));
            NodeConnector of1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n1);
            NodeConnector of2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n2);

            Assert.assertTrue(!of1.equals(of2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoONEPKNodeConnectorDifferentsNodes() {
        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            Node n2 = new Node(Node.NodeIDType.ONEPK, new String("Router2"));
            NodeConnector onepk1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);
            NodeConnector onepk2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n2);

            Assert.assertTrue(!onepk1.equals(onepk2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testTwoPCEPNodeConnectorDifferentsNodes() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            Node n2 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 1L));
            NodeConnector pcep1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xDEADBEEF), n1);
            NodeConnector pcep2 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(
                            0xDEADBEEF), n2);

            Assert.assertTrue(!pcep1.equals(pcep2));
        } catch (ConstructionException e) {
            // If we reach this point the exception was raised
            // which is not expected
            Assert.assertTrue(false);
        }
    }

    @SuppressWarnings("unused")
    @Test
    public void testIncompatibleNodes() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2PCEP, new Short(
                            (short) 0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
                    new Short((short) 0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2PCEP, new String(
                            "towardPCEP1"), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
                    new String("towardPCEP1"), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(0), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2ONEPK,
                    new Integer(0), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2OPENFLOW,
                    new Integer(0), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2PCEP, new Short(
                            (short) 0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
                    new Short((short) 0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2PCEP, new String(
                            "towardPCEP1"), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
                    new String("towardPCEP1"), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2ONEPK,
                    new Integer(0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2OPENFLOW,
                    new Integer(0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2PCEP, new Short(
                            (short) 0), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
                    new Short((short) 0), n1);
        } catch (ConstructionException e) {
            // Exception is NOT expected if raised test will fail
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2PCEP, new String(
                            "towardPCEP1"), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
                    new String("towardPCEP1"), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2ONEPK,
                    new Integer(0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2OPENFLOW,
                    new Integer(0), n1);
            // Exception is expected if not raised test will fail
            Assert.assertTrue(false);
        } catch (ConstructionException e) {
        }
    }

    @Test
    public void testConversionToStringAndBack() {
        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(
                    0xDEADBEEFCAFE0001L, 0xDEADBEEFCAFE0002L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2ONEPK, new Integer(
                            0xDEADBEEF), n1);
            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(
                    0xDEADBEEFCAFE0001L, 0xDEADBEEFCAFE0002L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP2OPENFLOW,
                    new Integer(0x10), n1);
            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.PCEP, new UUID(
                    0xDEADBEEFCAFE0001L, 0xDEADBEEFCAFE0002L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.PCEP, new Integer(0x10),
                    n1);
            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2PCEP, new String(
                            "towardPCEP1"), n1);

            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK2OPENFLOW,
                    new String("towardOPENFLOW1"), n1);

            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ONEPK, new String(
                            "Gi1/0/1"), n1);

            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(
                    0xDEADBEEFCAFE0001L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xCAFE), n1);

            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(0x100L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2PCEP, new Short(
                            (short) 0x10), n1);

            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n1 = new Node(Node.NodeIDType.OPENFLOW, new Long(0x100L));
            NodeConnector nc1 = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW2ONEPK,
                    new Short((short) 0x11), n1);

            String nc1Str = nc1.toString();
            System.out.println("NodeConnector String = " + nc1Str);
            NodeConnector nc1FromStr = NodeConnector.fromString(nc1Str);

            // Make sure we got a nodeconnector
            Assert.assertTrue(nc1FromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc1.equals(nc1FromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testNodeConnectorSpecialType() {
        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.CONTROLLER,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ALL,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.SWSTACK,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.HWPATH,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.CONTROLLER,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ALL,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.SWSTACK,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.HWPATH,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.CONTROLLER,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ALL,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.SWSTACK,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.HWPATH,
                    NodeConnector.SPECIALNODECONNECTORID, n);
            System.out.println("Special NC = " + specialNc);
            // We expect to reach this point succesfully
            Assert.assertTrue(true);
        } catch (ConstructionException e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testToStringConversionForOpenFlow() {
        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0x2AB), n);

            NodeConnector ofFromStr = null;

            ofFromStr = NodeConnector.fromStringNoNode("0x2ab", n);

            // Make sure we got a nodeconnector
            Assert.assertTrue(ofFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc.equals(ofFromStr));

            ofFromStr = NodeConnector.fromStringNoNode("0x2AB", n);

            // Make sure we got a nodeconnector
            Assert.assertTrue(ofFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc.equals(ofFromStr));

            ofFromStr = NodeConnector.fromStringNoNode("683", n);

            // Make sure we got a nodeconnector
            Assert.assertTrue(ofFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc.equals(ofFromStr));
        } catch (Exception e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector nc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.OPENFLOW, new Short(
                            (short) 0xcafe), n);

            NodeConnector ofFromStr = null;

            ofFromStr = NodeConnector.fromStringNoNode("-13570", n);

            // Make sure we got a nodeconnector
            Assert.assertTrue(ofFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(nc.equals(ofFromStr));
        } catch (Exception e) {
            // If this expection is raised the test is failing
            System.out.println("Got exception as expected!:" + e);
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testConversionToStringAndBackSpecialPorts() {
        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.CONTROLLER,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ALL,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.HWPATH,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.OPENFLOW, new Long(110L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.SWSTACK,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.CONTROLLER,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ALL,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.HWPATH,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.PCEP, new UUID(0L, 0L));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.SWSTACK,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.CONTROLLER,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.ALL,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.HWPATH,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }

        try {
            Node n = new Node(Node.NodeIDType.ONEPK, new String("Router1"));
            NodeConnector specialNc = new NodeConnector(
                    NodeConnector.NodeConnectorIDType.SWSTACK,
                    NodeConnector.SPECIALNODECONNECTORID, n);

            String specialNcStr = specialNc.toString();
            System.out.println("NodeConnector String obtained= " + specialNc);
            NodeConnector specialNcFromStr = NodeConnector
                    .fromString(specialNcStr);

            // Make sure we got a nodeconnector
            Assert.assertTrue(specialNcFromStr != null);

            // Now the converted nodeconnector need to be the same of the
            // original one
            Assert.assertTrue(specialNc.equals(specialNcFromStr));
        } catch (ConstructionException e) {
            // Fail if exception raised
            Assert.assertTrue(false);
        }
    }
}