Additional Functional tests for reading physical attributes from controllers

Change-Id: I09ed9e28309698101b2fcad9a9fbb361306766f6
Signed-off-by: senthil <senthil-b@hcl.com>

diff --git a/coordinator/test/vtn_ft/controller.data b/coordinator/test/vtn_ft/controller.data
index ec9ba9d3a9ab97033807f9327862515be96caee1..1a8f057bb50b15716f0cbec29366ccf8377f1827 100644 (file)
--- a/coordinator/test/vtn_ft/controller.data
+++ b/coordinator/test/vtn_ft/controller.data
@@ -8,15 +8,17 @@
 #
 
 [ControllerFirst]
-ipaddr=10.100.9.43
+ipaddr=10.100.9.41
 invalid_ipaddr=10.10.0.1
 controller_id=controller1
 description=First Test Controller
 type=odc
 version=1.0
 auditstatus=enable
+ssh=ssh -l
 username=admin
 password=admin
+machine_username=root
 invalidusername=admininval
 invalidpassword=admininval
 url=/controllers/controller1.json
@@ -24,15 +26,17 @@ get_url=/controllers/controller1
 port=8080
 
 [ControllerSecond]
-ipaddr=10.100.9.31
+ipaddr=10.100.9.43
 invalid_ipaddr=10.10.0.2
 controller_id=controller2
 description=Second Test Controller
 type=odc
 version=1.0
 auditstatus=enable
+ssh=ssh -l
 username=admin
 password=admin
+machine_username=root
 invalidusername=admininval
 invalidpassword=admininval
 url=/controllers/controller2.json

diff --git a/coordinator/test/vtn_ft/mininet_test.data b/coordinator/test/vtn_ft/mininet_test.data
index 400958c7e0a088540cffca2ec81333de457dd6be..1ce214eeac7118802475604cecf14ac0eea0794a 100644 (file)
--- a/coordinator/test/vtn_ft/mininet_test.data
+++ b/coordinator/test/vtn_ft/mininet_test.data
@@ -7,10 +7,19 @@
 # distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 
-[MININET]
+[MININETONE]
 mininet_ipaddr=10.100.9.151
 mininet_username=mininet
-ctr_id = 172.16.1.61
+ctr_id = 10.100.9.41
+ssh = ssh -l
+ctr_remote = sudo mn --controller=remote,ip=
+topo_tree = --topo tree,
+file_name = sudo python multitree.py
+
+[MININETTWO]
+mininet_ipaddr=10.100.9.110
+mininet_username=mininet
+ctr_id = 10.100.9.43
 ssh = ssh -l
 ctr_remote = sudo mn --controller=remote,ip=
 topo_tree = --topo tree,

diff --git a/coordinator/test/vtn_ft/mininet_test.py b/coordinator/test/vtn_ft/mininet_test.py
index 2a0eb3183180bd49f4b0086d5a05168a80ce0e91..0780384a72cfe4746ca08928e30c651ce082f485 100644 (file)
--- a/coordinator/test/vtn_ft/mininet_test.py
+++ b/coordinator/test/vtn_ft/mininet_test.py
@@ -89,7 +89,7 @@ def test_vtn_mininet_ping_demo1():
     print "VTNONE->VBRONE->VBRIFONE->PORTMAP"
     print "VTNONE->VBRONE->VBRIFTWO->PORTMAP"
 
-    child = create_mininet_topology('MININET', 'ControllerFirst', '2')
+    child = create_mininet_topology('MININETONE', 'ControllerFirst', '2')
     if child.isalive() == True :
         print "Topology creation Success!!!"
     else:
@@ -239,7 +239,7 @@ def test_vtn_mininet_ping_demo2():
     print "VTNONE->VBRONE->VBRIFONE->PORTMAP"
     print "VTNONE->VBRONE->VBRIFTWO->PORTMAP"
 
-    child = create_mininet_topology('MININET', 'ControllerFirst', '2')
+    child = create_mininet_topology('MININETONE', 'ControllerFirst', '2')
     if child.isalive() == True :
         print "Topology creation Success!!!"
     else:

diff --git a/coordinator/test/vtn_ft/multi_ctr_mininet.py b/coordinator/test/vtn_ft/multi_ctr_mininet.py
index 9ff63bb8bf798582fe260d6cd5c2fdb4e444f8b6..d771b4f0b36b67aeb2bde37e5dbedd3f6838a3ac 100644 (file)
--- a/coordinator/test/vtn_ft/multi_ctr_mininet.py
+++ b/coordinator/test/vtn_ft/multi_ctr_mininet.py
@@ -221,7 +221,7 @@ def validate_vlink(vlink_blockname, vtn_blockname, presence="yes", position=0):
             return 1
 
 def test_multi_ctr_mininet_ping():
-    child = create_multicontroller_mininet_topology('MININET')
+    child = create_multicontroller_mininet_topology('MININETONE')
     if child.isalive() == True :
         print "Topology creation Success!!!"
     else:

diff --git a/coordinator/test/vtn_ft/port_test.data b/coordinator/test/vtn_ft/port_test.data
index d8f96435cdc3bdcbd90395aa3ec6d9c7865bdd12..b235c8dcbc1ff453ecc3feefbc7faeb265e3c698 100644 (file)
--- a/coordinator/test/vtn_ft/port_test.data
+++ b/coordinator/test/vtn_ft/port_test.data
@@ -58,25 +58,55 @@ port_name = s4-eth2
 logical_port_id = PP-OF:00:00:00:00:00:00:00:04-s4-eth2
 
 [PortEleven]
+port_id = 3
+port_name = s4-eth3
+logical_port_id = PP-OF:00:00:00:00:00:00:00:04-s4-eth3
+
+[PortTwelve]
 port_id = 1
 port_name = s5-eth1
 logical_port_id = PP-OF:00:00:00:00:00:00:00:05-s5-eth1
 
-[PortTwelve]
+[PortThirteen]
 port_id = 2
 port_name = s5-eth2
 logical_port_id = PP-OF:00:00:00:00:00:00:00:05-s5-eth2
 
-[PortThirteen]
+[PortFourteen]
+port_id = 3
+port_name = s5-eth3
+logical_port_id = PP-OF:00:00:00:00:00:00:00:05-s5-eth3
+
+[PortFifteen]
 port_id = 1
 port_name = s6-eth1
 logical_port_id = PP-OF:00:00:00:00:00:00:00:06-s6-eth1
 
-[PortFourteen]
+[PortSixteen]
 port_id = 2
 port_name = s6-eth2
 logical_port_id = PP-OF:00:00:00:00:00:00:00:06-s6-eth2
 
+[PortSeventeen]
+port_id = 3
+port_name = s6-eth3
+logical_port_id = PP-OF:00:00:00:00:00:00:00:06-s6-eth3
+
+[PortEighteen]
+port_id = 1
+port_name = s7-eth1
+logical_port_id = PP-OF:00:00:00:00:00:00:00:07-s7-eth1
+
+[PortNineteen]
+port_id = 2
+port_name = s7-eth2
+logical_port_id = PP-OF:00:00:00:00:00:00:00:07-s7-eth2
+
+[PortTwenty]
+port_id = 3
+port_name = s7-eth3
+logical_port_id = PP-OF:00:00:00:00:00:00:00:07-s7-eth3
+
 [URL]
 port_url = /ports/detail.json
 lp_port_url = /logical_ports/detail.json

diff --git a/coordinator/test/vtn_ft/switch_test.py b/coordinator/test/vtn_ft/switch_test.py
index 8b6061c8cdc332f22f44d607c7c3a706f495fcc3..69d736bad26a0149046ddd45bcea28868678a1b4 100644 (file)
--- a/coordinator/test/vtn_ft/switch_test.py
+++ b/coordinator/test/vtn_ft/switch_test.py
@@ -7,10 +7,9 @@
 # distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 
-
 #! /usr/bin/python
 
-import requests, json, collections, sys, time, controller, vtn_vbr
+import requests, json, collections, sys, time, subprocess, controller, vtn_vbr
 import vtn_testconfig, pexpect, mininet_test
 
 SWITCHDATA = vtn_testconfig.SWITCHDATA
@@ -26,181 +25,240 @@ coordinator_headers = vtn_testconfig.coordinator_headers
 controller_url_part = vtn_testconfig.controller_url_part
 
 def validate_switch_at_physical(switch_blockname,controller_blockname,presence="yes",position=0):
-  ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
-  get_url=vtn_testconfig.ReadValues(SWITCHDATA,"GETURL")['sw_detail_url']
-  switch_id=vtn_testconfig.ReadValues(SWITCHDATA,switch_blockname)['switch_id']
-  url =  coordinator_url + ctr_url + get_url
-  print url
-  r=requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
-  print r.status_code
-
-  if presence == "no":
-    if r.status_code == 404:
-      return 0
-
-  if r.status_code != 200:
-    return 1
-
-  data=json.loads(r.text)
-  print data
-
-  if data['switches'] == []:
-     print "no switches"
-     return 0
-
-  switch_content = data['switches'][position]
-  print switch_content['switch_id']
-
-  if switch_content['switch_id'] != switch_id:
-    if presence == "yes":
-      return 1
-    else:
-      return 0
-  else:
-    if presence == "yes":
-      return 0
+    ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
+    get_url=vtn_testconfig.ReadValues(SWITCHDATA,"GETURL")['sw_detail_url']
+    switch_id=vtn_testconfig.ReadValues(SWITCHDATA,switch_blockname)['switch_id']
+    url =  coordinator_url + ctr_url + get_url
+    print url
+    r=requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
+    print r.status_code
+
+    if presence == "no":
+        if r.status_code == 404:
+            return 0
+
+    if r.status_code != 200:
+        return 1
+
+    data=json.loads(r.text)
+    print data
+
+    if data['switches'] == []:
+        print "no switches"
+        return 0
+
+    switch_content = data['switches'][position]
+    print switch_content['switch_id']
+
+    if switch_content['switch_id'] != switch_id:
+        if presence == "yes":
+            return 1
+        else:
+            return 0
     else:
-      return 1
+        if presence == "yes":
+            return 0
+        else:
+            return 1
 
 def update_switch(switch_blockname, controller_blockname):
-  print "update switch"
-  ctr_url = vtn_testconfig.ReadValues(SWITCHDATA, "GETURL")['controller_url']
-  switch_url = vtn_testconfig.ReadValues(SWITCHDATA, 'GETURL')['switch_url']
-  switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
-  default_url = vtn_testconfig.ReadValues(SWITCHDATA, "GETURL")['default_url']
-  description = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['description']
-  test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['ipaddr']
-  test_controller_port=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['port']
-  url = 'http://'+test_controller_ipaddr+':'+test_controller_port+'/'+ctr_url+ switch_url + switch_id + default_url + description
-  print url
-
-  r = requests.put(url,headers=controller_headers,auth=('admin','admin'))
-  print r.status_code
-  if r.status_code != 201:
-    return 1
-  else:
-    return 0
+    print "update switch"
+    ctr_url = vtn_testconfig.ReadValues(SWITCHDATA, "GETURL")['controller_url']
+    switch_url = vtn_testconfig.ReadValues(SWITCHDATA, 'GETURL')['switch_url']
+    switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
+    default_url = vtn_testconfig.ReadValues(SWITCHDATA, "GETURL")['default_url']
+    description = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['description']
+    test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['ipaddr']
+    test_controller_port=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['port']
+    url = 'http://'+test_controller_ipaddr+':'+test_controller_port+'/'+ctr_url+ switch_url + switch_id + default_url + description
+    print url
 
-def validate_update_switch(switch_blockname, controller_blockname,presence="yes", position = 0):
-  print "validate update switch"
-  ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
-  switch_url = vtn_testconfig.ReadValues(SWITCHDATA, 'GETURL')['url']
-  switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
-  description = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['description']
-
-  url = coordinator_url + ctr_url + '/switches/' +switch_id +switch_url
-  print url
-
-  r = requests.get(url,headers=def_header)
-  print r.status_code
-
-  if presence == "no":
-    if r.status_code == 404:
-      return 0
-
-  if r.status_code != 200:
-    return 1
-
-  data=json.loads(r.text)
-  print data
-
-  if data['switch'] == [ ]:
-     print "no switches"
-     return 1
-  switch_content = data['switch']
-  print switch_content['description']
-  print description
-
-  if switch_content['description'] == description:
-    if presence == "yes":
-      return 0
+    r = requests.put(url,headers=controller_headers,auth=('admin','admin'))
+    print r.status_code
+    if r.status_code != 201:
+        return 1
     else:
-      return 1
+        return 0
+
+def validate_update_switch(switch_blockname, controller_blockname,presence="yes", position = 0):
+    print "validate update switch"
+    ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
+    switch_url = vtn_testconfig.ReadValues(SWITCHDATA, 'GETURL')['url']
+    switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
+    description = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['description']
+
+    url = coordinator_url + ctr_url + '/switches/' +switch_id +switch_url
+    print url
+
+    r = requests.get(url,headers=def_header)
+    print r.status_code
+
+    if presence == "no":
+        if r.status_code == 404:
+            return 0
+
+    if r.status_code != 200:
+        return 1
+
+    data=json.loads(r.text)
+    print data
+
+    if data['switch'] == [ ] or data['switch'] == None:
+        print "no switches"
+        return 1
+    switch_content = data['switch']
+    print switch_content['description']
+    print description
+
+    if switch_content['description'] == description:
+        if presence == "yes":
+            return 0
+        else:
+            return 1
 
 def validate_switch_port(switch_blockname, port_blockname, controller_blockname, child, presence="yes", position=0):
-  print "validate switch port details"
-  ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
-  switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
-  port_id = vtn_testconfig.ReadValues(PORTDATA, port_blockname)['port_id']
-  port_url = vtn_testconfig.ReadValues(PORTDATA, 'URL')['port_url']
+    print "validate switch port details"
+    ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
+    switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
+    port_id = vtn_testconfig.ReadValues(PORTDATA, port_blockname)['port_id']
+    port_url = vtn_testconfig.ReadValues(PORTDATA, 'URL')['port_url']
 
-  url = coordinator_url + ctr_url + '/switches/' + switch_id + port_url
-  print url
+    url = coordinator_url + ctr_url + '/switches/' + switch_id + port_url
+    print url
 
-  r = requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
-  print r.status_code
+    r = requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
+    print r.status_code
 
-  if presence == "no":
-    if r.status_code == 404:
-      return 0
+    if presence == "no":
+        if r.status_code == 404:
+            return 0
 
-  if r.status_code != 200:
-    return 1
+    if r.status_code != 200:
+        return 1
 
-  data=json.loads(r.text)
+    data=json.loads(r.text)
 
-  if presence == "no":
-    print data['ports']
-    if data['ports'] == []:
-      print "no ports"
-      return 0
-  else:
-    port_content = data['ports'][position]
-    print port_content['port_id']
-    if port_content['port_id'] != port_id:
-      return 1
+    if presence == "no":
+        print data['ports']
+        if data['ports'] == []:
+            print "no ports"
+            return 0
     else:
-      return 0
+        port_content = data['ports'][position]
+        print port_content['port_id']
+        if port_content['port_id'] != port_id:
+            return 1
+        else:
+            return 0
 
-def verify_switch_port(switch_blockname, port_blockname, controller_blockname, child, presence="yes", position=0):
-  retval = validate_switch_port(switch_blockname, port_blockname, controller_blockname, child, presence, position)
-  if retval != 0:
-    mininet_test.close_topology(child)
-    print "validate", switch_blockname, port_blockname, "failed"
-    exit(1)
+def verify_switch_port(switch_blockname, port_blockname, controller_blockname, child, ctr_child, presence="yes", position=0):
+    retval = validate_switch_port(switch_blockname, port_blockname, controller_blockname, child, presence, position)
+    if retval != 0:
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        print "validate", switch_blockname, port_blockname, "failed"
+        exit(1)
+
+def verify_multictr_switch_port(switch_blockname, port_blockname, controller_blockname, child1, child2, ctr1_child, ctr2_child, presence="yes", position=0):
+    retval = validate_switch_port(switch_blockname, port_blockname, controller_blockname, child1, presence, position)
+    if retval != 0:
+        mininet_test.close_topology(child1)
+        mininet_test.close_topology(child2)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        print "validate", switch_blockname, port_blockname, "failed"
+        exit(1)
 
 def validate_logical_port(port_blockname, controller_blockname, child, presence = "yes", position = 0):
-  print "validate logical port details"
-  ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
-  logical_port_id = vtn_testconfig.ReadValues(PORTDATA, port_blockname)['logical_port_id']
-  domain_id = vtn_testconfig.ReadValues(PORTDATA, 'URL')['domain_id']
-  lp_url = vtn_testconfig.ReadValues(PORTDATA, 'URL')['lp_port_url']
-
-  url = coordinator_url + ctr_url + '/domains/' + domain_id + lp_url
-  print url
-
-  r = requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
-  print r.status_code
-
-  if presence == "no":
-    if r.status_code == 404:
-      return 0
-
-  if r.status_code != 200:
-    return 1
-
-  data=json.loads(r.text)
-
-  if presence == "no":
-    print data['logical_ports']
-    if data['ports'] == []:
-      print "no ports"
-      return 0
-  else:
-    port_content = data['logical_ports'][position]
-    print port_content, '\n'
-    print port_content['logical_port_id']
-    if port_content['logical_port_id'] != logical_port_id:
-      return 1
+    print "validate logical port details"
+    ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
+    logical_port_id = vtn_testconfig.ReadValues(PORTDATA, port_blockname)['logical_port_id']
+    domain_id = vtn_testconfig.ReadValues(PORTDATA, 'URL')['domain_id']
+    lp_url = vtn_testconfig.ReadValues(PORTDATA, 'URL')['lp_port_url']
+
+    url = coordinator_url + ctr_url + '/domains/' + domain_id + lp_url
+    print url
+
+    r = requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
+    print r.status_code
+
+    if presence == "no":
+      if r.status_code == 404:
+          return 0
+
+    if r.status_code != 200:
+        return 1
+
+    data=json.loads(r.text)
+
+    if presence == "no":
+        print data['logical_ports']
+        if data['ports'] == []:
+          print "no ports"
+          return 0
     else:
-      return 0
+        port_content = data['logical_ports'][position]
+        print port_content, '\n'
+        print port_content['logical_port_id']
+        if port_content['logical_port_id'] != logical_port_id:
+              return 1
+        else:
+              return 0
 
-def verify_logical_port(port_blockname, controller_blockname, child, presence = "yes", position = 0):
-  retval = validate_logical_port(port_blockname, controller_blockname, child, presence, position)
-  if retval != 0:
-    print "validate", port_blockname,"failed"
-    mininet_test.close_topology(child)
-    exit(1)
+def verify_logical_port(port_blockname, controller_blockname, child, ctr_child, presence = "yes", position = 0):
+    retval = validate_logical_port(port_blockname, controller_blockname, child, presence, position)
+    if retval != 0:
+        print "validate", port_blockname,"failed"
+        mininet_test.close_topology(child),
+        stop_controller(ctr_child)
+        exit(1)
+
+def verify_multictr_logical_port(port_blockname, controller_blockname, child1, child2, ctr1_child, ctr2_child, presence = "yes", position = 0):
+    retval = validate_logical_port(port_blockname, controller_blockname, child1, presence, position)
+    if retval != 0:
+        print "validate", port_blockname,"failed"
+        mininet_test.close_topology(child1)
+        mininet_test.close_topology(child2)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+def link_down(child, switch, host):
+    cmd = 'link' + ' ' + switch + ' ' + host + ' ' + 'down'
+    print cmd
+    if child.isalive() == True :
+        print "process alive\n"
+        child.sendline(cmd)
+        print "Toggling link of", switch, host, "passed"
+        return 0
+    else:
+        print "child process closed"
+        return 1
+
+def validate_link_down(controller_blockname, switch_blockname, port_blockname, status, position=0):
+    print "validate link_down"
+    ctr_url=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['get_url']
+    controller_id = vtn_testconfig.ReadValues(CONTROLLERDATA, controller_blockname)['controller_id']
+    switch_id = vtn_testconfig.ReadValues(SWITCHDATA, switch_blockname)['switch_id']
+    port_url = vtn_testconfig.ReadValues(PORTDATA, 'URL')['port_url']
+
+    url = coordinator_url + ctr_url + '/switches/' + switch_id + port_url
+    print url
+
+    r = requests.get(url, headers=coordinator_headers,auth=('admin','adminpass'))
+    print r.status_code
+
+    if r.status_code != 200:
+        return 1
+
+    data=json.loads(r.text)
+
+    port_content = data['ports'][position]
+    print port_content, '\n'
+    if port_content['operstatus'] != status:
+        return 1
+    else:
+        return 0
 
 def insync(delay):
     for i in range(delay):
@@ -208,111 +266,978 @@ def insync(delay):
         sys.stdout.write("\rWaiting for in sync with controller..%ds.." %i)
         sys.stdout.flush()
 
-def test():
+def start_controller(controller_blockname):
+    ctr_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, controller_blockname)['ipaddr']
+    machine_username = vtn_testconfig.ReadValues(CONTROLLERDATA, controller_blockname)['machine_username']
+    ssh = vtn_testconfig.ReadValues(CONTROLLERDATA, controller_blockname)['ssh']
+    ssh_newkey = 'Are you sure you want to continue connecting'
 
-  child=mininet_test.create_mininet_topology('MININET','ControllerFirst','2')
-  if child.isalive() == True :
-      print "Topology creation Success!!!"
-  else:
-      print "Topology creation Failed"
-      mininet_test.close_topology(child)
-      exit(1)
-  print "CREATE Controller"
-  retval = controller.add_controller_ex('ControllerFirst')
-  if retval != 0:
-    print "Controller Create Failed"
-    mininet_test.close_topology(child)
-    exit(1)
+    cmd = ssh + ' ' + machine_username + ' ' + ctr_ipaddr
+    print cmd
 
-  insync(60)
+    child = pexpect.spawn(cmd)
+    index = child.expect([ssh_newkey, 'password:', pexpect.EOF, pexpect.TIMEOUT])
+    if index == 0:
+        print "I say yes"
+        child.sendline('yes')
+        index = child.expect([ssh_newkey, 'password:', pexpect.EOF, pexpect.TIMEOUT])
+    if index == 1:
+        print "sending password"
+        child.sendline('uncunc')
+        print "connection OK"
+        child.sendline("cd opendaylight")
+        child.expect('opendaylight]#')
+        cmd = './run.sh -virt vtn'
+        child.sendline(cmd)
+        print('Starting controller')
+        return child
+    elif index == 2:
+        print "2:connection timeout"
+        return child
+    elif index == 3:
+        print "3:connection timeout"
+        return child
 
-  retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst','yes',0)
-  if retval != 0:
-    print "switch1 validate failed"
-    mininet_test.close_topology(child)
-    exit(1)
+def stop_controller(child):
+    if child.isalive() == True :
+        print "process alive\n"
+        child.sendline('exit')
+        child.expect('(y/n; default=y)')
+        child.sendline('y')
+        print "Controller Stoppped"
+        child.close()
+    else:
+        print "child process already closed"
 
-  retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst','yes',1)
-  if retval != 0:
-    print "switch2 validate failed"
-    mininet_test.close_topology(child)
-    exit(1)
+#Test cases are being started from here
+
+def test(ctr_child):
+    child=mininet_test.create_mininet_topology('MININETONE','ControllerFirst','2')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "CREATE Controller"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "Controller Create Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst','yes',0)
+    if retval != 0:
+        print "switch1 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst','yes',1)
+    if retval != 0:
+        print "switch2 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst','yes',2)
+    if retval != 0:
+        print "switch3 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = update_switch('SwitchOne', 'ControllerFirst')
+    if retval != 0:
+        print "switch1 update failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = update_switch('SwitchTwo', 'ControllerFirst')
+    if retval != 0:
+        print "switch2 update failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = update_switch('SwitchThree', 'ControllerFirst')
+    if retval != 0:
+        print "switch3 update failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_update_switch('SwitchOne', 'ControllerFirst',position = 0)
+    if retval != 0:
+        print "switch1 validate update failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_update_switch('SwitchTwo', 'ControllerFirst',position = 1)
+    if retval != 0:
+        print "switch2 validate update failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_update_switch('SwitchThree', 'ControllerFirst',position = 2)
+    if retval != 0:
+        print "switch3 validate update failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    verify_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchTwo', 'PortFive', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    insync(40)
+    verify_logical_port('PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_logical_port('PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_logical_port('PortThree', 'ControllerFirst', child, ctr_child, 'yes', 2)
+    verify_logical_port('PortFour', 'ControllerFirst', child, ctr_child, 'yes', 3)
+    verify_logical_port('PortFive', 'ControllerFirst', child, ctr_child, 'yes', 4)
+    verify_logical_port('PortSix', 'ControllerFirst', child, ctr_child, 'yes', 5)
+    verify_logical_port('PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 6)
+    verify_logical_port('PortEight', 'ControllerFirst', child, ctr_child, 'yes', 7)
 
-  retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst','yes',2)
-  if retval != 0:
-    print "switch3 validate failed"
     mininet_test.close_topology(child)
-    exit(1)
+    print "DELETE CONTROLLER"
+    retval=controller.delete_controller_ex('ControllerFirst')
+    if retval != 0:
+       print "CONTROLLER delete failed"
+       stop_controller(ctr_child)
+       exit(1)
+    print "PHYSICAL READ TEST SUCCESS"
+
+def test_physical_read_1(ctr_child):
+    print "TEST 1"
+    #create mininet topology
+    child = mininet_test.create_mininet_topology('MININETONE', 'ControllerFirst', '2')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "CREATE Controller"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        print "Controller Create Failed"
+        exit(1)
+# Delay for AUDIT
+    retval = controller.wait_until_state('ControllerFirst', "up")
+    if retval != 0:
+       mininet_test.close_topology(child)
+       stop_controller(ctr_child)
+       print "Controller state check failed"
+       exit(1)
+
+#stop and start vtn
+    print "stopping vtn"
+    subprocess.Popen("/usr/local/vtn/bin/vtn_stop", stdout=subprocess.PIPE)
+    time.sleep(5)
+    print "starting vtn"
+    subprocess.Popen("/usr/local/vtn/bin/vtn_start", stdout=subprocess.PIPE)
+    time.sleep(5)
+
+#Adding controller again, and cheking the physical table
+    print "CREATE Controller"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "Controller Create Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+# Delay for AUDIT
+    retval = controller.wait_until_state('ControllerFirst', "up")
+    if retval != 0:
+        print "Controller state check failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst', 'yes', 0)
+    if retval != 0:
+        print "switch1 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
 
-  retval = update_switch('SwitchOne', 'ControllerFirst')
-  if retval != 0:
-    print "switch1 update failed"
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst', 'yes', 1)
+    if retval != 0:
+        print "switch2 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst', 'yes', 2)
+    if retval != 0:
+        print "switch3 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    verify_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchThree', 'PortFive', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    insync(40)
+    verify_logical_port('PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_logical_port('PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_logical_port('PortThree', 'ControllerFirst', child, ctr_child, 'yes', 2)
+    verify_logical_port('PortFour', 'ControllerFirst', child, ctr_child, 'yes', 3)
+    verify_logical_port('PortFive', 'ControllerFirst', child, ctr_child, 'yes', 4)
+
+    verify_logical_port('PortSix', 'ControllerFirst', child, ctr_child, 'yes', 5)
+    verify_logical_port('PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 6)
+    verify_logical_port('PortEight', 'ControllerFirst', child, ctr_child, 'yes', 7)
+
+#close Topology
     mininet_test.close_topology(child)
-    exit(1)
 
-  retval = update_switch('SwitchTwo', 'ControllerFirst')
-  if retval != 0:
-    print "switch2 update failed"
+    print "DELETE CONTROLLER"
+    retval=controller.delete_controller_ex('ControllerFirst')
+    if retval != 0:
+      stop_controller(ctr_child)
+      print "CONTROLLER delete failed"
+      exit(1)
+
+    print "test_physical_read_1 SUCESS"
+
+def test_physical_read_2(ctr_child):
+    print "TEST 2"
+#create mininet topology
+    child = mininet_test.create_mininet_topology('MININETONE', 'ControllerFirst', '2')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "CREATE Controller"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "Controller Create Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+# Delay for AUDIT
+    retval = controller.wait_until_state('ControllerFirst', "up")
+    if retval != 0:
+        print "Controller state check failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst', 'yes', 0)
+    if retval != 0:
+        print "switch1 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst', 'yes', 1)
+    if retval != 0:
+        print "switch2 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst', 'yes', 2)
+    if retval != 0:
+        print "switch3 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    verify_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchTwo', 'PortFive', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    insync(40)
+    verify_logical_port('PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_logical_port('PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_logical_port('PortThree', 'ControllerFirst', child, ctr_child, 'yes', 2)
+    verify_logical_port('PortFour', 'ControllerFirst', child, ctr_child, 'yes', 3)
+    verify_logical_port('PortFive', 'ControllerFirst', child, ctr_child, 'yes', 4)
+
+    verify_logical_port('PortSix', 'ControllerFirst', child, ctr_child, 'yes', 5)
+    verify_logical_port('PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 6)
+    verify_logical_port('PortEight', 'ControllerFirst', child, ctr_child, 'yes', 7)
+
+#Making the link down of S3 H1
+    retval = link_down(child, 's3', 'h3')
+    if retval != 0:
+        print "Toggling of link s3 h3 down failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(40)
+#checking for link down
+    retval = validate_link_down('ControllerFirst', 'SwitchThree', 'PortSix', 'down', 0)
+    if retval != 0:
+        print "s3 h3 is not down"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+#close Topology
     mininet_test.close_topology(child)
-    exit(1)
 
-  retval = update_switch('SwitchThree', 'ControllerFirst')
-  if retval != 0:
-    print "switch3 update failed"
+    print "DELETE CONTROLLER"
+    retval=controller.delete_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "CONTROLLER delete failed"
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "test_physical_read_2 SUCESS"
+
+def test_physical_read_3(ctr_child):
+    print "TEST 3"
+#create mininet topology
+    child = mininet_test.create_mininet_topology('MININETONE', 'ControllerFirst', '2')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "CREATE Controller"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "Controller Create Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+# Delay for AUDIT
+    retval = controller.wait_until_state('ControllerFirst', "up")
+    if retval != 0:
+        print "Controller state check failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst', 'yes', 0)
+    if retval != 0:
+        print "switch1 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst', 'yes', 1)
+    if retval != 0:
+        print "switch2 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst', 'yes', 2)
+    if retval != 0:
+        print "switch3 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    verify_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchTwo', 'PortFive', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    insync(40)
+    verify_logical_port('PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_logical_port('PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_logical_port('PortThree', 'ControllerFirst', child, ctr_child, 'yes', 2)
+    verify_logical_port('PortFour', 'ControllerFirst', child, ctr_child, 'yes', 3)
+    verify_logical_port('PortFive', 'ControllerFirst', child, ctr_child, 'yes', 4)
+    verify_logical_port('PortSix', 'ControllerFirst', child, ctr_child, 'yes', 5)
+    verify_logical_port('PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 6)
+    verify_logical_port('PortEight', 'ControllerFirst', child, ctr_child, 'yes', 7)
+
     mininet_test.close_topology(child)
-    exit(1)
 
-  insync(60)
+#create mininet topology with change in topology tree
+    child = mininet_test.create_mininet_topology('MININETONE', 'ControllerFirst', '3')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(80)
+
+    retval = validate_switch_at_physical('SwitchFour', 'ControllerFirst', 'yes', 3)
+    if retval != 0:
+        print "switch4 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchFive', 'ControllerFirst', 'yes', 4)
+    if retval != 0:
+        print "switch5 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchSix', 'ControllerFirst', 'yes', 5)
+    if retval != 0:
+        print "switch6 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchSeven', 'ControllerFirst', 'yes', 6)
+    if retval != 0:
+        print "switch7 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    verify_switch_port('SwitchFour', 'PortNine', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchFour', 'PortTen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchFour', 'PortEleven', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchFive', 'PortTwelve', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchFive', 'PortThirteen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchFive', 'PortFourteen', 'ControllerFirst', child, ctr_child, 'yes', 2)
 
-  retval = validate_update_switch('SwitchOne', 'ControllerFirst',position = 0)
-  if retval != 0:
-    print "switch1 validate update failed"
+    verify_switch_port('SwitchSix', 'PortFifteen', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchSix', 'PortSixteen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchSix', 'PortSeventeen', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchSeven', 'PortEighteen', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchSeven', 'PortNineteen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchSeven', 'PortTwenty', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    insync(40)
+    verify_logical_port('PortNine', 'ControllerFirst', child, ctr_child, 'yes', 8)
+    verify_logical_port('PortTen', 'ControllerFirst', child, ctr_child, 'yes', 9)
+    verify_logical_port('PortEleven', 'ControllerFirst', child, ctr_child, 'yes', 10)
+    verify_logical_port('PortTwelve', 'ControllerFirst', child, ctr_child, 'yes', 11)
+    verify_logical_port('PortThirteen', 'ControllerFirst', child, ctr_child, 'yes', 12)
+    verify_logical_port('PortFourteen', 'ControllerFirst', child, ctr_child, 'yes', 13)
+    verify_logical_port('PortFifteen', 'ControllerFirst', child, ctr_child, 'yes', 14)
+    verify_logical_port('PortSixteen', 'ControllerFirst', child, ctr_child, 'yes', 15)
+    verify_logical_port('PortSeventeen', 'ControllerFirst', child, ctr_child, 'yes', 16)
+    verify_logical_port('PortEighteen', 'ControllerFirst', child, ctr_child, 'yes', 17)
+    verify_logical_port('PortNineteen', 'ControllerFirst', child, ctr_child, 'yes', 18)
+    verify_logical_port('PortTwenty', 'ControllerFirst', child, ctr_child, 'yes', 19)
+
+#close Topology
     mininet_test.close_topology(child)
-    exit(1)
 
-  retval = validate_update_switch('SwitchTwo', 'ControllerFirst',position = 1)
-  if retval != 0:
-    print "switch2 validate update failed"
+    print "DELETE CONTROLLER"
+    retval=controller.delete_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "CONTROLLER delete failed"
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "test_physical_read_3 SUCESS"
+
+def test_physical_read_4(ctr_child):
+    print "TEST 4"
+#create mininet topology
+    child = mininet_test.create_mininet_topology('MININETONE', 'ControllerFirst', '3')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "CREATE Controller"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "Controller Create Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+# Delay for AUDIT
+    retval = controller.wait_until_state('ControllerFirst', "up")
+    if retval != 0:
+        print "Controller state check failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst', 'yes', 0)
+    if retval != 0:
+        print "switch1 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst', 'yes', 1)
+    if retval != 0:
+        print "switch2 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst', 'yes', 2)
+    if retval != 0:
+        print "switch3 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchFour', 'ControllerFirst', 'yes', 3)
+    if retval != 0:
+        print "switch4 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchFive', 'ControllerFirst', 'yes', 4)
+    if retval != 0:
+        print "switch5 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchSix', 'ControllerFirst', 'yes', 5)
+    if retval != 0:
+        print "switch6 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchSeven', 'ControllerFirst', 'yes', 6)
+    if retval != 0:
+        print "switch7 validate failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    verify_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+
+    verify_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchTwo', 'PortFive', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchFour', 'PortNine', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchFour', 'PortTen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchFour', 'PortEleven', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchFive', 'PortTwelve', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchFive', 'PortThirteen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchFive', 'PortFourteen', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchSix', 'PortFifteen', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchSix', 'PortSixteen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchSix', 'PortSeventeen', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    verify_switch_port('SwitchSeven', 'PortEighteen', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_switch_port('SwitchSeven', 'PortNineteen', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_switch_port('SwitchSeven', 'PortTwenty', 'ControllerFirst', child, ctr_child, 'yes', 2)
+
+    insync(40)
+    verify_logical_port('PortOne', 'ControllerFirst', child, ctr_child, 'yes', 0)
+    verify_logical_port('PortTwo', 'ControllerFirst', child, ctr_child, 'yes', 1)
+    verify_logical_port('PortThree', 'ControllerFirst', child, ctr_child, 'yes', 2)
+    verify_logical_port('PortFour', 'ControllerFirst', child, ctr_child, 'yes', 3)
+    verify_logical_port('PortFive', 'ControllerFirst', child, ctr_child, 'yes', 4)
+    verify_logical_port('PortSix', 'ControllerFirst', child, ctr_child, 'yes', 5)
+    verify_logical_port('PortSeven', 'ControllerFirst', child, ctr_child, 'yes', 6)
+    verify_logical_port('PortEight', 'ControllerFirst', child, ctr_child, 'yes', 7)
+    verify_logical_port('PortNine', 'ControllerFirst', child, ctr_child, 'yes', 8)
+    verify_logical_port('PortTen', 'ControllerFirst', child, ctr_child, 'yes', 9)
+    verify_logical_port('PortEleven', 'ControllerFirst', child, ctr_child, 'yes', 10)
+    verify_logical_port('PortTwelve', 'ControllerFirst', child, ctr_child, 'yes', 11)
+    verify_logical_port('PortThirteen', 'ControllerFirst', child, ctr_child, 'yes', 12)
+    verify_logical_port('PortFourteen', 'ControllerFirst', child, ctr_child, 'yes', 13)
+    verify_logical_port('PortFifteen', 'ControllerFirst', child, ctr_child, 'yes', 14)
+    verify_logical_port('PortSixteen', 'ControllerFirst', child, ctr_child, 'yes', 15)
+    verify_logical_port('PortSeventeen', 'ControllerFirst', child, ctr_child, 'yes', 16)
+    verify_logical_port('PortEighteen', 'ControllerFirst', child, ctr_child, 'yes', 17)
+    verify_logical_port('PortNineteen', 'ControllerFirst', child, ctr_child, 'yes', 18)
+    verify_logical_port('PortTwenty', 'ControllerFirst', child, ctr_child, 'yes', 19)
+
     mininet_test.close_topology(child)
-    exit(1)
 
-  retval = validate_update_switch('SwitchThree', 'ControllerFirst',position = 2)
-  if retval != 0:
-    print "switch3 validate update failed"
+#create mininet topology with change in topology tree
+    child = mininet_test.create_mininet_topology('MININETONE', 'ControllerFirst', '2')
+    if child.isalive() == True :
+        print "Topology creation Success!!!"
+    else:
+        print "Topology creation Failed"
+        mininet_test.close_topology(child)
+        stop_controller(ctr_child)
+        exit(1)
+
+    insync(80)
+
+    verify_switch_port('SwitchFour', 'PortNine', 'ControllerFirst', child, ctr_child, 'no', 0)
+    verify_switch_port('SwitchFive', 'PortTwelve', 'ControllerFirst', child, ctr_child, 'no', 0)
+    verify_switch_port('SwitchSix', 'PortFifteen', 'ControllerFirst', child, ctr_child, 'no', 0)
+    verify_switch_port('SwitchSeven', 'PortEighteen', 'ControllerFirst', child, ctr_child, 'no', 0)
+
+#close Topology
     mininet_test.close_topology(child)
-    exit(1)
-
-  verify_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child, 'yes', 0)
-  verify_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child, 'yes', 1)
-
-  verify_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child, 'yes', 0)
-  verify_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child, 'yes', 1)
-  verify_switch_port('SwitchTwo', 'PortFive', 'ControllerFirst', child, 'yes', 2)
-
-  verify_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child, 'yes', 0)
-  verify_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child, 'yes', 1)
-  verify_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child, 'yes', 2)
-
-  insync(20)
-  verify_logical_port('PortOne', 'ControllerFirst', child, 'yes', 0)
-  verify_logical_port('PortTwo', 'ControllerFirst', child, 'yes', 1)
-  verify_logical_port('PortThree', 'ControllerFirst', child, 'yes', 2)
-  verify_logical_port('PortFour', 'ControllerFirst', child, 'yes', 3)
-  verify_logical_port('PortFive', 'ControllerFirst', child, 'yes', 4)
-  verify_logical_port('PortSix', 'ControllerFirst', child, 'yes', 5)
-  verify_logical_port('PortSeven', 'ControllerFirst', child, 'yes', 6)
-  verify_logical_port('PortEight', 'ControllerFirst', child, 'yes', 7)
-
-  mininet_test.close_topology(child)
-  print "DELETE CONTROLLER"
-  retval=controller.delete_controller_ex('ControllerFirst')
-  if retval != 0:
-    print "CONTROLLER delete failed"
-    exit(1)
-  print "PHYSICAL READ TEST SUCCESS"
+
+    print "DELETE CONTROLLER"
+    retval=controller.delete_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "CONTROLLER delete failed"
+        stop_controller(ctr_child)
+        exit(1)
+
+    print "test_physical_read_4 SUCESS"
+
+def test_multi_ctr_multi_mininet(ctr1_child, ctr2_child):
+    child1 = mininet_test.create_mininet_topology('MININETONE','ControllerFirst','2')
+    if child1.isalive() == True :
+        print "Topology1 creation Success!!!"
+    else:
+        print "Topology1 creation Failed"
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    print "CREATE Controller1"
+    retval = controller.add_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "Controller1 Create Failed"
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    insync(60)
+
+    child2 = mininet_test.create_mininet_topology('MININETTWO','ControllerSecond','2')
+    if child2.isalive() == True :
+        print "Topology2 creation Success!!!"
+    else:
+        print "Topology2 creation Failed"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    print "CREATE Controller2"
+    retval = controller.add_controller_ex('ControllerSecond')
+    if retval != 0:
+        print "Controller2 Create Failed"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerFirst','yes',0)
+    if retval != 0:
+        print "switch1 validate failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerFirst','yes',1)
+    if retval != 0:
+        print "switch2 validate failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerFirst','yes',2)
+    if retval != 0:
+        print "switch3 validate failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchOne', 'ControllerSecond','yes',0)
+    if retval != 0:
+        print "switch1 validate failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchTwo', 'ControllerSecond','yes',1)
+    if retval != 0:
+        print "switch2 validate failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_switch_at_physical('SwitchThree', 'ControllerSecond','yes',2)
+    if retval != 0:
+        print "switch3 validate failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = update_switch('SwitchOne', 'ControllerFirst')
+    if retval != 0:
+        print "switch1 update failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = update_switch('SwitchTwo', 'ControllerFirst')
+    if retval != 0:
+        print "switch2 update failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = update_switch('SwitchThree', 'ControllerFirst')
+    if retval != 0:
+        print "switch3 update failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_update_switch('SwitchOne', 'ControllerFirst', position = 0)
+    if retval != 0:
+        print "switch1 validate update failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_update_switch('SwitchTwo', 'ControllerFirst', position = 1)
+    if retval != 0:
+        print "switch2 validate update failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_update_switch('SwitchThree', 'ControllerFirst', position = 2)
+    if retval != 0:
+        print "switch3 validate update failed for ctr1"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = update_switch('SwitchOne', 'ControllerSecond')
+    if retval != 0:
+        print "switch1 update failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = update_switch('SwitchTwo', 'ControllerSecond')
+    if retval != 0:
+        print "switch2 update failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = update_switch('SwitchThree', 'ControllerSecond')
+    if retval != 0:
+        print "switch3 update failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    insync(60)
+
+    retval = validate_update_switch('SwitchOne', 'ControllerSecond', position = 0)
+    if retval != 0:
+        print "switch1 validate update failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_update_switch('SwitchTwo', 'ControllerSecond', position = 1)
+    if retval != 0:
+        print "switch2 validate update failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    retval = validate_update_switch('SwitchThree', 'ControllerSecond', position = 2)
+    if retval != 0:
+        print "switch3 validate update failed for ctr2"
+        mininet_test.close_topology(child2)
+        mininet_test.close_topology(child1)
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    verify_multictr_switch_port('SwitchOne', 'PortOne', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_switch_port('SwitchOne', 'PortTwo', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child,'yes', 1)
+
+    verify_multictr_switch_port('SwitchTwo', 'PortThree', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_switch_port('SwitchTwo', 'PortFour', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+    verify_multictr_switch_port('SwitchTwo', 'PortFive', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 2)
+
+    verify_multictr_switch_port('SwitchThree', 'PortSix', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_switch_port('SwitchThree', 'PortSeven', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+    verify_multictr_switch_port('SwitchThree', 'PortEight', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child,'yes', 2)
+
+    verify_multictr_switch_port('SwitchOne', 'PortOne', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_switch_port('SwitchOne', 'PortTwo', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+
+    verify_multictr_switch_port('SwitchTwo', 'PortThree', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_switch_port('SwitchTwo', 'PortFour', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+    verify_multictr_switch_port('SwitchTwo', 'PortFive', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child,  'yes', 2)
+
+    verify_multictr_switch_port('SwitchThree', 'PortSix', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_switch_port('SwitchThree', 'PortSeven', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+    verify_multictr_switch_port('SwitchThree', 'PortEight', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 2)
+
+    insync(40)
+    verify_multictr_logical_port('PortOne', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_logical_port('PortTwo', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+    verify_multictr_logical_port('PortThree', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 2)
+    verify_multictr_logical_port('PortFour', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 3)
+    verify_multictr_logical_port('PortFive', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 4)
+    verify_multictr_logical_port('PortSix', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 5)
+    verify_multictr_logical_port('PortSeven', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 6)
+    verify_multictr_logical_port('PortEight', 'ControllerFirst', child1, child2, ctr1_child, ctr2_child, 'yes', 7)
+
+    verify_multictr_logical_port('PortOne', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 0)
+    verify_multictr_logical_port('PortTwo', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 1)
+    verify_multictr_logical_port('PortThree', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 2)
+    verify_multictr_logical_port('PortFour', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 3)
+    verify_multictr_logical_port('PortFive', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 4)
+    verify_multictr_logical_port('PortSix', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 5)
+    verify_multictr_logical_port('PortSeven', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 6)
+    verify_multictr_logical_port('PortEight', 'ControllerSecond', child1, child2, ctr1_child, ctr2_child, 'yes', 7)
+
+    mininet_test.close_topology(child2)
+    mininet_test.close_topology(child1)
+    print "DELETE CONTROLLER1"
+    retval=controller.delete_controller_ex('ControllerFirst')
+    if retval != 0:
+        print "CONTROLLER1 delete failed"
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    print "DELETE CONTROLLER2"
+    retval=controller.delete_controller_ex('ControllerSecond')
+    if retval != 0:
+        print "CONTROLLER2 delete failed"
+        stop_controller(ctr1_child)
+        stop_controller(ctr2_child)
+        exit(1)
+
+    print "MULTI-CONTROLLER MULTI-MININET PHYSICAL READ TEST SUCCESS"
+
 # Main Block
 if __name__ == '__main__':
-  print '*****Switch TESTS******'
-  test()
+    print '*****Switch TESTS******'
+#Start controller1
+    ctr1_child = start_controller('ControllerFirst')
+    insync(150)
+    test(ctr1_child)
+    test_physical_read_1(ctr1_child)
+    test_physical_read_2(ctr1_child)
+    test_physical_read_3(ctr1_child)
+    test_physical_read_4(ctr1_child)
+#Start controller2
+    ctr2_child = start_controller('ControllerSecond')
+    insync(150)
+    test_multi_ctr_multi_mininet(ctr1_child, ctr2_child)
+    stop_controller(ctr1_child)
+    stop_controller(ctr2_child)
 else:
-  print "Switch Loaded as Module"
+    print "Switch Loaded as Module"