diff --git a/TestON/tests/CHOtest/README b/TestON/tests/CHOtest/README
index 4b92d14..ab402f7 100644
--- a/TestON/tests/CHOtest/README
+++ b/TestON/tests/CHOtest/README
@@ -1 +1,40 @@
-#This README file be updated soon
+CHO TEST
+
+Summary:
+        This is a long-term regression test that is aimed to run
+        for weeks at a time. It's goal is to find memory leaks or bugs that
+        otherwise cannot be easily seen with short-term tests. The following
+        is an overview of the steps that are performed in this test.
+        Steps:
+        - Discover IPv4 and IPv6 hosts
+        - Add host intents
+        - Ping all hosts
+        - Bring links down
+        - Ping all hosts
+        - Bring links back up
+        - Ping all hosts
+        - remove intents
+
+        These steps are iterated over and over again. The number of iterations can
+        be found in the params file.
+
+Topology:
+        Att topology - 25 switches and 25 hosts and its structure is designed to simulate
+                        a real world configuration,
+        Chordal topology - 25 swithces and 25 hosts and because of its chordal graph structure,
+                            it's particulary useful in testing the rerouting capability of ONOS.
+        Leaf-spine topology - 78 switches and 68 hosts and designed to simulate modern data centers.
+
+Pre-requisites:
+        To run out-of-the box this test requires 3 NODES. The cell file
+        must be passed through the startup test command, e.g.,
+
+            ./cli.py run CHOtest onoscell <cell name>.
+
+        Passwordless login must be set from TestStation "admin" root user.
+        This test relies on the topology files to start Mininet located in
+        the Dependency folder. Be sure to check that each topology file can
+        be loaded properly by Mininet by using this command:
+
+            sudo ~/<Dependency path>/<topology name>
+
diff --git a/TestON/tests/FUNCflow/README b/TestON/tests/FUNCflow/README
new file mode 100644
index 0000000..018e42d
--- /dev/null
+++ b/TestON/tests/FUNCflow/README
@@ -0,0 +1,49 @@
+FUNCflow test suite
+
+Summary:
+        This test suite consists of basic flow-rule based functionality testing.
+        The main goal of this test suite is to verify that the flow subsytem is
+        compiling flows correctly. We verify each flow by utilizing Scapy, a
+        Python library for generating and sending packets. The following is an
+        overview of the test.
+        Steps:
+            - Discover hosts
+            - add specific flow
+            - verify flow
+            - remove flow
+
+        Each repetion of the steps tests a specific selector. Here is a list
+        of the selectors that are being tested:
+        Selectors:
+            - MAC
+            - IPv4
+            - VLAN
+            - MPLS
+            - TCP
+            - UDP
+
+        We verify the selectors by sending a tailor made packet through the
+        two hosts. If the packet was recieved, then the flow was compiled
+        correctly.
+
+Topology:
+        The topology consists of one switch with four hosts connected to it.
+        Two hosts are regular IPv4 hosts, while the other two are hosts with
+        vlan interfaces to test the vlan selector.
+
+Required:
+        This test requires Mininet topology file topo-flow.py located in the
+        dependency folder. The topology consistes of VLAN hosts, so you will
+        need to install the VLAN module. You will also need to install the
+        Python module, Scapy.
+
+VLAN configuration:
+        Execute command:
+            $ sudo apt-get install vlan
+        Configuration:
+            $ sudo modprobe 8021q
+        NOTE:To make this configuration permanent
+            $ sudo su -c 'echo "8021q" >> /etc/modules'
+
+Scapy install:
+    sudo apt-get install Scapy
diff --git a/TestON/tests/FUNCintent/README b/TestON/tests/FUNCintent/README
index ce4e99f..e97d0d3 100644
--- a/TestON/tests/FUNCintent/README
+++ b/TestON/tests/FUNCintent/README
@@ -29,6 +29,10 @@
         including VLAN hosts. Therefore you need to install VLAN module to build
         the topology correctly.
 
+NOTE:
+    This test is being updated to use Scapy for host discovery and verification of flows.
+    So, Scapy will be required to run the test in the future.
+
 VLAN configuration:
         Execute command:
             $ sudo apt-get install vlan
@@ -37,3 +41,6 @@
         NOTE:To make this configuration permanent
             $ sudo su -c 'echo "8021q" >> /etc/modules'
 
+Scapy install:
+    sudo apt-get install Scapy
+
diff --git a/TestON/tests/FUNCipv6Intent/README b/TestON/tests/FUNCipv6Intent/README
new file mode 100644
index 0000000..3a2dd91
--- /dev/null
+++ b/TestON/tests/FUNCipv6Intent/README
@@ -0,0 +1,39 @@
+Summary:
+        This test suite consist of basic intent IPv6 functionality testing.
+        The following is an overview of how point-to-point intents are being tested.
+        Steps:
+            - Discover IPv6 hosts with ICMP6 ping
+            - Add point intents
+            - Check intents
+            - Verify flows
+            - ICMP6 ping of all hosts
+            - Reroute
+                - Link down
+                - Verify flows
+                - Check topology
+                - Ping hosts
+                - Link up
+                - Verify flows
+                - Check topology
+                - Ping hosts
+            - Verify intents with VLAN-id
+            - Remove intents
+        This test suite includes testing of different types of intents such as
+        host, point, single-to-multi and multi-to-single ( More intent types to
+        add later ). The same steps above is being performed to other type of
+        intents.
+
+Required:
+        This test requires Mininet topology file newFuncIntent.py that is in the
+        Dependency folder. You should run the topology file to check for any
+        missing packages. The mininet topology file has different type of hosts
+        including VLAN hosts. Therefore you need to install VLAN module to build
+        the topology correctly.
+
+VLAN configuration:
+        Execute command:
+            $ sudo apt-get install vlan
+        Configuration:
+            $ sudo modprobe 8021q
+        NOTE:To make this configuration permanent
+            $ sudo su -c 'echo "8021q" >> /etc/modules'
diff --git a/TestON/tests/FUNCoptical/README b/TestON/tests/FUNCoptical/README
new file mode 100644
index 0000000..48a4f5f
--- /dev/null
+++ b/TestON/tests/FUNCoptical/README
@@ -0,0 +1,11 @@
+Summary:
+        This test suite consist of basic optical functionality testing.
+        It bings up Link-OE topology to simulate optical switches.
+        The following is an overview of the basic functionality that is
+        performed in this test.
+        Steps:
+            - Discover hosts
+            - Compare Mininet topology
+            - Add and test point intents
+            - Add and test host intents
+ 
diff --git a/TestON/tests/FUNCovsdbtest/README b/TestON/tests/FUNCovsdbtest/README
new file mode 100644
index 0000000..e73cc26
--- /dev/null
+++ b/TestON/tests/FUNCovsdbtest/README
@@ -0,0 +1,2 @@
+TODO:
+    Brief summary of the test and test cases. 
diff --git a/TestON/tests/HAclusterRestart/README b/TestON/tests/HAclusterRestart/README
new file mode 100644
index 0000000..033598c
--- /dev/null
+++ b/TestON/tests/HAclusterRestart/README
@@ -0,0 +1 @@
+Summary: Fill me in please!
diff --git a/TestON/tests/HAsingleInstanceRestart/README b/TestON/tests/HAsingleInstanceRestart/README
new file mode 100644
index 0000000..033598c
--- /dev/null
+++ b/TestON/tests/HAsingleInstanceRestart/README
@@ -0,0 +1 @@
+Summary: Fill me in please!
diff --git a/TestON/tests/SAMPstartTemplate/README b/TestON/tests/SAMPstartTemplate/README
new file mode 100644
index 0000000..359943e
--- /dev/null
+++ b/TestON/tests/SAMPstartTemplate/README
@@ -0,0 +1,5 @@
+Summary:
+        This is a Sample test suite that demonstrates starting up ONOS
+        and scalling to multiple instances. It also has extra
+        functionalilty that allows the tester to bypass the ONOS
+        package and install case (case 2) to save time.
diff --git a/TestON/tests/SCPFflowTp1g/README b/TestON/tests/SCPFflowTp1g/README
index 613bd13..e43e6ea 100644
--- a/TestON/tests/SCPFflowTp1g/README
+++ b/TestON/tests/SCPFflowTp1g/README
@@ -1,29 +1,31 @@
 FLOW THROUGHPUT
 
-Summary: This is a performance test suite to test the flow throughput 
-    capabilities of ONOS with various controller cluster sizes. 
+Summary:
+        This is a performance test suite to test the flow throughput
+        capabilities of ONOS with various controller cluster sizes. This
+        This test uses the null-provider to simulate a network topology
+        and tests the throughput via a python script called flow-tester.py.
 
-Pre-requisites: To run out-of-the box this test requires 7 NODES. 
-    OC1->OC7 must be set before initiating the test. Passwordless login 
-    must be set from TestStation "admin" root user. 
+Pre-requisites: To run out-of-the box this test requires 7 NODES.
+    OC1->OC7 must be set before initiating the test. Passwordless login
+    must be set from TestStation "admin" root user.
 
-***If you wish to run this test with less than 7 nodes the following 
+***If you wish to run this test with less than 7 nodes the following
     alterations must be made:
 
 NOTE: Only scale sizes 1,3,5 and 7 will be functional
 
---In the .params, remove any values in the comma separated list in the 
-    <scale> tag that are above your desired cluster size. 
+Modifying .params file:
+-- Remove any values in the comma separated list in the
+    <scale> tag that are above your desired cluster size.
 
---In the .params file remove one instance of “1,2” from the <testcases> 
-    tag for each value you removed from <scale> (case 1 and 2 are each 
+-- Remove one instance of “1,2” from the <testcases>
+    tag for each value you removed from <scale> (case 1 and 2 are each
     called once for each scale value)
 
---In the .params file, change the value in the <max> tag to your 
-    desired scale size (1,3, or 5)
+-- Change the value in the <max> tag to your desired scale size (1,3, or 5)
 
---In the .topo file, change the <ONOSbench/COMPONENTS/nodes> tag to your 
-    desired scale size 
+Modifying .topo file:
+-- Change the <ONOSbench/COMPONENTS/nodes> tag to your desired scale size
 
---Also in the .topo file, you will need to remove all unneeded <ONOS X 
-    cli> tags and their contents 
+-- Remove all unneeded <ONOS#cli> tags and their contents
diff --git a/TestON/tests/SCPFintentEventTp/README b/TestON/tests/SCPFintentEventTp/README
index 8de1428..980c748 100644
--- a/TestON/tests/SCPFintentEventTp/README
+++ b/TestON/tests/SCPFintentEventTp/README
@@ -1,29 +1,28 @@
 INTENT EVENT THROUGHPUT
 
-Summary: This is a performance test suite to test the intent 
-    throughput capabilities of ONOS with various controller cluster sizes. 
+Summary: This is a performance test suite to test the intent
+    throughput capabilities of ONOS with various controller cluster sizes.
 
-Pre-requisites: To run out-of-the box this test requires 7 NODES. OC1->OC7 
-    must be set before initiating the test. Passwordless login must be set 
-    from TestStation "admin" root user. 
+Pre-requisites: To run out-of-the box this test requires 7 NODES. OC1->OC7
+    must be set before initiating the test. Passwordless login must be set
+    from TestStation "admin" root user.
 
-***If you wish to run this test with less than 7 nodes the following 
-    alterations must be made: 
+***If you wish to run this test with less than 7 nodes the following
+    alterations must be made:
 
 NOTE: Only scale sizes 1,3,5 and 7 will be functional
 
---In the .params, remove any values in the comma separated list in the 
-    <scale> tag that are above your desired cluster size. 
+Modifying .params file:
+-- Remove any values in the comma separated list in the
+    <scale> tag that are above your desired cluster size.
 
---In the .params file remove one instance of “1,2” from the <testcases> 
-    tag for each value you removed from <scale> (case 1 and 2 are each 
+-- Remove one instance of “1,2” from the <testcases>
+    tag for each value you removed from <scale> (case 1 and 2 are each
     called once for each scale value)
 
---In the .params file, change the value in the <max> tag to your desired 
-    scale size (1,3, or 5)
+-- Change the value in the <max> tag to your desired scale size (1,3, or 5)
 
---In the .topo file, change the <ONOSbench/COMPONENTS/nodes> tag to your 
-    desired scale size 
+Modifying .topo file:
+-- Change the <ONOSbench/COMPONENTS/nodes> tag to your desired scale size
 
---Also in the .topo file, you will need to remove all unneeded <ONOS X cli> 
-    tags and their contents 
+-- Remove all unneeded <ONOS#cli> tags and their contents
diff --git a/TestON/tests/SCPFintentInstallWithdrawLat/README b/TestON/tests/SCPFintentInstallWithdrawLat/README
index 864739b..0dc53cd 100644
--- a/TestON/tests/SCPFintentInstallWithdrawLat/README
+++ b/TestON/tests/SCPFintentInstallWithdrawLat/README
@@ -1,31 +1,30 @@
-INTENT INSTALL/WITHDRAW LATENCY 
+INTENT INSTALL/WITHDRAW LATENCY
 
-Summary: This is a performance test designed to benchmark the 
-    latency of installing intents and withdrawing intents. (intent 
-    install and intent withdraw are separate operations with 
-    independent time data) 
+Summary: This is a performance test designed to benchmark the
+    latency of installing intents and withdrawing intents. (intent
+    install and intent withdraw are separate operations with
+    independent time data)
 
-Pre-requisites: To run out-of-the box this test requires 7 NODES. 
-    OC1->OC7 must be set before initiating the test. Passwordless 
-    login must be set from TestStation "admin" root user. 
+Pre-requisites: To run out-of-the box this test requires 7 NODES.
+    OC1->OC7 must be set before initiating the test. Passwordless
+    login must be set from TestStation "admin" root user.
 
-***If you wish to run this test with less than 7 nodes the 
-    following alterations must be made: 
+***If you wish to run this test with less than 7 nodes the
+    following alterations must be made:
 
 NOTE: Only scale sizes 1,3,5 and 7 will be functional
 
---In the .params, remove any values in the comma separated list 
-    in the <scale> tag that are above your desired cluster size. 
+Modifying .params file:
+-- Remove any values in the comma separated list in the <scale>
+    tag that are above your desired cluster size.
 
---In the .params file remove one instance of “1,2” from the 
-    <testcases> tag for each value you removed from <scale> (case 
-    1 and 2 are each called once for each scale value)
+-- Remove one instance of “1,2” from the <testcases> tag for each
+    value you removed from <scale> (case 1 and 2 are each called
+    once for each scale value)
 
---In the .params file, change the value in the <max> tag to your 
-    desired scale size (1,3, or 5)
+-- Change the value in the <max> tag to your desired scale size (1,3,5)
 
---In the .topo file, change the <ONOSbench/COMPONENTS/nodes> tag 
-    to your desired scale size 
+Modifying .topo file:
+-- Change the <ONOSbench/COMPONENTS/nodes> tag to your desired scale size
 
---Also in the .topo file, you will need to remove all unneeded 
-    <ONOS X cli> tags and their contents 
+-- Remove all unneeded <ONOS#cli> tags and their contents
diff --git a/TestON/tests/SCPFintentRerouteLat/README b/TestON/tests/SCPFintentRerouteLat/README
index 6ad9cce..af912f1 100644
--- a/TestON/tests/SCPFintentRerouteLat/README
+++ b/TestON/tests/SCPFintentRerouteLat/README
@@ -1,29 +1,29 @@
-INTENT REROUTE LATENCY 
+INTENT REROUTE LATENCY
 
-Summary: This is a performance test designed to benchmark the 
-    intent reroute speed of ONOS at various controller cluster sizes. 
+Summary: This is a performance test designed to benchmark the
+    intent reroute speed of ONOS at various controller cluster sizes.
 
-Pre-requisites: To run out-of-the box this test requires 7 NODES. 
-    OC1->OC7 must be set before initiating the test. Passwordless login 
-    must be set from TestStation "admin" root user. 
+Pre-requisites: To run out-of-the box this test requires 7 NODES.
+    OC1->OC7 must be set before initiating the test. Passwordless login
+    must be set from TestStation "admin" root user.
 
-***If you wish to run this test with less than 7 nodes the 
+***If you wish to run this test with less than 7 nodes the
     following alterations must be made:
 
 NOTE: Only scale sizes 1,3,5 and 7 will be functional
 
---In the .params, remove any values in the comma separated list in 
-    the <scale> tag that are above your desired cluster size. 
+Modifying .params file:
+-- Remove any values in the comma separated list in
+    the <scale> tag that are above your desired cluster size.
 
---In the .params file remove one instance of “1,2” from the 
-    <testcases> tag for each value you removed from <scale> (case 
-    1 and 2 are each called once for each scale value)
+-- Remove one instance of “1,2” from the <testcases> tag for
+    each value you removed from <scale> (case1 and 2 are each
+    called once for each scale value)
 
---In the .params file, change the value in the <max> tag to your 
-    desired scale size (1,3, or 5)
+-- Change the value in the <max> tag to your desired scale size (1,3,5)
 
---In the .topo file, change the <ONOSbench/COMPONENTS/nodes> tag to 
-    your desired scale size 
+Modifying .topo file:
+-- Change the <ONOSbench/COMPONENTS/nodes> tag to
+    your desired scale size
 
---Also in the .topo file, you will need to remove all unneeded 
-    <ONOS X cli> tags and their contents 
+-- Remove all unneeded <ONOS#cli> tags and their contents
diff --git a/TestON/tests/SCPFmaxIntents/README b/TestON/tests/SCPFmaxIntents/README
new file mode 100644
index 0000000..cb53df8
--- /dev/null
+++ b/TestON/tests/SCPFmaxIntents/README
@@ -0,0 +1,6 @@
+Summary:
+        This is a performance test suit, designed to test the upper limits
+        of onos and ovsdb with respect to installing intents and rerouting flows.
+NOTE:
+        This test is largely based on the hardware used to run onos and mininet.
+        Therefore, results will very test station to test station.
diff --git a/TestON/tests/SCPFscaleTopo/README b/TestON/tests/SCPFscaleTopo/README
new file mode 100644
index 0000000..16df150
--- /dev/null
+++ b/TestON/tests/SCPFscaleTopo/README
@@ -0,0 +1,8 @@
+Summary:
+        This is a performance test suite that is designed to test
+        large topologies. It also contains a failure case that brings
+        down an onos controller to see if the neighboring controllers
+        pick up the rest of the devices.
+NOTE:
+        This test does not scale onos controllers. The number of
+        controllers is fixed at 3.
diff --git a/TestON/tests/SCPFswitchLat/README b/TestON/tests/SCPFswitchLat/README
new file mode 100644
index 0000000..b86ca6f
--- /dev/null
+++ b/TestON/tests/SCPFswitchLat/README
@@ -0,0 +1,31 @@
+SWITCH LATENCY
+
+Summary: This is a performance test suite to measure the time it takes ONOS
+        to recognize a switch going up and down.
+
+Pre-requisites: To run out-of-the box this test requires 7 NODES.
+    OC1->OC7 must be set before initiating the test. Passwordless login
+    must be set from TestStation "admin" root user. The 7 NODES must have
+    their clocks synced to TestStation via ptpd and be accurate to the
+    millisecond. You will also need the Wireshark disector to see openflow packets.
+
+*** If you wish to run this test with less than 7 nodes the following
+    alterations must be made:
+
+NOTE: Only scale sizes 1,3,5 and 7 will be functional
+
+Modifying .params file:
+-- Remove any values in the comma separated list in the
+    <scale> tag that are above your desired cluster size.
+
+-- Remove one instance of “1,2” from the <testcases> tag for each
+    value you removed from <scale> (case 1 and 2 are each called once
+    for each scale value)
+
+-- Change the value in the <max> tag to your desired scale size (1,3,5)
+
+Modifying .topo file:
+-- Change the <ONOSbench/COMPONENTS/nodes> tag to your
+    desired scale size
+
+-- Remove all unneeded <ONOS#cli> tags and their contents
