diff --git a/src/test/setup/cord-test.py b/src/test/setup/cord-test.py
index d48edff..66dd299 100755
--- a/src/test/setup/cord-test.py
+++ b/src/test/setup/cord-test.py
@@ -96,18 +96,25 @@
         self.vcpes = olt_config.get_vcpes()
         #Try using the host interface in olt conf to setup the switch
         self.switches = self.port_map['switches']
+        voltha_network = VolthaService.get_network('voltha')
+        voltha_rest_ip = VolthaService.get_ip('chameleon')
         if env is not None:
             env['TEST_SWITCH'] = self.switches[0]
             env['TEST_SWITCHES'] = ','.join(self.switches)
             env['TEST_HOST'] = self.name
             env['TEST_INSTANCE'] = instance
             env['TEST_INSTANCES'] = num_instances
+            if voltha_rest_ip:
+                env['VOLTHA_HOST'] = voltha_rest_ip
         if self.create:
             print('Starting test container %s, image %s, tag %s' %(self.name, self.image, self.tag))
             self.start(rm = False, volumes = volumes, environment = env,
                        host_config = host_config, tty = True)
             if network is not None:
                 Container.connect_to_network(self.name, network)
+            if voltha_network:
+                print('Connecting container to VOLTHA container network %s' %(voltha_network))
+                Container.connect_to_network(self.name, voltha_network)
 
     def execute_switch(self, cmd, shell = False):
         if self.olt:
@@ -708,7 +715,8 @@
 
     if voltha_loc:
         #start voltha
-        voltha = VolthaService(voltha_loc, onos_ips[0], interface = voltha_intf, olt_config = olt_config_file)
+        voltha = VolthaService(voltha_loc, onos_ips[0], interface = voltha_intf,
+                               olt_config = olt_config_file, container_mode = test_manifest.voltha_container_mode)
         voltha.start()
 
     if radius_ip is None:
@@ -988,7 +996,8 @@
 
     if voltha_loc:
         #start voltha
-        voltha = VolthaService(voltha_loc, onos_ips[0], interface = voltha_intf, olt_config = olt_config_file)
+        voltha = VolthaService(voltha_loc, onos_ips[0], interface = voltha_intf,
+                               olt_config = olt_config_file, container_mode = test_manifest.voltha_container_mode)
         voltha.start()
 
     ##Start Radius container if not started
@@ -1354,6 +1363,8 @@
                             help='Specify the voltha interface for voltha to listen')
     parser_run.add_argument('-voltha-enable', '--voltha-enable', action='store_true',
                             help='Run the tests with voltha environment enabled')
+    parser_run.add_argument('-voltha-container-mode', '--voltha-container-mode', action='store_true',
+                            help='Run the tests with voltha container environment enabled')
     parser_run.add_argument('-expose-port', '--expose-port', action='store_true',
                             help='Start ONOS by exposing the controller ports to the host.'
                             'Add +1 for every other onos/cluster instance when running more than 1 ONOS instances')
@@ -1406,6 +1417,8 @@
                               help='Specify the voltha interface for voltha to listen')
     parser_setup.add_argument('-voltha-enable', '--voltha-enable', action='store_true',
                               help='Run the tests with voltha environment enabled')
+    parser_setup.add_argument('-voltha-container-mode', '--voltha-container-mode', action='store_true',
+                              help='Run the tests with voltha container environment enabled')
     parser_setup.add_argument('-expose-port', '--expose-port', action='store_true',
                               help='Start ONOS by exposing the controller ports to the host.'
                               'Add +1 for every other onos/cluster instance when running more than 1 ONOS instances')
diff --git a/src/test/utils/CordTestConfig.py b/src/test/utils/CordTestConfig.py
index 0d14239..f82be0e 100644
--- a/src/test/utils/CordTestConfig.py
+++ b/src/test/utils/CordTestConfig.py
@@ -22,7 +22,7 @@
 from nose.plugins import Plugin
 from CordTestUtils import log_test as log
 from CordTestUtils import running_on_pod
-from VolthaCtrl import voltha_setup, voltha_teardown
+from VolthaCtrl import voltha_setup, voltha_teardown, VolthaService
 from SSHTestAgent import SSHTestAgent
 log.setLevel('INFO')
 
@@ -91,7 +91,8 @@
                 setattr(class_test, k, v)
 
     #check for voltha and configure as appropriate
-    voltha_attrs = dict(host='172.17.0.1',
+    voltha_attrs = dict(host = VolthaService.DOCKER_HOST_IP,
+                        ponsim_host = VolthaService.PONSIM_HOST,
                         rest_port = 8881,
                         config_fake = False,
                         olt_type = 'ponsim_olt',
@@ -105,6 +106,13 @@
     if hasattr(class_test, 'VOLTHA_AUTO_CONFIGURE'):
         voltha_configure = getattr(class_test, 'VOLTHA_AUTO_CONFIGURE')
 
+    if hasattr(class_test, 'VOLTHA_HOST'):
+        #update the voltha host ip based on chameleon IP for rest interface
+        rest_interface = VolthaService.get_ip('chameleon')
+        if rest_interface:
+            log.info('Updating VOLTHA_HOST IP to %s' %rest_interface)
+            setattr(class_test, 'VOLTHA_HOST', rest_interface)
+
     if voltha_enabled and voltha_configure:
         for k,v in voltha_attrs.iteritems():
             voltha_attr = 'VOLTHA_{}'.format(k.upper())
diff --git a/src/test/utils/TestManifest.py b/src/test/utils/TestManifest.py
index 8829340..5b4cb0a 100644
--- a/src/test/utils/TestManifest.py
+++ b/src/test/utils/TestManifest.py
@@ -69,6 +69,7 @@
             self.voltha_loc = args.voltha_loc
             self.voltha_intf = args.voltha_intf
             self.voltha_enable = args.voltha_enable
+            self.voltha_container_mode = args.voltha_container_mode
             self.expose_port = args.expose_port
         else:
             with open(self.manifest, 'r') as fd:
@@ -102,4 +103,7 @@
             if self.voltha_loc:
                 voltha_enable = True
             self.voltha_enable = data.get('voltha_enable', voltha_enable)
+            self.voltha_container_mode = data.get('voltha_container_mode', False)
             self.expose_port = data.get('expose_port', False)
+            if self.voltha_enable and self.voltha_container_mode:
+                self.expose_port = True
diff --git a/src/test/utils/VolthaCtrl.py b/src/test/utils/VolthaCtrl.py
index 644d487..cf616c7 100644
--- a/src/test/utils/VolthaCtrl.py
+++ b/src/test/utils/VolthaCtrl.py
@@ -26,10 +26,17 @@
 
 class VolthaService(object):
     services = ('consul', 'kafka', 'zookeeper', 'registrator', 'fluentd')
+    standalone_services = ('chameleon', 'voltha', 'ofagent', 'vcli')
     compose_file = 'docker-compose-system-test.yml'
     service_map = {}
+    PROJECT = 'cordtester'
+    NETWORK = '{}_default'.format(PROJECT)
+    CONTAINER_MODE = False
+    REST_SERVICE = 'chameleon'
+    DOCKER_HOST_IP = '172.17.0.1'
+    PONSIM_HOST = '172.17.0.1'
 
-    def __init__(self, voltha_loc, controller, interface = 'eth0', olt_config = None):
+    def __init__(self, voltha_loc, controller, interface = 'eth0', olt_config = None, container_mode = False):
         if not os.access(voltha_loc, os.F_OK):
             raise Exception('Voltha location %s not found' %voltha_loc)
         compose_file_loc = os.path.join(voltha_loc, 'compose', self.compose_file)
@@ -39,6 +46,7 @@
         self.controller = controller
         self.interface = interface
         self.compose_file_loc = compose_file_loc
+        VolthaService.CONTAINER_MODE = container_mode
         num_onus = 1
         if olt_config is not None:
             port_map, _ = OltConfig(olt_config).olt_port_map()
@@ -46,81 +54,102 @@
                 num_onus = max(1, len(port_map['ports']))
         self.num_onus = num_onus
 
-    def start(self):
-        start_cmd = 'docker-compose -f {} up -d {} {} {} {} {}'.format(self.compose_file_loc,
-                                                                       *self.services)
+    def start_services(self, *services):
+        services_fmt = ' {}' * len(services)
+        services_cmd_fmt = 'DOCKER_HOST_IP={} docker-compose -p {} -f {} up -d {}'.format(self.DOCKER_HOST_IP,
+                                                                                          self.PROJECT,
+                                                                                          self.compose_file_loc,
+                                                                                          services_fmt)
+        start_cmd = services_cmd_fmt.format(*services)
         ret = os.system(start_cmd)
         if ret != 0:
             raise Exception('Failed to start voltha services. Failed with code %d' %ret)
 
-        for service in self.services:
-            name = 'compose_{}_1'.format(service)
-            network = 'compose_default'
+        for service in services:
+            name = '{}_{}_1'.format(self.PROJECT, service)
             cnt = Container(name, name)
-            ip = cnt.ip(network = network)
+            ip = cnt.ip(network = self.NETWORK)
             if not ip:
                 raise Exception('IP not found for container %s' %name)
             print('IP %s for service %s' %(ip, service))
-            self.service_map[service] = dict(name = name, network = network, ip = ip)
+            self.service_map[service] = dict(name = name, network = self.NETWORK, ip = ip)
 
-        #first start chameleon
-        chameleon_start_cmd = "cd {} && sh -c '. ./env.sh && \
-        nohup python chameleon/main.py -v --consul=localhost:8500 \
-        --fluentd={}:24224 --grpc-endpoint=localhost:50555 \
-        >/tmp/chameleon.log 2>&1 &'".format(self.voltha_loc,
-                                            self.service_map['fluentd']['ip'])
-        if not self.service_running('python chameleon/main.py'):
-            ret = os.system(chameleon_start_cmd)
-            if ret != 0:
-                raise Exception('VOLTHA chameleon service not started. Failed with return code %d' %ret)
+    def ponmgmt_enable(self):
+        cmds = ('echo 8 | tee /sys/class/net/ponmgmt/bridge/group_fwd_mask',
+                'brctl addif ponmgmt {} >/dev/null 2>&1'.format(self.interface),
+        )
+        for cmd in cmds:
+            try:
+                os.system(cmd)
+            except:
+                pass
+
+    def start(self):
+        self.start_services(*self.services)
+        if self.CONTAINER_MODE is True:
+            self.start_services(*self.standalone_services)
+            #enable multicast mac forwarding:
+            self.ponmgmt_enable()
             time.sleep(10)
         else:
-            print('Chameleon voltha sevice is already running. Skipped start')
+            #first start chameleon
+            chameleon_start_cmd = "cd {} && sh -c '. ./env.sh && \
+            nohup python chameleon/main.py -v --consul=localhost:8500 \
+            --fluentd={}:24224 --grpc-endpoint=localhost:50555 \
+            >/tmp/chameleon.log 2>&1 &'".format(self.voltha_loc,
+                                                self.service_map['fluentd']['ip'])
+            if not self.service_running('python chameleon/main.py'):
+                ret = os.system(chameleon_start_cmd)
+                if ret != 0:
+                    raise Exception('VOLTHA chameleon service not started. Failed with return code %d' %ret)
+                time.sleep(10)
+            else:
+                print('Chameleon voltha sevice is already running. Skipped start')
 
-        #now start voltha and ofagent
-        voltha_setup_cmd = "cd {} && sh -c '. ./env.sh && make rebuild-venv && make protos'".format(self.voltha_loc)
-        voltha_start_cmd = "cd {} && sh -c '. ./env.sh && \
-        nohup python voltha/main.py -v --consul=localhost:8500 --kafka={}:9092 -I {} \
-        --fluentd={}:24224 --rest-port=8880 --grpc-port=50555 \
-        >/tmp/voltha.log 2>&1 &'".format(self.voltha_loc,
-                                         self.service_map['kafka']['ip'],
-                                         self.interface,
-                                         self.service_map['fluentd']['ip'])
-        pki_dir = '{}/pki'.format(self.voltha_loc)
-        if not self.service_running('python voltha/main.py'):
-            voltha_pki_dir = '/voltha'
-            if os.access(pki_dir, os.F_OK):
-                pki_xfer_cmd = 'mkdir -p {} && cp -rv {}/pki {}'.format(voltha_pki_dir,
-                                                                        self.voltha_loc,
-                                                                        voltha_pki_dir)
-                os.system(pki_xfer_cmd)
-            #os.system(voltha_setup_cmd)
-            ret = os.system(voltha_start_cmd)
-            if ret != 0:
-                raise Exception('Failed to start VOLTHA. Return code %d' %ret)
-            time.sleep(10)
-        else:
-            print('VOLTHA core is already running. Skipped start')
+            #now start voltha and ofagent
+            voltha_setup_cmd = "cd {} && sh -c '. ./env.sh && make rebuild-venv && make protos'".format(self.voltha_loc)
+            voltha_start_cmd = "cd {} && sh -c '. ./env.sh && \
+            nohup python voltha/main.py -v --consul=localhost:8500 --kafka={}:9092 -I {} \
+            --fluentd={}:24224 --rest-port=8880 --grpc-port=50555 \
+            >/tmp/voltha.log 2>&1 &'".format(self.voltha_loc,
+                                             self.service_map['kafka']['ip'],
+                                             self.interface,
+                                             self.service_map['fluentd']['ip'])
+            pki_dir = '{}/pki'.format(self.voltha_loc)
+            if not self.service_running('python voltha/main.py'):
+                voltha_pki_dir = '/voltha'
+                if os.access(pki_dir, os.F_OK):
+                    pki_xfer_cmd = 'mkdir -p {} && cp -rv {}/pki {}'.format(voltha_pki_dir,
+                                                                            self.voltha_loc,
+                                                                            voltha_pki_dir)
+                    os.system(pki_xfer_cmd)
+                #os.system(voltha_setup_cmd)
+                ret = os.system(voltha_start_cmd)
+                if ret != 0:
+                    raise Exception('Failed to start VOLTHA. Return code %d' %ret)
+                time.sleep(10)
+            else:
+                print('VOLTHA core is already running. Skipped start')
 
-        ofagent_start_cmd = "cd {} && sh -c '. ./env.sh && \
-        nohup python ofagent/main.py -v --consul=localhost:8500 \
-        --fluentd={}:24224 --controller={}:6653 --grpc-endpoint=localhost:50555 \
-        >/tmp/ofagent.log 2>&1 &'".format(self.voltha_loc,
-                                          self.service_map['fluentd']['ip'],
-                                          self.controller)
-        if not self.service_running('python ofagent/main.py'):
-            ofagent_pki_dir = '/ofagent'
-            if os.access(pki_dir, os.F_OK):
-                pki_xfer_cmd = 'mkdir -p {} && cp -rv {}/pki {}'.format(ofagent_pki_dir,
-                                                                        self.voltha_loc,
-                                                                        ofagent_pki_dir)
-                os.system(pki_xfer_cmd)
-            ret = os.system(ofagent_start_cmd)
-            if ret != 0:
-                raise Exception('VOLTHA ofagent not started. Failed with return code %d' %ret)
-            time.sleep(10)
-        else:
-            print('VOLTHA ofagent is already running. Skipped start')
+            ofagent_start_cmd = "cd {} && sh -c '. ./env.sh && \
+            nohup python ofagent/main.py -v --consul=localhost:8500 \
+            --fluentd={}:24224 --controller={}:6653 --grpc-endpoint=localhost:50555 \
+            >/tmp/ofagent.log 2>&1 &'".format(self.voltha_loc,
+                                              self.service_map['fluentd']['ip'],
+                                              self.controller)
+            if not self.service_running('python ofagent/main.py'):
+                ofagent_pki_dir = '/ofagent'
+                if os.access(pki_dir, os.F_OK):
+                    pki_xfer_cmd = 'mkdir -p {} && cp -rv {}/pki {}'.format(ofagent_pki_dir,
+                                                                            self.voltha_loc,
+                                                                            ofagent_pki_dir)
+                    os.system(pki_xfer_cmd)
+                ret = os.system(ofagent_start_cmd)
+                if ret != 0:
+                    raise Exception('VOLTHA ofagent not started. Failed with return code %d' %ret)
+                time.sleep(10)
+            else:
+                print('VOLTHA ofagent is already running. Skipped start')
 
         ponsim_start_cmd = "cd {} && sh -c '. ./env.sh && \
         nohup python ponsim/main.py -o {} -v >/tmp/ponsim.log 2>&1 &'".format(self.voltha_loc, self.num_onus)
@@ -147,13 +176,30 @@
                     pass
 
     def stop(self):
-        self.kill_service('python voltha/main.py')
-        self.kill_service('python ofagent/main.py')
-        self.kill_service('python chameleon/main.py')
-        self.kill_service('python ponsim/main.py')
-        service_stop_cmd = 'docker-compose -f {} down'.format(self.compose_file_loc)
+        if self.CONTAINER_MODE is False:
+            self.kill_service('python voltha/main.py')
+            self.kill_service('python ofagent/main.py')
+            self.kill_service('python chameleon/main.py')
+            self.kill_service('python ponsim/main.py')
+        service_stop_cmd = 'DOCKER_HOST_IP={} docker-compose -p {} -f {} down'.format(self.DOCKER_HOST_IP,
+                                                                                      self.PROJECT,
+                                                                                      self.compose_file_loc)
         os.system(service_stop_cmd)
 
+    @classmethod
+    def get_ip(cls, service):
+        if service in cls.service_map:
+            return cls.service_map[service]['ip']
+        if service == cls.REST_SERVICE:
+            return os.getenv('VOLTHA_HOST', None)
+        return None
+
+    @classmethod
+    def get_network(cls, service):
+        if service in cls.service_map:
+            return cls.service_map[service]['network']
+        return None
+
 class VolthaCtrl(object):
     UPLINK_VLAN_START = 333
     UPLINK_VLAN_MAP = { 'of:0000000000000001' : '222' }
@@ -251,7 +297,7 @@
         if olt_mac is not None:
             log.info('Pre-provisioning %s with mac %s' %(olt_type, olt_mac))
         else:
-            log.info('Pre-provisioning %s with address %s' %(olt_type, address))
+            log.info('Pre-provisioning %s with address %s, url %s' %(olt_type, address, url))
         resp = requests.post(url, data = json.dumps(device_config))
         if resp.ok is not True or resp.status_code != 200:
             return None, False
@@ -347,7 +393,7 @@
     olt_app_file = os.path.join(our_path, '..', 'apps/olt-app-{}.oar'.format(olt_app_version))
     return olt_app_file
 
-def voltha_setup(host = '172.17.0.1', olt_ip = None, rest_port = VolthaCtrl.REST_PORT,
+def voltha_setup(host = '172.17.0.1', ponsim_host = VolthaService.PONSIM_HOST, olt_ip = None, rest_port = VolthaCtrl.REST_PORT,
                  olt_type = 'ponsim_olt', olt_mac = '00:0c:e2:31:12:00',
                  uplink_vlan_map = VolthaCtrl.UPLINK_VLAN_MAP,
                  uplink_vlan_start = VolthaCtrl.UPLINK_VLAN_START,
@@ -357,7 +403,7 @@
                         uplink_vlan_map = uplink_vlan_map,
                         uplink_vlan_start = uplink_vlan_start)
     if olt_type.startswith('ponsim'):
-        ponsim_address = '{}:50060'.format(host)
+        ponsim_address = '{}:50060'.format(ponsim_host)
         log.info('Enabling ponsim olt')
         device_id, status = voltha.enable_device(olt_type, address = ponsim_address)
     else:
diff --git a/src/test/voltha/volthaTest.py b/src/test/voltha/volthaTest.py
index eb06815..c2789bb 100644
--- a/src/test/voltha/volthaTest.py
+++ b/src/test/voltha/volthaTest.py
@@ -30,7 +30,7 @@
 from twisted.internet import defer
 from CordTestConfig import setup_module, teardown_module
 from CordTestUtils import get_mac, log_test
-from VolthaCtrl import VolthaCtrl, voltha_setup, voltha_teardown
+from VolthaCtrl import VolthaCtrl, VolthaService, voltha_setup, voltha_teardown
 from CordTestUtils import log_test, get_controller
 from portmaps import g_subscriber_port_map
 from OltConfig import *
@@ -212,7 +212,8 @@
 
     OLT_TYPE = 'tibit_olt'
     OLT_MAC = '00:0c:e2:31:12:00'
-    VOLTHA_HOST = 'localhost'
+    VOLTHA_HOST = VolthaService.DOCKER_HOST_IP
+    VOLTHA_PONSIM_HOST = VolthaService.PONSIM_HOST
     VOLTHA_REST_PORT = 8881
     VOLTHA_OLT_TYPE = 'ponsim_olt'
     VOLTHA_OLT_MAC = '00:0c:e2:31:12:00'
@@ -221,10 +222,10 @@
     voltha_attrs = None
     success = True
     olt_device_id = None
-    apps = ('org.opencord.aaa', 'org.onosproject.dhcp')
+    apps = ('org.opencord.aaa', 'org.onosproject.dhcp',)
     #apps = ('org.opencord.aaa', 'org.onosproject.dhcp', 'org.onosproject.dhcprelay')
-    app_dhcp = ('org.onosproject.dhcp')
-    app_dhcprelay = ('org.onosproject.dhcprelay')
+    app_dhcp = ('org.onosproject.dhcp',)
+    app_dhcprelay = ('org.onosproject.dhcprelay',)
     olt_apps = () #'org.opencord.cordmcast')
     vtn_app = 'org.opencord.vtn'
     table_app = 'org.ciena.cordigmp'
@@ -433,7 +434,6 @@
                                 uplink_vlan_map = cls.VOLTHA_UPLINK_VLAN_MAP,
                                 uplink_vlan_start = cls.VOLTHA_UPLINK_VLAN_START)
         cls.voltha = VolthaCtrl(**cls.voltha_attrs)
-        cls.install_app_table()
         cls.olt = OltConfig(olt_conf_file = cls.olt_conf_file)
         cls.port_map, cls.port_list = cls.olt.olt_port_map()
         cls.switches = cls.port_map['switches']
@@ -453,7 +453,6 @@
             onos_ctrl = OnosCtrl(app)
             onos_ctrl.deactivate()
         cls.deactivate_apps(cls.app_dhcprelay)
-        cls.install_app_igmp()
         log_test.info('TearDownClass Restarting the Radius Server in the TA setup')
         cord_test_radius_restart()
 
@@ -529,6 +528,7 @@
             if deactivate is True:
                onos_ctrl.deactivate()
                time.sleep(2)
+               log_test.info('Activating app %s' %app)
                status, _ = onos_ctrl.activate()
                assert_equal(status, True)
                time.sleep(2)
@@ -540,6 +540,7 @@
         cls.success = True
         for app in apps:
             onos_ctrl = OnosCtrl(app)
+            log_test.info('Deactivating app %s' %app)
             status, _ = onos_ctrl.deactivate()
             if status is False:
                cls.success = False
@@ -1457,7 +1458,7 @@
                               rest_port = self.VOLTHA_REST_PORT,
                               uplink_vlan_map = self.VOLTHA_UPLINK_VLAN_MAP)
           if self.VOLTHA_OLT_TYPE.startswith('ponsim'):
-             ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+             ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
              log_test.info('Enabling ponsim olt')
              device_id, status = voltha.enable_device(self.VOLTHA_OLT_TYPE, address = ponsim_address)
              if device_id != '':
@@ -1589,7 +1590,7 @@
 
     def test_ponsim_enable_disable(self):
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         try:
@@ -1622,6 +1623,7 @@
         """
         ret = voltha_setup(
               host = self.VOLTHA_HOST,
+              ponsim_host = self.VOLTHA_PONSIM_HOST,
               rest_port = self.VOLTHA_REST_PORT,
               olt_type = 'ponsim_olt',
               uplink_vlan_map = self.VOLTHA_UPLINK_VLAN_MAP,
@@ -1657,7 +1659,7 @@
         df = defer.Deferred()
         def tls_flow_check_with_no_cert_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1699,7 +1701,7 @@
         df = defer.Deferred()
         def tls_flow_check_with_invalid_cert_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1740,7 +1742,7 @@
         df = defer.Deferred()
         def tls_flow_check_with_no_cert_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1784,7 +1786,7 @@
         def tls_flow_check_deactivating_app(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1834,7 +1836,7 @@
         def tls_flow_check_restarting_radius(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1887,7 +1889,7 @@
         def tls_flow_check_operating_olt_state(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1940,7 +1942,7 @@
         def tls_flow_check_operating_olt_state(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -1996,7 +1998,7 @@
         def tls_flow_check_with_disable_olt_device_scenario(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2053,7 +2055,7 @@
         def tls_flow_check_operating_olt_state(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2108,7 +2110,7 @@
         def tls_flow_check_with_disable_olt_device_scenario(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2165,7 +2167,7 @@
         def tls_flow_check_operating_onu_state(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2224,7 +2226,7 @@
         def tls_flow_check_operating_olt_state(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2284,7 +2286,7 @@
         def tls_flow_check_on_two_subscribers_same_olt_device(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2339,7 +2341,7 @@
         def tls_flow_check_on_two_subscribers_same_olt_device(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2396,7 +2398,7 @@
         def tls_flow_check_on_two_subscribers_same_olt_device(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2453,7 +2455,7 @@
         def tls_flow_check_on_two_subscribers_same_olt_device(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2512,7 +2514,7 @@
         def tls_flow_check_on_two_subscribers_same_olt_device(df):
             aaa_app = ["org.opencord.aaa"]
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             devices_list = self.voltha.get_devices()
             log_test.info('All available devices on voltha = %s'%devices_list['items'])
@@ -2626,7 +2628,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2668,7 +2670,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2712,7 +2714,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2753,7 +2755,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2796,7 +2798,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2839,7 +2841,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2882,7 +2884,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2925,7 +2927,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -2969,7 +2971,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3010,7 +3012,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3051,7 +3053,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3096,7 +3098,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3147,7 +3149,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3190,7 +3192,7 @@
         df = defer.Deferred()
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3235,7 +3237,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3290,7 +3292,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3348,7 +3350,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3403,7 +3405,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3457,7 +3459,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3509,7 +3511,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3566,7 +3568,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3625,7 +3627,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3680,7 +3682,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3735,7 +3737,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3789,7 +3791,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3842,7 +3844,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3894,7 +3896,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -3946,7 +3948,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4001,7 +4003,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4056,7 +4058,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4115,7 +4117,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4170,7 +4172,7 @@
         dhcp_app =  'org.onosproject.dhcp'
         def dhcp_flow_check_scenario(df):
             log_test.info('Enabling ponsim_olt')
-            ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+            ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
             device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
             assert_not_equal(device_id, None)
             voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4338,7 +4340,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4387,7 +4389,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4438,7 +4440,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4488,7 +4490,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4540,7 +4542,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4598,7 +4600,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4673,7 +4675,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4731,7 +4733,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4785,7 +4787,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4837,7 +4839,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4904,7 +4906,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)
@@ -4964,7 +4966,7 @@
         subnet = self.default_subnet_config
         dhcpd_interface_list = self.relay_interfaces
         log_test.info('Enabling ponsim_olt')
-        ponsim_address = '{}:50060'.format(self.VOLTHA_HOST)
+        ponsim_address = '{}:50060'.format(self.VOLTHA_PONSIM_HOST)
         device_id, status = self.voltha.enable_device('ponsim_olt', address = ponsim_address)
         assert_not_equal(device_id, None)
         voltha = VolthaCtrl(**self.voltha_attrs)