diff --git a/src/test/cordSubscriber/cordSubscriberTest.py b/src/test/cordSubscriber/cordSubscriberTest.py
index 7a52092..6606ec5 100644
--- a/src/test/cordSubscriber/cordSubscriberTest.py
+++ b/src/test/cordSubscriber/cordSubscriberTest.py
@@ -150,7 +150,15 @@
       def pool_cb(self):
             for cb in self.test_cbs:
                   if cb:
-                        cb(self.subscriber)
+                        self.test_status = cb(self.subscriber)
+                        if self.test_status is not True:
+                           ## This is chaning for other sub status has to check again
+                           self.test_status = True
+                           log.info('This service is failed and other services will not run for this subscriber')
+                           break
+            log.info('This Subscriber is tested for multiple service elgibility ')
+            self.test_status = True
+
 
 class subscriber_exchange(unittest.TestCase):
 
@@ -185,6 +193,52 @@
       recv_timeout = False
       onos_restartable = not bool(int(os.getenv('ONOS_RESTART_DISABLED', 0)))
 
+      INTF_TX_DEFAULT = 'veth2'
+      INTF_RX_DEFAULT = 'veth0'
+      SUBSCRIBER_TIMEOUT = 300
+
+      CLIENT_CERT = """-----BEGIN CERTIFICATE-----
+MIICuDCCAiGgAwIBAgIBAjANBgkqhkiG9w0BAQUFADCBizELMAkGA1UEBhMCVVMx
+CzAJBgNVBAgTAkNBMRIwEAYDVQQHEwlTb21ld2hlcmUxEzARBgNVBAoTCkNpZW5h
+IEluYy4xHjAcBgkqhkiG9w0BCQEWD2FkbWluQGNpZW5hLmNvbTEmMCQGA1UEAxMd
+RXhhbXBsZSBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMTYwNjA2MjExMjI3WhcN
+MTcwNjAxMjExMjI3WjBnMQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEzARBgNV
+BAoTCkNpZW5hIEluYy4xFzAVBgNVBAMUDnVzZXJAY2llbmEuY29tMR0wGwYJKoZI
+hvcNAQkBFg51c2VyQGNpZW5hLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC
+gYEAwvXiSzb9LZ6c7uNziUfKvoHO7wu/uiFC5YUpXbmVGuGZizbVrny0xnR85Dfe
++9R4diansfDhIhzOUl1XjN3YDeSS9OeF5YWNNE8XDhlz2d3rVzaN6hIhdotBkUjg
+rUewjTg5OFR31QEyG3v8xR3CLgiE9xQELjZbSA07pD79zuUCAwEAAaNPME0wEwYD
+VR0lBAwwCgYIKwYBBQUHAwIwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL3d3dy5l
+eGFtcGxlLmNvbS9leGFtcGxlX2NhLmNybDANBgkqhkiG9w0BAQUFAAOBgQDAjkrY
+6tDChmKbvr8w6Du/t8vHjTCoCIocHTN0qzWOeb1YsAGX89+TrWIuO1dFyYd+Z0KC
+PDKB5j/ygml9Na+AklSYAVJIjvlzXKZrOaPmhZqDufi+rXWti/utVqY4VMW2+HKC
+nXp37qWeuFLGyR1519Y1d6F/5XzqmvbwURuEug==
+-----END CERTIFICATE-----"""
+
+      CLIENT_CERT_INVALID = '''-----BEGIN CERTIFICATE-----
+MIIDvTCCAqWgAwIBAgIBAjANBgkqhkiG9w0BAQUFADCBizELMAkGA1UEBhMCVVMx
+CzAJBgNVBAgTAkNBMRIwEAYDVQQHEwlTb21ld2hlcmUxEzARBgNVBAoTCkNpZW5h
+IEluYy4xHjAcBgkqhkiG9w0BCQEWD2FkbWluQGNpZW5hLmNvbTEmMCQGA1UEAxMd
+RXhhbXBsZSBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMTYwMzExMTg1MzM2WhcN
+MTcwMzA2MTg1MzM2WjBnMQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEzARBgNV
+BAoTCkNpZW5hIEluYy4xFzAVBgNVBAMUDnVzZXJAY2llbmEuY29tMR0wGwYJKoZI
+hvcNAQkBFg51c2VyQGNpZW5hLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
+AQoCggEBAOxemcBsPn9tZsCa5o2JA6sQDC7A6JgCNXXl2VFzKLNNvB9PS6D7ZBsQ
+5An0zEDMNzi51q7lnrYg1XyiE4S8FzMGAFr94RlGMQJUbRD9V/oqszMX4k++iAOK
+tIA1gr3x7Zi+0tkjVSVzXTmgNnhChAamdMsjYUG5+CY9WAicXyy+VEV3zTphZZDR
+OjcjEp4m/TSXVPYPgYDXI40YZKX5BdvqykWtT/tIgZb48RS1NPyN/XkCYzl3bv21
+qx7Mc0fcEbsJBIIRYTUkfxnsilcnmLxSYO+p+DZ9uBLBzcQt+4Rd5pLSfi21WM39
+2Z2oOi3vs/OYAPAqgmi2JWOv3mePa/8CAwEAAaNPME0wEwYDVR0lBAwwCgYIKwYB
+BQUHAwIwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL3d3dy5leGFtcGxlLmNvbS9l
+eGFtcGxlX2NhLmNybDANBgkqhkiG9w0BAQUFAAOCAQEALBzMPDTIB6sLyPl0T6JV
+MjOkyldAVhXWiQsTjaGQGJUUe1cmUJyZbUZEc13MygXMPOM4x7z6VpXGuq1c/Vxn
+VzQ2fNnbJcIAHi/7G8W5/SQfPesIVDsHTEc4ZspPi5jlS/MVX3HOC+BDbOjdbwqP
+RX0JEr+uOyhjO+lRxG8ilMRACoBUbw1eDuVDoEBgErSUC44pq5ioDw2xelc+Y6hQ
+dmtYwfY0DbvwxHtA495frLyPcastDiT/zre7NL51MyUDPjjYjghNQEwvu66IKbQ3
+T1tJBrgI7/WI+dqhKBFolKGKTDWIHsZXQvZ1snGu/FRYzg1l+R/jT8cRB9BDwhUt
+yg==
+-----END CERTIFICATE-----'''
+
       @classmethod
       def load_device_id(cls):
             '''Configure the device id'''
@@ -372,6 +426,10 @@
                   log.info('Running subscriber %s tls auth test' %subscriber.name)
                   tls.runTest()
                   self.test_status = True
+                  return self.test_status
+            else:
+                  self.test_status = True
+                  return self.test_status
 
       def dhcp_verify(self, subscriber):
             if subscriber.has_service('DHCP'):
@@ -379,9 +437,11 @@
                   log.info('Subscriber %s got client ip %s from server %s' %(subscriber.name, cip, sip))
                   subscriber.src_list = [cip]
                   self.test_status = True
+                  return self.test_status
             else:
                   subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
                   self.test_status = True
+                  return self.test_status
 
       def dhcp_jump_verify(self, subscriber):
             if subscriber.has_service('DHCP'):
@@ -389,9 +449,11 @@
                   log.info('Subscriber %s got client ip %s from server %s' %(subscriber.name, cip, sip))
                   subscriber.src_list = [cip]
                   self.test_status = True
+                  return self.test_status
             else:
                   subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
                   self.test_status = True
+                  return self.test_status
 
       def dhcp_next_verify(self, subscriber):
             if subscriber.has_service('DHCP'):
@@ -399,9 +461,11 @@
                   log.info('Subscriber %s got client ip %s from server %s' %(subscriber.name, cip, sip))
                   subscriber.src_list = [cip]
                   self.test_status = True
+                  return self.test_status
             else:
                   subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
                   self.test_status = True
+                  return self.test_status
 
       def igmp_verify(self, subscriber):
             chan = 0
@@ -429,6 +493,7 @@
                         log.info('Joining channel %d for subscriber %s' %(chan, subscriber.name))
                         subscriber.channel_join(chan, delay = 0)
                   self.test_status = True
+                  return self.test_status
 
       def igmp_jump_verify(self, subscriber):
             if subscriber.has_service('IGMP'):
@@ -440,6 +505,7 @@
                         time.sleep(3)
                   log.info('Interface %s Jump RX stats for subscriber %s, %s' %(subscriber.iface, subscriber.name, subscriber.join_rx_stats))
                   self.test_status = True
+                  return self.test_status
 
       def igmp_next_verify(self, subscriber):
             if subscriber.has_service('IGMP'):
@@ -454,6 +520,7 @@
                         time.sleep(3)
                   log.info('Interface %s Join Next RX stats for subscriber %s, %s' %(subscriber.iface, subscriber.name, subscriber.join_rx_stats))
                   self.test_status = True
+                  return self.test_status
 
       def generate_port_list(self, subscribers, channels):
             return self.port_list[:subscribers]
@@ -488,19 +555,30 @@
             igmpChannel.igmp_load_ssm_config(ssm_list)
 
       def subscriber_join_verify( self, num_subscribers = 10, num_channels = 1,
-                                  channel_start = 0, cbs = None, port_list = []):
+                                  channel_start = 0, cbs = None, port_list = [], negative_subscriber_auth = None):
+
           self.test_status = False
-          self.num_subscribers = num_subscribers
+          subscribers_count = num_subscribers
+          sub_loop_count =  num_subscribers
           self.subscriber_load(create = True, num = num_subscribers,
                                num_channels = num_channels, channel_start = channel_start, port_list = port_list)
           self.onos_aaa_load()
-          self.thread_pool = ThreadPool(min(100, self.num_subscribers), queue_size=1, wait_timeout=1)
+          self.thread_pool = ThreadPool(min(100, subscribers_count), queue_size=1, wait_timeout=1)
+
           chan_leave = False #for single channel, multiple subscribers
-          if cbs is None:
+          if None in (cbs, negative_subscriber_auth):
                 cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify, self.traffic_verify)
                 chan_leave = True
+          cbs_negative = cbs
           for subscriber in self.subscriber_list:
                 subscriber.start()
+                if negative_subscriber_auth is 'half' and sub_loop_count%2 is not 0:
+                   cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify, self.traffic_verify)
+                elif negative_subscriber_auth is 'onethird' and sub_loop_count%3 is not 0:
+                   cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify, self.traffic_verify)
+                else:
+                   cbs = cbs_negative
+                sub_loop_count = sub_loop_count - 1
                 pool_object = subscriber_pool(subscriber, cbs)
                 self.thread_pool.addTask(pool_object.pool_cb)
           self.thread_pool.cleanUpThreads()
@@ -508,10 +586,531 @@
                 subscriber.stop()
                 if chan_leave is True:
                       subscriber.channel_leave(0)
-          self.num_subscribers = 0
+          subscribers_count = 0
           return self.test_status
 
-      def test_subscriber_join_recv(self):
+      def tls_invalid_cert(self, subscriber):
+          if subscriber.has_service('TLS'):
+             time.sleep(2)
+             log.info('Running subscriber %s tls auth test' %subscriber.name)
+             tls = TLSAuthTest(client_cert = self.CLIENT_CERT_INVALID)
+             tls.runTest()
+             if tls.failTest == True:
+                self.test_status = False
+             return self.test_status
+          else:
+              self.test_status = True
+              return self.test_status
+
+      def tls_no_cert(self, subscriber):
+          if subscriber.has_service('TLS'):
+             time.sleep(2)
+             log.info('Running subscriber %s tls auth test' %subscriber.name)
+             tls = TLSAuthTest(client_cert = '')
+             tls.runTest()
+             if tls.failTest == True:
+                self.test_status = False
+             return self.test_status
+          else:
+              self.test_status = True
+              return self.test_status
+
+      def tls_self_signed_cert(self, subscriber):
+          if subscriber.has_service('TLS'):
+             time.sleep(2)
+             log.info('Running subscriber %s tls auth test' %subscriber.name)
+             tls = TLSAuthTest(client_cert = self.CLIENT_CERT)
+             tls.runTest()
+             if tls.failTest == False:
+                self.test_status = True
+             return self.test_status
+          else:
+              self.test_status = True
+              return self.test_status
+
+      def tls_non_ca_authrized_cert(self, subscriber):
+          if subscriber.has_service('TLS'):
+             time.sleep(2)
+             log.info('Running subscriber %s tls auth test' %subscriber.name)
+             tls = TLSAuthTest(client_cert = self.CLIENT_CERT_NON_CA_AUTHORIZED)
+             tls.runTest()
+             if tls.failTest == False:
+                self.test_status = True
+             return self.test_status
+          else:
+              self.test_status = True
+              return self.test_status
+
+
+      def tls_Nsubscribers_use_same_valid_cert(self, subscriber):
+          if subscriber.has_service('TLS'):
+             time.sleep(2)
+             log.info('Running subscriber %s tls auth test' %subscriber.name)
+             num_users = 3
+             for i in xrange(num_users):
+                 tls = TLSAuthTest(intf = 'veth{}'.format(i*2))
+                 tls.runTest()
+             if tls.failTest == False:
+                self.test_status = True
+             return self.test_status
+          else:
+              self.test_status = True
+              return self.test_status
+
+      def dhcp_discover_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+             time.sleep(2)
+             log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+             t1 = self.subscriber_dhcp_1release()
+             self.test_status = True
+             return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_1release(self, iface = INTF_RX_DEFAULT):
+             config = {'startip':'10.10.100.20', 'endip':'10.10.100.21',
+                       'ip':'10.10.100.2', 'mac': "ca:fe:ca:fe:8a:fe",
+                       'subnet': '255.255.255.0', 'broadcast':'10.10.100.255', 'router':'10.10.100.1'}
+             self.onos_dhcp_table_load(config)
+             self.dhcp = DHCPTest(seed_ip = '10.10.100.10', iface = iface)
+             cip, sip = self.send_recv()
+             log.info('Releasing ip %s to server %s' %(cip, sip))
+             assert_equal(self.dhcp.release(cip), True)
+             log.info('Triggering DHCP discover again after release')
+             cip2, sip2 = self.send_recv(update_seed = True)
+             log.info('Verifying released IP was given back on rediscover')
+             assert_equal(cip, cip2)
+             log.info('Test done. Releasing ip %s to server %s' %(cip2, sip2))
+             assert_equal(self.dhcp.release(cip2), True)
+
+
+      def dhcp_client_reboot_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                  time.sleep(2)
+                  log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                  tl = self.subscriber_dhcp_client_request_after_reboot()
+                  self.test_status = True
+                  return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_client_request_after_reboot(self, iface = INTF_RX_DEFAULT):
+          #''' Client sends DHCP Request after reboot.'''
+
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+          cip, sip, mac, lval = self.dhcp.only_discover()
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+
+          log.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
+
+          if (cip == None and mac != None):
+                log.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
+                assert_not_equal(cip, None)
+
+          else:
+                new_cip, new_sip = self.dhcp.only_request(cip, mac)
+                if new_cip == None:
+                        log.info("Got DHCP server NAK.")
+                os.system('ifconfig '+iface+' down')
+                log.info('Client goes down.')
+                log.info('Delay for 5 seconds.')
+
+                time.sleep(5)
+
+                os.system('ifconfig '+iface+' up')
+                log.info('Client is up now.')
+
+                new_cip, new_sip = self.dhcp.only_request(cip, mac)
+                if new_cip == None:
+                        log.info("Got DHCP server NAK.")
+                        assert_not_equal(new_cip, None)
+                elif new_cip != None:
+                        log.info("Got DHCP ACK.")
+
+      def dhcp_client_renew_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_client_renew_time()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_client_renew_time(self, iface = INTF_RX_DEFAULT):
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+          cip, sip, mac , lval = self.dhcp.only_discover()
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+
+          log.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
+          if (cip == None and mac != None):
+                log.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
+                assert_not_equal(cip, None)
+          elif cip and sip and mac:
+                log.info("Triggering DHCP Request.")
+                new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, renew_time = True)
+                if new_cip and new_sip and lval:
+                        log.info("Client 's Renewal time is :%s",lval)
+                        log.info("Generating delay till renewal time.")
+                        time.sleep(lval)
+                        log.info("Client Sending Unicast DHCP request.")
+                        latest_cip, latest_sip = self.dhcp.only_request(new_cip, mac, unicast = True)
+                        if latest_cip and latest_sip:
+                                log.info("Got DHCP Ack. Lease Renewed for ip %s and mac %s from server %s." %
+                                                (latest_cip, mac, latest_sip) )
+
+                        elif latest_cip == None:
+                                log.info("Got DHCP NAK. Lease not renewed.")
+                elif new_cip == None or new_sip == None or lval == None:
+                        log.info("Got DHCP NAK.")
+
+      def dhcp_server_reboot_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_server_after_reboot()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_server_after_reboot(self, iface = INTF_RX_DEFAULT):
+          ''' DHCP server goes down.'''
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+          cip, sip, mac, lval = self.dhcp.only_discover()
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+          log.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
+          if (cip == None and mac != None):
+                log.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
+                assert_not_equal(cip, None)
+          else:
+                new_cip, new_sip = self.dhcp.only_request(cip, mac)
+                if new_cip == None:
+                        log.info("Got DHCP server NAK.")
+                        assert_not_equal(new_cip, None)
+                log.info('Getting DHCP server Down.')
+                onos_ctrl = OnosCtrl(self.dhcp_app)
+                onos_ctrl.deactivate()
+                for i in range(0,4):
+                        log.info("Sending DHCP Request.")
+                        log.info('')
+                        new_cip, new_sip = self.dhcp.only_request(cip, mac)
+                        if new_cip == None and new_sip == None:
+                                log.info('')
+                                log.info("DHCP Request timed out.")
+                        elif new_cip and new_sip:
+                                log.info("Got Reply from DHCP server.")
+                                assert_equal(new_cip,None) #Neagtive Test Case
+                log.info('Getting DHCP server Up.')
+#               self.activate_apps(self.dhcp_app)
+                onos_ctrl = OnosCtrl(self.dhcp_app)
+                status, _ = onos_ctrl.activate()
+                assert_equal(status, True)
+                time.sleep(3)
+                for i in range(0,4):
+                        log.info("Sending DHCP Request after DHCP server is up.")
+                        log.info('')
+                        new_cip, new_sip = self.dhcp.only_request(cip, mac)
+                        if new_cip == None and new_sip == None:
+                                log.info('')
+                                log.info("DHCP Request timed out.")
+                        elif new_cip and new_sip:
+                                log.info("Got Reply from DHCP server.")
+                                assert_equal(new_cip,None) #Neagtive Test Case
+
+      def dhcp_client_rebind_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_client_rebind_time()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_client_rebind_time(self, iface = INTF_RX_DEFAULT):
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+          cip, sip, mac, lval = self.dhcp.only_discover()
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+          log.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
+          if (cip == None and mac != None):
+                log.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
+                assert_not_equal(cip, None)
+          elif cip and sip and mac:
+                log.info("Triggering DHCP Request.")
+                new_cip, new_sip, lval = self.dhcp.only_request(cip, mac, rebind_time = True)
+                if new_cip and new_sip and lval:
+                        log.info("Client 's Rebind time is :%s",lval)
+                        log.info("Generating delay till rebind time.")
+                        time.sleep(lval)
+                        log.info("Client Sending broadcast DHCP requests for renewing lease or for getting new ip.")
+                        self.dhcp.after_T2 = True
+                        for i in range(0,4):
+                                latest_cip, latest_sip = self.dhcp.only_request(new_cip, mac)
+                                if latest_cip and latest_sip:
+                                        log.info("Got DHCP Ack. Lease Renewed for ip %s and mac %s from server %s." %
+                                                        (latest_cip, mac, latest_sip) )
+                                        break
+                                elif latest_cip == None:
+                                        log.info("Got DHCP NAK. Lease not renewed.")
+                        assert_not_equal(latest_cip, None)
+                elif new_cip == None or new_sip == None or lval == None:
+                        log.info("Got DHCP NAK.Lease not Renewed.")
+
+      def dhcp_starvation_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_starvation()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_starvation(self, iface = INTF_RX_DEFAULT):
+          '''DHCP starve'''
+          config = {'startip':'182.17.0.20', 'endip':'182.17.0.69',
+                    'ip':'182.17.0.2', 'mac': "ca:fe:c3:fe:ca:fe",
+                    'subnet': '255.255.255.0', 'broadcast':'182.17.0.255', 'router':'182.17.0.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '182.17.0.1', iface = iface)
+          log.info('Verifying 1 ')
+          for x in xrange(50):
+              mac = RandMAC()._fix()
+              self.send_recv(mac = mac)
+          log.info('Verifying 2 ')
+          cip, sip = self.send_recv(update_seed = True, validate = False)
+          assert_equal(cip, None)
+          assert_equal(sip, None)
+
+      def dhcp_same_client_multi_discovers_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_same_client_multiple_discover()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_same_client_multiple_discover(self, iface = INTF_RX_DEFAULT):
+          ''' DHCP Client sending multiple discover . '''
+          config = {'startip':'10.10.10.20', 'endip':'10.10.10.69',
+                    'ip':'10.10.10.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                    'subnet': '255.255.255.0', 'broadcast':'10.10.10.255', 'router':'10.10.10.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+          cip, sip, mac, lval = self.dhcp.only_discover()
+          log.info('Got dhcp client IP %s from server %s for mac %s . Not going to send DHCPREQUEST.' %
+                  (cip, sip, mac) )
+          log.info('Triggering DHCP discover again.')
+          new_cip, new_sip, new_mac , lval = self.dhcp.only_discover()
+          if cip == new_cip:
+                 log.info('Got same ip for 2nd DHCP discover for client IP %s from server %s for mac %s. Triggering DHCP Request. '
+                          % (new_cip, new_sip, new_mac) )
+          elif cip != new_cip:
+                log.info('Ip after 1st discover %s' %cip)
+                log.info('Map after 2nd discover %s' %new_cip)
+                assert_equal(cip, new_cip)
+
+      def dhcp_same_client_multi_request_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_same_client_multiple_request()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_same_client_multiple_request(self, iface = INTF_RX_DEFAULT):
+          ''' DHCP Client sending multiple repeat DHCP requests. '''
+          config = {'startip':'10.10.10.20', 'endip':'10.10.10.69',
+                    'ip':'10.10.10.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                    'subnet': '255.255.255.0', 'broadcast':'10.10.10.255', 'router':'10.10.10.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '10.10.10.1', iface = iface)
+          log.info('Sending DHCP discover and DHCP request.')
+          cip, sip = self.send_recv()
+          mac = self.dhcp.get_mac(cip)[0]
+          log.info("Sending DHCP request again.")
+          new_cip, new_sip = self.dhcp.only_request(cip, mac)
+          if (new_cip,new_sip) == (cip,sip):
+                log.info('Got same ip for 2nd DHCP Request for client IP %s from server %s for mac %s.'
+                          % (new_cip, new_sip, mac) )
+          elif (new_cip,new_sip):
+                log.info('No DHCP ACK')
+                assert_equal(new_cip, None)
+                assert_equal(new_sip, None)
+          else:
+                print "Something went wrong."
+
+      def dhcp_client_desired_ip_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_client_desired_address()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_client_desired_address(self, iface = INTF_RX_DEFAULT):
+          '''DHCP Client asking for desired IP address.'''
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.31', iface = iface)
+          cip, sip, mac , lval = self.dhcp.only_discover(desired = True)
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+          if cip == self.dhcp.seed_ip:
+                log.info('Got dhcp client IP %s from server %s for mac %s as desired .' %
+                  (cip, sip, mac) )
+          elif cip != self.dhcp.seed_ip:
+                log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+                log.info('The desired ip was: %s .' % self.dhcp.seed_ip)
+                assert_equal(cip, self.dhcp.seed_ip)
+
+      def dhcp_client_request_pkt_with_non_offered_ip_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_server_nak_packet()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_server_nak_packet(self, iface = INTF_RX_DEFAULT):
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+          cip, sip, mac, lval = self.dhcp.only_discover()
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+          log.info("Verifying Client 's IP and mac in DHCP Offer packet. Those should not be none, which is expected.")
+          if (cip == None and mac != None):
+                log.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
+                assert_not_equal(cip, None)
+          else:
+                new_cip, new_sip = self.dhcp.only_request('20.20.20.31', mac)
+                if new_cip == None:
+                        log.info("Got DHCP server NAK.")
+                        assert_equal(new_cip, None)  #Negative Test Case
+
+      def dhcp_client_requested_out_pool_ip_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_client_desired_address_out_of_pool()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_client_desired_address_out_of_pool(self, iface = INTF_RX_DEFAULT):
+          '''DHCP Client asking for desired IP address from out of pool.'''
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.35', iface = iface)
+          cip, sip, mac, lval = self.dhcp.only_discover(desired = True)
+          log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+          if cip == self.dhcp.seed_ip:
+                log.info('Got dhcp client IP %s from server %s for mac %s as desired .' %
+                  (cip, sip, mac) )
+                assert_equal(cip, self.dhcp.seed_ip) #Negative Test Case
+
+          elif cip != self.dhcp.seed_ip:
+                log.info('Got dhcp client IP %s from server %s for mac %s .' %
+                  (cip, sip, mac) )
+                log.info('The desired ip was: %s .' % self.dhcp.seed_ip)
+                assert_not_equal(cip, self.dhcp.seed_ip)
+
+          elif cip == None:
+                log.info('Got DHCP NAK')
+
+      def dhcp_client_specific_lease_scenario(self, subscriber):
+          if subscriber.has_service('DHCP'):
+                time.sleep(2)
+                log.info('Running subscriber %s DHCP rediscover scenario test' %subscriber.name)
+                tl = self.subscriber_dhcp_specific_lease_packet()
+                self.test_status = True
+                return self.test_status
+          else:
+              subscriber.src_list = ['10.10.10.{}'.format(subscriber.rx_port)]
+              self.test_status = True
+              return self.test_status
+
+      def subscriber_dhcp_specific_lease_packet(self, iface = INTF_RX_DEFAULT):
+          ''' Client sends DHCP Discover packet for particular lease time.'''
+          config = {'startip':'20.20.20.30', 'endip':'20.20.20.69',
+                   'ip':'20.20.20.2', 'mac': "ca:fe:ca:fe:ca:fe",
+                   'subnet': '255.255.255.0', 'broadcast':'20.20.20.255', 'router':'20.20.20.1'}
+          self.onos_dhcp_table_load(config)
+          self.dhcp = DHCPTest(seed_ip = '20.20.20.45', iface = iface)
+          log.info('Sending DHCP discover with lease time of 700')
+          cip, sip, mac, lval = self.dhcp.only_discover(lease_time = True)
+
+          log.info("Verifying Client 's IP and mac in DHCP Offer packet.")
+          if (cip == None and mac != None):
+                log.info("Verified that Client 's IP and mac in DHCP Offer packet are none, which is not expected behavior.")
+                assert_not_equal(cip, None)
+          elif lval != 700:
+                log.info('Getting dhcp client IP %s from server %s for mac %s with lease time %s. That is not 700.' %
+                         (cip, sip, mac, lval) )
+                assert_not_equal(lval, 700)
+
+      def test_cord_subscriber_join_recv(self):
           """Test subscriber join and receive for channel surfing"""
           self.num_subscribers = 5
           self.num_channels = 1
@@ -524,7 +1123,7 @@
                                                                                               self.num_channels))
           assert_equal(test_status, True)
 
-      def test_subscriber_join_jump(self):
+      def test_cord_subscriber_join_jump(self):
           """Test subscriber join jump for channel surfing"""
           self.num_subscribers = 5
           self.num_channels = 10
@@ -536,7 +1135,7 @@
                                                                                         self.num_channels))
           assert_equal(test_status, True)
 
-      def test_subscriber_join_next(self):
+      def test_cord_subscriber_join_next(self):
           """Test subscriber join next for channel surfing"""
           self.num_subscribers = 5
           self.num_channels = 10
@@ -547,3 +1146,1317 @@
                                                     port_list = self.generate_port_list(self.num_subscribers,
                                                                                         self.num_channels))
           assert_equal(test_status, True)
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      def test_cord_subscriber_authentication_with_invalid_certificate_and_channel_surfing(self):
+          ### """Test subscriber to auth with invalidCertification and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_invalid_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_invalid_cert, self.dhcp_verify,
+                                                                   self.igmp_verify, self.traffic_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),                                                                                  negative_subscriber_auth = 'all')
+              assert_equal(test_status, False)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_invalid_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      def test_cord_subscriber_authentication_with_no_certificate_and_channel_surfing(self):
+          ### """Test subscriber to auth with No Certification and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_no_cert, self.dhcp_verify,
+                                                               self.igmp_verify, self.traffic_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                        negative_subscriber_auth = 'all')
+              assert_equal(test_status, False)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+      def test_cord_subscriber_authentication_with_self_signed_certificate_and_channel_surfing(self):
+          ### """Test subscriber to auth with Self Signed Certification and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                           num_channels = num_channels,
+                                           cbs = (self.tls_self_signed_cert, self.dhcp_verify,
+                                                          self.igmp_verify, self.traffic_verify),
+                                           port_list = self.generate_port_list(num_subscribers, num_channels),
+                                           negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @deferred(SUBSCRIBER_TIMEOUT)
+      def test_2_cord_subscribers_authentication_with_valid_and_invalid_certificates_and_channel_surfing(self):
+          ### """Test 2 subscribers to auth, one of the subscriber with invalidCertification and join channel"""
+          num_subscribers = 2
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_invalid_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                               num_channels = num_channels,
+                               cbs = (self.tls_invalid_cert, self.dhcp_verify,self.igmp_verify, self.traffic_verify),
+                               port_list = self.generate_port_list(num_subscribers, num_channels),                                                                                  negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_invalid_cert, df)
+          return df
+
+      @deferred(SUBSCRIBER_TIMEOUT)
+      def test_2_cord_subscribers_authentication_with_valid_and_no_certificates_and_channel_surfing(self):
+          ### """Test 2 subscribers to auth, one of the subscriber with No Certification and join channel"""
+          num_subscribers = 2
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_no_cert, self.dhcp_verify,
+                                                                self.igmp_verify, self.traffic_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                        negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      @deferred(SUBSCRIBER_TIMEOUT)
+      def test_2_cord_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_and_channel_surfing(self):
+          ### """Test 2 subscribers to auth, one of the subscriber with Non CA authorized Certificate and join channel"""
+          num_subscribers = 2
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                 num_channels = num_channels,
+                                                 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify,
+                                                                     self.igmp_verify, self.traffic_verify),
+                                                 port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                 negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      def test_cord_subscriber_authentication_with_dhcp_discover_and_channel_surfing(self):
+          ### """Test subscriber auth success, DHCP re-discover with DHCP server and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                   num_channels = num_channels,
+                                                   cbs = (self.tls_verify, self.dhcp_discover_scenario,
+                                                                   self.igmp_verify, self.traffic_verify),
+                                                   port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_dhcp_client_reboot_and_channel_surfing(self):
+          ### """Test subscriber auth success, DHCP client got re-booted and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                num_channels = num_channels,
+                                                cbs = (self.tls_verify, self.dhcp_client_reboot_scenario,
+                                                                     self.igmp_verify, self.traffic_verify),
+                                                port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_dhcp_server_reboot_and_channel_surfing(self):
+          ### """Test subscriber auth , DHCP server re-boot during DHCP process and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                              num_channels = num_channels,
+                                              cbs = (self.tls_verify, self.dhcp_server_reboot_scenario,
+                                                                   self.igmp_verify, self.traffic_verify),
+                                              port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_dhcp_client_rebind_and_channel_surfing(self):
+          ### """Test subscriber auth , DHCP client rebind IP and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                num_channels = num_channels,
+                                                cbs = (self.tls_verify, self.dhcp_client_rebind_scenario,
+                                                                     self.igmp_verify, self.traffic_verify),
+                                                port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+
+      def test_cord_subscriber_authentication_with_dhcp_starvation_and_channel_surfing(self):
+          ### """Test subscriber auth , DHCP starvation and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                num_channels = num_channels,
+                                                cbs = (self.tls_verify, self.dhcp_starvation_scenario,
+                                                                  self.igmp_verify, self.traffic_verify),
+                                                port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_multiple_dhcp_discover_for_same_subscriber_and_channel_surfing(self):
+          ### """Test subscriber auth , sending same DHCP client discover multiple times and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                   num_channels = num_channels,
+                                   cbs = (self.tls_verify, self.dhcp_same_client_multi_discovers_scenario,
+                                                                     self.igmp_verify, self.traffic_verify),
+                                   port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_multiple_dhcp_request_for_same_subscriber_and_channel_surfing(self):
+          ### """Test subscriber auth , same DHCP client multiple requerts times and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                     num_channels = num_channels,
+                                     cbs = (self.tls_verify, self.dhcp_same_client_multi_request_scenario,
+                                                                     self.igmp_verify, self.traffic_verify),
+                                     port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_dhcp_client_requested_ip_and_channel_surfing(self):
+          ### """Test subscriber auth with DHCP client requesting ip and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                     num_channels = num_channels,
+                                     cbs = (self.tls_verify, self.dhcp_client_desired_ip_scenario,
+                                                              self.igmp_verify, self.traffic_verify),
+                                     port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_dhcp_non_offered_ip_and_channel_surfing(self):
+          ### """Test subscriber auth with DHCP client request for non-offered ip and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                        num_channels = num_channels,
+                        cbs = (self.tls_verify, self.dhcp_client_request_pkt_with_non_offered_ip_scenario,
+                                                                   self.igmp_verify, self.traffic_verify),
+                        port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_authentication_with_dhcp_request_out_of_pool_ip_by_client_and_channel_surfing(self):
+          ### """Test subscriber auth with DHCP client requesting out of pool ip and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                               num_channels = num_channels,
+                               cbs = (self.tls_verify, self.dhcp_client_requested_out_pool_ip_scenario,
+                                                              self.igmp_verify, self.traffic_verify),
+                               port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+
+      def test_cord_subscriber_authentication_with_dhcp_specified_lease_time_functionality_and_channel_surfing(self):
+          ### """Test subscriber auth with DHCP client specifying lease time and join channel"""
+          num_subscribers = 1
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                               num_channels = num_channels,
+                               cbs = (self.tls_verify, self.dhcp_client_specific_lease_scenario,
+                                            self.igmp_verify, self.traffic_verify),
+                               port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_1k_subscribers_authentication_with_valid_and_invalid_certificates_and_channel_surfing(self):
+          ### """Test 1k subscribers to auth, half of the subscribers with invalidCertification and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_invalid_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_invalid_cert, self.dhcp_verify,
+                                                                   self.igmp_verify, self.traffic_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),                                                                                  negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_invalid_cert, df)
+          return df
+
+      @nottest
+      @deferred(SUBSCRIBER_TIMEOUT)
+      def test_1k_subscribers_authentication_with_valid_and_no_certificates_and_channel_surfing(self):
+          ### """Test 1k subscribers to auth, half of the subscribers with No Certification and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_no_cert, self.dhcp_verify, self.igmp_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                        negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_1k_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_and_channel_surfing(self):
+          ### """Test 1k subscribers to auth, half of the subscribers with Non CA authorized Certificate and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                 num_channels = num_channels,
+                                                 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify, self.igmp_verify),
+                                                 port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                 negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_5k_subscribers_authentication_with_valid_and_invalid_certificates_and_channel_surfing(self):
+          ### """Test 5k subscribers to auth, half of the subscribers with invalidCertification and join channel"""
+          num_subscribers = 5000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_invalid_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_invalid_cert, self.dhcp_verify, self.igmp_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_invalid_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_5k_subscribers_authentication_with_valid_and_no_certificates_and_channel_surfing(self):
+          ### """Test 5k subscribers to auth, half of the subscribers with No Certification and join channel"""
+          num_subscribers = 5000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_no_cert, self.dhcp_verify, self.igmp_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                        negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_5k_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_and_channel_surfing(self):
+          ### """Test 5k subscribers to auth, half of the subscribers with Non CA authorized Certificate and join channel"""
+          num_subscribers = 5000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                 num_channels = num_channels,
+                                                 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify, self.igmp_verify),
+                                                 port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                 negative_subscriber_auth = 'half')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_10k_subscribers_authentication_with_valid_and_invalid_certificates_and_channel_surfing(self):
+          ### """Test 10k subscribers to auth, half of the subscribers with invalidCertification and join channel"""
+          num_subscribers = 10000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_invalid_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_invalid_cert, self.dhcp_verify, self.igmp_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'onethird')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_invalid_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_10k_subscribers_authentication_with_valid_and_no_certificates_and_channel_surfing(self):
+          ### """Test 10k subscribers to auth, half of the subscribers with No Certification and join channel"""
+          num_subscribers = 10000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                        num_channels = num_channels,
+                                                        cbs = (self.tls_no_cert, self.dhcp_verify, self.igmp_verify),
+                                                        port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                        negative_subscriber_auth = 'onethird')
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      #@deferred(SUBSCRIBER_TIMEOUT)
+      @nottest
+      def test_10k_subscribers_authentication_with_valid_and_non_ca_authorized_certificates_and_channel_surfing(self):
+          ### """Test 10k subscribers to auth, half of the subscribers with Non CA authorized Certificate and join channel"""
+          num_subscribers = 10000
+          num_channels = 1
+          df = defer.Deferred()
+          def sub_auth_no_cert(df):
+              test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                 num_channels = num_channels,
+                                                 cbs = (self.tls_non_ca_authrized_cert, self.dhcp_verify, self.igmp_verify),
+                                                 port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                 negative_subscriber_auth = 'onethird')
+              assert_equal(test_status, False)
+              assert_equal(test_status, True)
+              df.callback(0)
+          reactor.callLater(0, sub_auth_no_cert, df)
+          return df
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_discovers_and_channel_surfing(self):
+          ### """Test 1k subscribers auth success, DHCP re-discover with DHCP server and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                   num_channels = num_channels,
+                                                   cbs = (self.tls_verify, self.dhcp_discover_scenario, self.igmp_verify),
+                                                   port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_client_reboot_and_channel_surfing(self):
+          ### """Test 1k subscribers auth success, DHCP client got re-booted and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                num_channels = num_channels,
+                                                cbs = (self.tls_verify, self.dhcp_client_reboot_scenario, self.igmp_verify),
+                                                port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_server_reboot_and_channel_surfing(self):
+          ### """Test 1k subscribers auth , DHCP server re-boot during DHCP process and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                              num_channels = num_channels,
+                                              cbs = (self.tls_verify, self.dhcp_server_reboot_scenario, self.igmp_verify),
+                                              port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_client_rebind_and_channel_surfing(self):
+          ### """Test 1k subscribers auth , DHCP client rebind IP and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                num_channels = num_channels,
+                                                cbs = (self.tls_verify, self.dhcp_client_rebind_scenario, self.igmp_verify),
+                                                port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_starvation_and_channel_surfing(self):
+          ### """Test 1k subscribers auth , DHCP starvation and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                num_channels = num_channels,
+                                                cbs = (self.tls_verify, self.dhcp_starvation_scenario, self.igmp_verify),
+                                                port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_client_requested_ip_and_channel_surfing(self):
+          ### """Test 1k subscribers auth with DHCP client requesting ip and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                     num_channels = num_channels,
+                                     cbs = (self.tls_verify, self.dhcp_client_desired_ip_scenario, self.igmp_verify),
+                                     port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_non_offered_ip_and_channel_surfing(self):
+          ### """Test subscribers auth with DHCP client request for non-offered ip and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                        num_channels = num_channels,
+                        cbs = (self.tls_verify, self.dhcp_client_request_pkt_with_non_offered_ip_scenario, self.igmp_verify),
+                        port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_4_cord_subscribers_join_recv_5channel(self):
+          ###"""Test 4 subscribers join and receive for 5 channels surfing"""
+          num_subscribers = 4
+          num_channels = 5
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_4_cord_subscribers_join_jump_5channel(self):
+          ###"""Test 4 subscribers jump and receive for 5 channels surfing"""
+          num_subscribers = 4
+          num_channels = 5
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_4_cord_subscribers_join_next_5channel(self):
+          ###"""Test 4 subscribers join next for 5 channels"""
+          num_subscribers = 4
+          num_channels = 5
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_10_cord_subscribers_join_recv_5channel(self):
+          ###"""Test 10 subscribers join and receive for 5 channels surfing"""
+          num_subscribers = 10
+          num_channels = 5
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_10_cord_subscribers_join_jump_5channel(self):
+          ###"""Test 10 subscribers jump and receive for 5 channels surfing"""
+          num_subscribers = 10
+          num_channels = 5
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+
+      def test_10_cord_subscribers_join_next_5channel(self):
+          ###"""Test 10 subscribers join next for 5 channels"""
+          num_subscribers = 10
+          num_channels = 5
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+
+
+      def test_cord_subscriber_join_recv_100channels(self):
+          num_subscribers = 1
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify,
+                                                              self.igmp_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_recv_400channels(self):
+          num_subscribers = 1
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify,
+                                                              self.igmp_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_recv_800channels(self):
+          num_subscribers = 1
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify,
+                                                             self.igmp_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_recv_1200channels(self):
+          num_subscribers = 1
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify,
+                                                                self.igmp_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_recv_1500channels(self):
+          num_subscribers = 1
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify,
+                                                                  self.igmp_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_jump_100channels(self):
+          num_subscribers = 1
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify,
+                                                            self.igmp_jump_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+      def test_cord_subscriber_join_jump_400channels(self):
+          num_subscribers = 1
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify,
+                                                              self.igmp_jump_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_jump_800channels(self):
+          num_subscribers = 1
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify,
+                                                          self.igmp_jump_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+      def test_cord_subscriber_join_jump_1200channel(sself):
+          num_subscribers = 1
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify,
+                                                           self.igmp_jump_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+      def test_cord_subscriber_join_jump_1500channels(self):
+          num_subscribers = 1
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify,
+                                                           self.igmp_jump_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_next_100channels(self):
+          num_subscribers = 1
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify,
+                                                            self.igmp_next_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_next_400channels(self):
+          num_subscribers = 1
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify,
+                                                           self.igmp_next_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_next_800channels(self):
+          num_subscribers = 1
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify,
+                                                            self.igmp_next_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+
+      def test_cord_subscriber_join_next_1200channels(self):
+          num_subscribers = 1
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify,
+                                                           self.igmp_next_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      def test_cord_subscriber_join_next_1500channels(self):
+          num_subscribers = 1
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify,
+                                                           self.igmp_next_verify, self.traffic_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_authentication_with_dhcp_request_out_of_pool_ip_by_client_and_channel_surfing(self):
+          ### """Test 1k subscribers auth with DHCP client requesting out of pool ip and join channel"""
+          num_subscribers = 1000
+          num_channels = 1
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                               num_channels = num_channels,
+                               cbs = (self.tls_verify, self.dhcp_client_requested_out_pool_ip_scenario, self.igmp_verify),
+                               port_list = self.generate_port_list(num_subscribers, num_channels),                                                          negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_recv_100channel(self):
+          ###"""Test 1k subscribers join and receive for 100 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_jump_100channel(self):
+          ###"""Test 1k subscribers jump and receive for 100 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_next_100channel(self):
+          ###"""Test 1k subscribers join next for 100 channels"""
+          num_subscribers = 1000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_recv_400channel(self):
+          ###"""Test 1k subscribers join and receive for 400 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_jump_400channel(self):
+          ###"""Test 1k subscribers jump and receive for 400 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_next_400channel(self):
+          ###"""Test 1k subscribers join next for 400 channels"""
+          num_subscribers = 1000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_recv_800channel(self):
+          ###"""Test 1k subscribers join and receive for 800 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_jump_800channel(self):
+          ###"""Test 1k subscribers jump and receive for 800 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_next_800channel(self):
+          ###"""Test 1k subscribers join next for 800 channels"""
+          num_subscribers = 1000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_recv_1200channel(self):
+          ###"""Test 1k subscribers join and receive for 1200 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_jump_1200channel(self):
+          ###"""Test 1k subscribers jump and receive for 1200 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_next_1200channel(self):
+          ###"""Test 1k subscribers join next for 1200 channels"""
+          num_subscribers = 1000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_recv_1500channel(self):
+          ###"""Test 1k subscribers join and receive for 1500 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_jump_1500channel(self):
+          ###"""Test 1k subscribers jump and receive for 1500 channels surfing"""
+          num_subscribers = 1000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_1k_cord_subscribers_join_next_1500channel(self):
+          ###"""Test 1k subscribers join next for 1500 channels"""
+          num_subscribers = 1000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_recv_100channel(self):
+          ###"""Test 5k subscribers join and receive for 100 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_jump_100channel(self):
+          ###"""Test 5k subscribers jump and receive for 100 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_next_100channel(self):
+          ###"""Test 5k subscribers join next for 100 channels"""
+          num_subscribers = 5000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_recv_400channel(self):
+          ###"""Test 5k subscribers join and receive for 400 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_jump_400channel(self):
+          ###"""Test 5k subscribers jump and receive for 400 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_next_400channel(self):
+          ###"""Test 5k subscribers join next for 400 channels"""
+          num_subscribers = 5000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_recv_800channel(self):
+          ###"""Test 5k subscribers join and receive for 800 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_jump_800channel(self):
+          ###"""Test 5k subscribers jump and receive for 800 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_next_800channel(self):
+          ###"""Test 5k subscribers join next for 800 channels"""
+          num_subscribers = 5000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_recv_1200channel(self):
+          ###"""Test 5k subscribers join and receive for 1200 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_jump_1200channel(self):
+          ###"""Test 5k subscribers jump and receive for 1200 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_next_1200channel(self):
+          ###"""Test 5k subscribers join next for 1200 channels"""
+          num_subscribers = 5000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_recv_1500channel(self):
+          ###"""Test 5k subscribers join and receive for 1500 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_jump_1500channel(self):
+          ###"""Test 5k subscribers jump and receive for 1500 channels surfing"""
+          num_subscribers = 5000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_5k_cord_subscribers_join_next_1500channel(self):
+          ###"""Test 5k subscribers join next for 1500 channels"""
+          num_subscribers = 5000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_recv_100channel(self):
+          ###"""Test 10k subscribers join and receive for 100 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_jump_100channel(self):
+          ###"""Test 10k subscribers jump and receive for 100 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_next_100channel(self):
+          ###"""Test 10k subscribers join next for 100 channels"""
+          num_subscribers = 10000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_100k_cord_subscribers_join_recv_100channel(self):
+          ###"""Test 100k subscribers join and receive for 100 channels surfing"""
+          num_subscribers = 100000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_100k_cord_subscribers_join_jump_100channel(self):
+          ###"""Test 100k subscribers jump and receive for 100 channels surfing"""
+          num_subscribers = 100000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_100k_cord_subscribers_join_next_100channel(self):
+          ###"""Test 100k subscribers join next for 100 channels"""
+          num_subscribers = 100000
+          num_channels = 100
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_recv_400channel(self):
+          ###"""Test 10k subscribers join and receive for 400 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_jump_400channel(self):
+          ###"""Test 10k subscribers jump and receive for 400 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_next_400channel(self):
+          ###"""Test 10k subscribers join next for 400 channels"""
+          num_subscribers = 10000
+          num_channels = 400
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_recv_800channel(self):
+          ###"""Test 10k subscribers join and receive for 800 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_jump_800channel(self):
+          ###"""Test 10k subscribers jump and receive for 800 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_next_800channel(self):
+          ###"""Test 10k subscribers join next for 800 channels"""
+          num_subscribers = 10000
+          num_channels = 800
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_recv_1200channel(self):
+          ###"""Test 10k subscribers join and receive for 1200 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_jump_1200channel(self):
+          ###"""Test 10k subscribers jump and receive for 1200 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_next_1200channel(self):
+          ###"""Test 10k subscribers join next for 1200 channels"""
+          num_subscribers = 10000
+          num_channels = 1200
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_recv_1500channel(self):
+          ###"""Test 10k subscribers join and receive for 1500 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_jump_1500channel(self):
+          ###"""Test 10k subscribers jump and receive for 1500 channels surfing"""
+          num_subscribers = 10000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_10k_cord_subscribers_join_next_1500channel(self):
+          ###"""Test 10k subscribers join next for 1500 channels"""
+          num_subscribers = 10000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_100k_cord_subscribers_join_recv_1500channel(self):
+          ###"""Test 100k subscribers join and receive for 1500 channels surfing"""
+          num_subscribers = 100000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_verify, self.igmp_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_100k_cord_subscribers_join_jump_1500channel(self):
+          ###"""Test 10k subscribers jump and receive for 1500 channels surfing"""
+          num_subscribers = 100000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_jump_verify, self.igmp_jump_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)
+
+      @nottest
+      def test_100k_cord_subscribers_join_next_1500channel(self):
+          ###"""Test 10k subscribers join next for 1500 channels"""
+          num_subscribers = 100000
+          num_channels = 1500
+          test_status = self.subscriber_join_verify(num_subscribers = num_subscribers,
+                                                    num_channels = num_channels,
+                                                    cbs = (self.tls_verify, self.dhcp_next_verify, self.igmp_next_verify),
+                                                    port_list = self.generate_port_list(num_subscribers, num_channels),
+                                                    negative_subscriber_auth = 'all')
+          assert_equal(test_status, True)