diff --git a/src/test/java/net/onrc/onos/core/topology/TopologyImplTest.java b/src/test/java/net/onrc/onos/core/topology/TopologyImplTest.java
new file mode 100644
index 0000000..2501425
--- /dev/null
+++ b/src/test/java/net/onrc/onos/core/topology/TopologyImplTest.java
@@ -0,0 +1,244 @@
+package net.onrc.onos.core.topology;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Iterator;
+
+import net.floodlightcontroller.util.MACAddress;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Unit tests for the TopologyImpl Class in the Topology module.
+ * These test cases check the sanity of getSwitch/removeSwitch,
+ * getLink/removeLink, getDevice/removeDevice, and getPort functions and
+ * verify the data objects inside the global graphDB through a injected network.
+ * The injected network has a ring topology with a large number of switches (configurable), and
+ * each switch is associated with one device and connected to two other switches.
+ */
+public class TopologyImplTest {
+    private TopologyImpl testTopology;
+    private static final Long SWITCH_HOST_PORT = 1L;
+    private static final Long SWITCH_PORT_1 = 2L;
+    private static final Long SWITCH_PORT_2 = 3L;
+
+    // Set the test network size, it should be larger than 3
+    private static final long TEST_SWITCH_NUM = 100L;
+
+    @Before
+    public void setUp() throws Exception {
+        // Create the injected network first
+        testTopology = new TopologyImpl();
+
+        // Create a number of switches and install two ports for each switch
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            SwitchImpl testSwitch = new SwitchImpl(testTopology, switchID);
+            testSwitch.addPort(SWITCH_PORT_1);
+            testSwitch.addPort(SWITCH_PORT_2);
+            testTopology.putSwitch(testSwitch);
+
+            // Create a host for each switch
+            MACAddress devMac = MACAddress.valueOf(switchID);
+            DeviceImpl testHost = new DeviceImpl(testTopology, devMac);
+            testHost.addAttachmentPoint(testSwitch.addPort(SWITCH_HOST_PORT));
+            testTopology.putDevice(testHost);
+        }
+
+        // Create one bidirectional link b/w two switches to construct a ring topology
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            LinkImpl testLinkEast = new LinkImpl(testTopology,
+                    testTopology.getPort(switchID, SWITCH_PORT_2),
+                    testTopology.getPort(switchID % TEST_SWITCH_NUM + 1, SWITCH_PORT_1)
+                    );
+            LinkImpl testLinkWest = new LinkImpl(testTopology,
+                    testTopology.getPort(switchID % TEST_SWITCH_NUM + 1, SWITCH_PORT_1),
+                    testTopology.getPort(switchID, SWITCH_PORT_2)
+                    );
+            testTopology.putLink(testLinkEast);
+            testTopology.putLink(testLinkWest);
+        }
+    }
+
+    @After
+    public void tearDown() throws Exception {
+
+    }
+
+    /**
+     * Test the result of getSwitch function.
+     */
+    @Test
+    public void testGetSwitch() {
+        // Verify the switch is in the graphDB
+        assertNotNull(testTopology.getSwitch(TEST_SWITCH_NUM - 1));
+
+        // Verify there is no such switch in the graphDB
+        assertNull(testTopology.getSwitch(TEST_SWITCH_NUM + 1));
+        long swID = 0;
+        long index = 0;
+        Iterator<Switch> itr =  testTopology.getSwitches().iterator();
+        while (itr.hasNext()) {
+            index++;
+            swID = itr.next().getDpid();
+            assertTrue(swID >= 1 && swID <= TEST_SWITCH_NUM);
+        }
+
+        // Verify the total number of switches
+        assertEquals(TEST_SWITCH_NUM, index);
+    }
+
+    /**
+     * Test the result of getPort function.
+     */
+    @Test
+    public void testGetPort() {
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            // Verify ports are in the graphDB
+            assertNotNull(testTopology.getSwitch(switchID).getPort(SWITCH_PORT_1));
+            assertNotNull(testTopology.getSwitch(switchID).getPort(SWITCH_PORT_2));
+
+            // Verify there is no such port in the graphDB
+            assertNull(testTopology.getSwitch(switchID).getPort(SWITCH_PORT_2 + 1));
+        }
+    }
+
+    /**
+     * Test the result of getLink function.
+     */
+    @Test
+    public void testGetLink() {
+        long sw1ID = 1L;
+        long sw2ID = 3L;
+
+        // Verify there is no such link b/w these two switches
+        assertNull((testTopology.getSwitch(sw1ID)).getLinkToNeighbor(sw2ID));
+        long index = 0;
+        Iterator<Link> itr = testTopology.getLinks().iterator();
+        while (itr.hasNext()) {
+            index++;
+            Link objectLink = itr.next();
+            Switch srcSw = (objectLink.getSrcSwitch());
+            Switch dstSw = (objectLink.getDstSwitch());
+            if (srcSw.getDpid() < TEST_SWITCH_NUM && dstSw.getDpid() < TEST_SWITCH_NUM) {
+                // Verify the link relationship
+                assertTrue((srcSw.getDpid() == dstSw.getDpid() - 1
+                        || (srcSw.getDpid() == dstSw.getDpid() + 1)));
+            }
+        }
+
+        // Verify the total number of links
+        assertEquals(TEST_SWITCH_NUM * 2, index);
+    }
+
+    /**
+     * Test the result of getOutgoingLink function.
+     */
+    @Test
+    public void testGetOutgoingLink() {
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            assertNotNull(testTopology.getOutgoingLink(switchID, SWITCH_PORT_1));
+            assertNotNull(testTopology.getOutgoingLink(switchID, SWITCH_PORT_2));
+
+            // Verify there is no such link in the graphDB
+            assertNull(testTopology.getOutgoingLink(switchID, SWITCH_PORT_1 + 2));
+        }
+    }
+
+    /**
+     * Test the result of getIncomingLink function.
+     */
+    @Test
+    public void testGetIncomingLink() {
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            // Verify the links are in the graphDB
+            assertNotNull(testTopology.getIncomingLink(switchID, SWITCH_PORT_1));
+            assertNotNull(testTopology.getIncomingLink(switchID, SWITCH_PORT_2));
+
+            // Verify there is no such link in the graphDB
+            assertNull(testTopology.getIncomingLink(switchID, SWITCH_PORT_1 + 2));
+        }
+    }
+
+    /**
+     * Test the result of getDeviceByMac function.
+     */
+    @Test
+    public void testGetDeviceByMac() {
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            MACAddress devMac = MACAddress.valueOf(switchID);
+
+            // Verify the device is in the graphDB
+            assertNotNull(testTopology.getDeviceByMac(devMac));
+        }
+    }
+
+    /**
+     * Test the result of removeDevice function.
+     */
+    @Test
+    public void testRemoveDevice() {
+        int devCount = 0;
+        Iterator<Device> itr = testTopology.getDevices().iterator();
+        while (itr.hasNext()) {
+            Device currDev = itr.next();
+            testTopology.removeDevice(currDev);
+            testTopology.getDeviceByMac(currDev.getMacAddress());
+            devCount++;
+        }
+
+        // Verify all hosts have been removed successfully
+        assertEquals(TEST_SWITCH_NUM, devCount);
+    }
+
+    /**
+     * Test the result of removeLink function.
+     */
+    @Test
+    public void testRemoveLink() {
+        long index = 0;
+        Iterator<Link> itr = testTopology.getLinks().iterator();
+        while (itr.hasNext()) {
+            index++;
+            Link objectLink = itr.next();
+            Switch srcSw = (objectLink.getSrcSwitch());
+            Port srcPort = objectLink.getSrcPort();
+            Switch dstSw = (objectLink.getDstSwitch());
+            Port dstPort = objectLink.getDstPort();
+            testTopology.removeLink(objectLink);
+
+            // Verify the link was removed successfully
+            assertNull(testTopology.getLink(srcSw.getDpid(), srcPort.getNumber(),
+                    dstSw.getDpid(), dstPort.getNumber()));
+        }
+
+        // Verify all links have been removed successfully
+        assertEquals(TEST_SWITCH_NUM * 2, index);
+    }
+
+    /**
+     * Test the result of removeSwitch function.
+     */
+    @Test
+    public void testRemoveSwitch() {
+        for (long switchID = 1; switchID <= TEST_SWITCH_NUM; switchID++) {
+            Iterator<Device> itr = testTopology.getSwitch(switchID).getDevices().iterator();
+            while (itr.hasNext()) {
+                testTopology.removeDevice((Device) itr);
+            }
+            testTopology.removeSwitch(switchID);
+
+            // Verify the switch has been removed from the graphDB successfully
+            assertNull(testTopology.getSwitch(switchID));
+        }
+
+        // Verify all switches have been removed successfully
+        Iterator<Switch> itr = testTopology.getSwitches().iterator();
+        assertFalse(itr.hasNext());
+    }
+}