def main():
    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent()

    scan_filter.update({"UUIDs": [runTest.DUT_UUID]})
    bleAdapter.setDiscoveryFilter(scan_filter)
    bleAdapter.startDiscovery(discoveryEventCb)
    firstStartScan = time.time()
    mainloop.run()
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.advertisement)
    bleAdapter.stopDiscovery()

    #Simple Connection test
    testDevice = runTest.getTestDevice()
    isTestSuccessFull = bleAdapter.connect(testDevice)
    firstKPI = time.time() - firstStartScan
    runTest.submitTestResult(isTestSuccessFull, runTest.simpleConnection)
    time.sleep(2)  #wait for connection parameters update

    # Second time
    isTestSuccessFull &= bleAdapter.disconnect()

    # bleAdapter.setDiscoveryFilter(scan_filter)
    bleAdapter.startDiscovery(
        discoveryStartedCb)  #wait for DUT to start advertising
    secondStartScan = time.time()
    mainloop.run()
    bleAdapter.stopDiscovery()
    isConnectSuccessFull = bleAdapter.connect(testDevice)
    secondKPI = time.time() - secondStartScan
    isTestSuccessFull &= isConnectSuccessFull

    runTest.submitTestResult(isTestSuccessFull,
                             runTest.discoverPrimaryServices)
    bleAdapter.gatt.updateLocalAttributeTable()
    print firstKPI
    print secondKPI
    if secondKPI > firstKPI * 10:
        isTestSuccessFull &= false

    isTestSuccessFull &= runTest.writeResultWithoutResponse(
        chr(isTestSuccessFull + 48))

    runTest.submitTestResult(isTestSuccessFull, runTest.writeWithoutResponse)
    isTestSuccessFull &= bleAdapter.disconnect()

    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)
    time.sleep(2)  #wait for connection parameters update

    runTest.printTestsSummary()
    agent = teardown_test(agent)
Exemplo n.º 2
0
def main():
    agent = None
    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent(agent=agent)

    scan_filter.update({"UUIDs": [runTest.DUT_UUID]})
    bleAdapter.setDiscoveryFilter(scan_filter)

    #KPI test
    isTestSuccessFull = True
    firstPeriodSum = 0
    secondPeriodSum = 0
    reconnectTime = 3

    successTime = reconnectTime

    for i in range(reconnectTime):
        if i == 0:
            bleAdapter.startDiscovery(discoveryEventCb)
        else:
            bleAdapter.startDiscovery(
                discoveryStartedCb)  #wait for DUT to start advertising
        tStartScan = time.time()
        mainloop.run()
        firstPeriod = time.time() - tStartScan
        bleAdapter.stopDiscovery()

        testDevice = runTest.getTestDevice()
        isConnectSuccessFull = bleAdapter.connect(testDevice)
        secondPeriod = time.time() - tStartScan
        # runTest.stopAdvertisement(scan_filter)

        isTestSuccessFull &= isConnectSuccessFull
        firstPeriodSum += firstPeriod
        if isConnectSuccessFull:
            secondPeriodSum += secondPeriod
        else:
            successTime -= 1
        isTestSuccessFull &= bleAdapter.disconnect()

    if reconnectTime:
        firstPeriodAvg = firstPeriodSum / reconnectTime
        print "start to receive:" + str(firstPeriodAvg)
    if successTime:
        secondPeriodAvg = secondPeriodSum / successTime
        print "start to connect:" + str(secondPeriodAvg)
    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)

    time.sleep(2)
    runTest.printTestsSummary()
    agent = teardown_test(agent)
Exemplo n.º 3
0
def main():
    agent = None
    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent(agent=agent)

    scan_filter.update({ "UUIDs": [runTest.DUT_UUID]})
    bleAdapter.setDiscoveryFilter(scan_filter)

    #KPI test
    # Evaluate KPI from scanning start to advertisement received.
    # Evaluate KPI from scanning start to connection created.
    isTestSuccessFull = True
    startToReceivedSum = 0
    startToConnectedSum = 0
    numberOfReconnect = 3
    numberOfSuccess = 0

    for i in range(numberOfReconnect):
        if i == 0:
            bleAdapter.startDiscovery(discoveryEventCb)
        else:
            bleAdapter.startDiscovery(discoveryStartedCb)   #wait for DUT to start advertising
        tStartScan = time.time()
        mainloop.run()
        startToReceived = time.time() - tStartScan  
        bleAdapter.stopDiscovery()
        
        testDevice = runTest.getTestDevice()
        isConnectSuccessFull = bleAdapter.connect(testDevice)
        startToConnected = time.time() - tStartScan
        
        isTestSuccessFull &= isConnectSuccessFull
        startToReceivedSum += startToReceived
        if isConnectSuccessFull:
            startToConnectedSum += startToConnected
            numberOfSuccess += 1
        isTestSuccessFull &= bleAdapter.disconnect()

    if numberOfReconnect:
        startToReceivedAvg = startToReceivedSum / numberOfReconnect
        print "start scanning to received:" + str(startToReceivedAvg)
    if numberOfSuccess:
        startToConnectedAvg = startToConnectedSum / numberOfSuccess
        print "start scanning to connected:" + str(startToConnectedAvg)
    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)

    time.sleep(2)
    runTest.printTestsSummary()
    agent = teardown_test(agent)
Exemplo n.º 4
0
def main():
    agent = None
    reconnectTime = 3

    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent(agent=agent)

    scan_filter.update({"UUIDs": [runTest.DUT_UUID]})
    bleAdapter.setDiscoveryFilter(scan_filter)

    #Discovery test
    bleAdapter.startDiscovery(discoveryEventCb)
    mainloop.run()
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.advertisement)
    bleAdapter.stopDiscovery()

    #Simple Connection test
    testDevice = runTest.getTestDevice()
    isTestSuccessFull = bleAdapter.connect(testDevice)
    runTest.submitTestResult(isTestSuccessFull, runTest.simpleConnection)
    time.sleep(2)  #wait for connection parameters update

    # Reconnect test
    isTestSuccessFull = True

    for j in range(reconnectTime):
        isTestSuccessFull &= bleAdapter.disconnect()

        # bleAdapter.setDiscoveryFilter(scan_filter)
        bleAdapter.startDiscovery(
            discoveryStartedCb)  #wait for DUT to start advertising
        mainloop.run()
        bleAdapter.stopDiscovery()
        isConnectSuccessFull = bleAdapter.connect(testDevice)
        # runTest.stopAdvertisement(scan_filter)
        isTestSuccessFull &= isConnectSuccessFull

    if reconnectTime:
        runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)
        time.sleep(2)  #wait for connection parameters update

    runTest.printTestsSummary()
    agent = teardown_test(agent)
Exemplo n.º 5
0
def main():
    agent = None
    numberOfReconnect = 1
    numberOfInit = 1
    numberOfEnable = 1
    isTestSuccessFull = True

    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent(agent=agent)

    scan_filter.update({"UUIDs": [runTest.DUT_UUID]})

    for i in range(numberOfInit * numberOfEnable):
        bleAdapter.setDiscoveryFilter(scan_filter)
        for j in range(numberOfReconnect):
            if i == 0 and j == 0:
                bleAdapter.startDiscovery(discoveryEventCb)
            else:
                bleAdapter.startDiscovery(discoveryStartedCb)
            mainloop.run()
            bleAdapter.stopDiscovery()

            testDevice = runTest.getTestDevice()
            isConnectSuccessFull = bleAdapter.connect(testDevice)

            isTestSuccessFull &= isConnectSuccessFull
            runTest.stopAdvertisement(scan_filter)
            isTestSuccessFull &= bleAdapter.disconnect()

        if numberOfReconnect:
            runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)
        # runTest.setTestDevice([]);
        time.sleep(2)

    runTest.printTestsSummary()
    agent = teardown_test(agent)
Exemplo n.º 6
0
def main():
    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent()

    # default DUT_name: nimble(without set_property)
    # TODO: check DUT with MAC address instead of name.

    scan_filter.update({"UUIDs": [runTest.DUT_UUID_128]})

    # default DUT_name: nimble(without set_property)
    # TODO: check DUT with MAC address instead of name.
    DUT_ORIGINAL_NAME = runTest.DUT_NAME
    runTest.DUT_NAME = "nimb"
    bleAdapter.setDiscoveryFilter(scan_filter)

    # Advertisement interval consistent after reset test
    # The first time uses different callback to get/check test device information. Use the second time and third time KPI to compare.
    # First time connection
    isTestSuccessFull = True
    bleAdapter.startDiscovery(runTest.discoveryEventCb)
    # firstStartScan = time.time()
    runTest.mainloop.run()
    # firstKPI = time.time() - firstStartScan
    runTest.submitTestResult(isTestSuccessFull, runTest.advertisement)
    bleAdapter.stopDiscovery()

    testDevice = runTest.getTestDevice()
    isTestSuccessFull = bleAdapter.connect(testDevice)
    runTest.submitTestResult(isTestSuccessFull, runTest.simpleConnection)
    time.sleep(2)  #wait for connection parameters update

    isTestSuccessFull &= bleAdapter.disconnect()

    # Second time connection
    bleAdapter.startDiscovery(
        runTest.discoveryStartedCb)  #wait for DUT to start advertising
    secondStartScan = time.time()
    runTest.mainloop.run()
    secondKPI = time.time() - secondStartScan
    bleAdapter.stopDiscovery()
    isConnectSuccessFull = bleAdapter.connect(testDevice)
    isTestSuccessFull &= isConnectSuccessFull
    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)
    time.sleep(2)  #wait for connection parameters update
    # Second time disconnect
    isTestSuccessFull &= bleAdapter.disconnect()

    #Third time connection
    bleAdapter.startDiscovery(
        runTest.discoveryStartedCb)  #wait for DUT to start advertising
    thirdStartScan = time.time()
    runTest.mainloop.run()
    thirdKPI = time.time() - thirdStartScan
    bleAdapter.stopDiscovery()
    isConnectSuccessFull = bleAdapter.connect(testDevice)
    isTestSuccessFull &= isConnectSuccessFull
    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)

    if thirdKPI > secondKPI * 10:
        isTestSuccessFull &= false
    # write result back to server
    isTestSuccessFull = runTest.discoverPrimaryServices()
    bleAdapter.gatt.updateLocalAttributeTable()

    isTestSuccessFull &= runTest.writeResultWithoutResponse(
        chr(isTestSuccessFull + 48))
    runTest.submitTestResult(isTestSuccessFull, runTest.writeWithoutResponse)

    # Data size > MTU - 3 send notification test
    bleAdapter.setNotificationCallBack(runTest.notificationMTUCb)
    bleAdapter.subscribeForNotification(
        runTest.DUT_NOTIFY_CHAR_UUID)  #subscribe for next test
    isTestSuccessFull = True
    runTest.mainloop.run()
    isTestSuccessFull = runTest.isNotificationDeclinedSuccessFull
    runTest.submitTestResult(isTestSuccessFull, runTest.notification)

    isTestSuccessFull = bleAdapter.subscribeForNotification(
        runTest.DUT_NOTIFY_CHAR_UUID, subscribe=False)  #unsubscribe
    runTest.submitTestResult(isTestSuccessFull, runTest.removeNotification)

    isTestSuccessFull &= bleAdapter.disconnect()
    testutils.removeBondedDevices()

    runTest.DUT_NAME = DUT_ORIGINAL_NAME

    isTestSuccessFull = runTest.Advertise_With_16bit_ServiceUUID(
        scan_filter=scan_filter, bleAdapter=bleAdapter)
    runTest.submitTestResult(isTestSuccessFull,
                             runTest.Advertise_With_16bit_ServiceUUID)

    scan_filter.update({"UUIDs": [runTest.DUT_UUID_128]})
    # default DUT_name: nimble(without set_property)
    bleAdapter.setDiscoveryFilter(scan_filter)

    # First time connection
    isTestSuccessFull = True
    bleAdapter.startDiscovery(runTest.discoveryEventCb)
    runTest.mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.advertisement)
    bleAdapter.stopDiscovery()

    testDevice = runTest.getTestDevice()
    isTestSuccessFull = bleAdapter.connect(testDevice)
    runTest.submitTestResult(isTestSuccessFull, runTest.simpleConnection)

    isTestSuccessFull = runTest.discoverPrimaryServices()
    runTest.submitTestResult(isTestSuccessFull,
                             runTest.discoverPrimaryServices)

    bleAdapter.gatt.updateLocalAttributeTable()

    # Check device not present. After discovery of services, advertisement should have stopped.
    runTest.stopAdvertisement(scan_filter)

    # Check write and read
    bleAdapter.writeCharacteristic(runTest.DUT_OPEN_CHAR_UUID,
                                   runTest.DUT_OPEN_DESCR_UUID)
    bleAdapter.readCharacteristic(runTest.DUT_OPEN_CHAR_UUID)

    # Enable and receive notification and indication then disable.
    bleAdapter.subscribeForNotification(runTest.DUT_NOTIFY_CHAR_UUID)
    bleAdapter.subscribeForNotification(
        runTest.DUT_INDICATE_CHAR_UUID)  #subscribe for next test

    time.sleep(2)  #wait for connection parameters update

    # Check Notification and Indication
    bleAdapter.setNotificationCallBack(runTest.notificationCb)
    isTestSuccessFull = True
    runTest.mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.notification)

    bleAdapter.setNotificationCallBack(runTest.indicationCb)
    isTestSuccessFull = True
    runTest.mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.indication)

    isTestSuccessFull &= bleAdapter.disconnect()

    # Second time connection
    bleAdapter.startDiscovery(
        runTest.discoveryStartedCb)  #wait for DUT to start advertising
    runTest.mainloop.run()
    bleAdapter.stopDiscovery()
    isConnectSuccessFull = bleAdapter.connect(testDevice)
    isTestSuccessFull &= isConnectSuccessFull
    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)

    bleAdapter.subscribeForNotification(runTest.DUT_NOTIFY_CHAR_UUID)
    bleAdapter.subscribeForNotification(
        runTest.DUT_INDICATE_CHAR_UUID)  #subscribe for next test

    # Check write and read after reconnection
    bleAdapter.writeCharacteristic(runTest.DUT_OPEN_CHAR_UUID,
                                   runTest.DUT_OPEN_DESCR_UUID)
    bleAdapter.readCharacteristic(runTest.DUT_OPEN_CHAR_UUID)

    # Check Notification and Indication after reconnection
    bleAdapter.setNotificationCallBack(runTest.notificationCb)
    isTestSuccessFull = True
    runTest.mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.notification)

    bleAdapter.setNotificationCallBack(runTest.indicationCb)
    isTestSuccessFull = True
    runTest.mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.indication)

    isTestSuccessFull = bleAdapter.subscribeForNotification(
        runTest.DUT_NOTIFY_CHAR_UUID, subscribe=False)  #unsubscribe
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.removeNotification)

    isTestSuccessFull = bleAdapter.subscribeForNotification(
        runTest.DUT_INDICATE_CHAR_UUID, subscribe=False)  #unsubscribe
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.removeIndication)

    isTestSuccessFull &= bleAdapter.disconnect()
    testutils.removeBondedDevices()

    time.sleep(2)  #wait for connection parameters update
    runTest.submitTestResult(isTestSuccessFull, runTest.disconnect)
    runTest.printTestsSummary()
def main():
    agent = None
    STRESS_TIER = 1

    if (STRESS_TIER == 0):
        STRESS_TEST_INIT_REPETITION = 1
        STRESS_TEST_ENABLE_REPETITION = 1
        STRESS_TEST_MODULE_REPETITION = 1
    elif (STRESS_TIER == 1):
        STRESS_TEST_INIT_REPETITION = 1
        STRESS_TEST_ENABLE_REPETITION = 1
        STRESS_TEST_MODULE_REPETITION = 10
    elif (STRESS_TIER == 2):
        STRESS_TEST_INIT_REPETITION = 2
        STRESS_TEST_ENABLE_REPETITION = 10
        STRESS_TEST_MODULE_REPETITION = 100
    elif (STRESS_TIER == 3):
        STRESS_TEST_INIT_REPETITION = 3
        STRESS_TEST_ENABLE_REPETITION = 100
        STRESS_TEST_MODULE_REPETITION = 1000

    isTestSuccessFull = True

    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent(agent=agent)

    scan_filter.update({"UUIDs": [runTest.DUT_UUID_128]})

    for i in range(STRESS_TEST_INIT_REPETITION *
                   STRESS_TEST_ENABLE_REPETITION):
        bleAdapter.setDiscoveryFilter(scan_filter)
        for j in range(STRESS_TEST_MODULE_REPETITION):
            if i == 0 and j == 0:
                bleAdapter.startDiscovery(runTest.discoveryEventCb)
            else:
                bleAdapter.startDiscovery(runTest.discoveryStartedCb)
            runTest.mainloop.run()
            bleAdapter.stopDiscovery()

            testDevice = runTest.getTestDevice()
            isConnectSuccessFull = bleAdapter.connect(testDevice)

            isTestSuccessFull &= isConnectSuccessFull
            runTest.stopAdvertisement(scan_filter)
            isTestSuccessFull &= bleAdapter.disconnect()

        bleAdapter.startDiscovery(runTest.discoveryStartedCb)
        runTest.mainloop.run()
        bleAdapter.stopDiscovery()

        runTest._simple_connect()
        runTest.stopAdvertisement(scan_filter)
        # Discover all primary services
        isTestSuccessFull = runTest.discoverPrimaryServices()
        runTest.submitTestResult(isTestSuccessFull,
                                 runTest.discoverPrimaryServices)
        bleAdapter.gatt.updateLocalAttributeTable()
        isTestSuccessFull &= runTest.checkUUIDs(bleAdapter.gatt)
        # Check attribute table properties
        isTestSuccessFull &= runTest.checkProperties(bleAdapter.gatt)

        # Check read/write, simple connection
        for i in range(STRESS_TEST_MODULE_REPETITION):
            isTestSuccessFull &= runTest.readWriteSimpleConnection()
            runTest.submitTestResult(isTestSuccessFull,
                                     runTest.readWriteSimpleConnection)
            time.sleep(2)

        bleAdapter.subscribeForNotification(
            runTest.DUT_NOTIFY_CHAR_UUID)  # subscribe for next test
        bleAdapter.subscribeForNotification(
            runTest.DUT_INDICATE_CHAR_UUID)  # subscribe for next test

        # Check read/write, simple connection
        for i in range(STRESS_TEST_MODULE_REPETITION):
            # Enable and receive notification and indication then disable.
            bleAdapter.setNotificationCallBack(runTest.notificationCb)
            isTestSuccessFull = True
            runTest.mainloop.run()
            runTest.submitTestResult(isTestSuccessFull, runTest.notification)

            bleAdapter.setNotificationCallBack(runTest.indicationCb)
            isTestSuccessFull = True
            runTest.mainloop.run()
            runTest.submitTestResult(isTestSuccessFull, runTest.indication)
        time.sleep(5)

        isTestSuccessFull = bleAdapter.subscribeForNotification(
            runTest.DUT_NOTIFY_CHAR_UUID, subscribe=False)  # unsubscribe
        isTestSuccessFull = True
        runTest.submitTestResult(isTestSuccessFull, runTest.removeNotification)

        isTestSuccessFull = bleAdapter.subscribeForNotification(
            runTest.DUT_INDICATE_CHAR_UUID, subscribe=False)  # unsubscribe
        isTestSuccessFull = True
        runTest.submitTestResult(isTestSuccessFull, runTest.removeIndication)

        if STRESS_TEST_MODULE_REPETITION:
            runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)

        time.sleep(2)

    runTest.printTestsSummary()
Exemplo n.º 8
0
def main():
    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent()

    scan_filter.update({ "UUIDs": [runTest.DUT_UUID]})

    # default DUT_name: nimble(without set_property)
    # TODO: check DUT with MAC address instead of name.
    runTest.DUT_NAME = "nimb"
    bleAdapter.setDiscoveryFilter(scan_filter)


    # Advertisement interval consistent after reset test
    # TODO: the first time uses different callback to get/check test device information. we can choose to use the second time and third time KPI to compare.
    # First time connection
    isTestSuccessFull = True
    bleAdapter.startDiscovery(discoveryEventCb)
    firstStartScan = time.time()
    mainloop.run()
    firstKPI = time.time() - firstStartScan
    runTest.submitTestResult(isTestSuccessFull, runTest.advertisement)
    bleAdapter.stopDiscovery()

    testDevice = runTest.getTestDevice()
    isTestSuccessFull = bleAdapter.connect(testDevice)
    runTest.submitTestResult(isTestSuccessFull, runTest.simpleConnection)
    time.sleep(2) #wait for connection parameters update

    isTestSuccessFull &= bleAdapter.disconnect()

    # Second time connection
    bleAdapter.startDiscovery(discoveryStartedCb)#wait for DUT to start advertising
    secondStartScan = time.time()
    mainloop.run()
    secondKPI = time.time() - secondStartScan
    bleAdapter.stopDiscovery()
    isConnectSuccessFull = bleAdapter.connect(testDevice)
    isTestSuccessFull &= isConnectSuccessFull
    runTest.submitTestResult(isTestSuccessFull, runTest.reConnection)

    bleAdapter.gatt.updateLocalAttributeTable()
    print firstKPI
    print secondKPI
    if secondKPI > firstKPI * 10:
        isTestSuccessFull &= false

    # write result back to peripheral
    isTestSuccessFull &= runTest.writeResultWithoutResponse(chr(isTestSuccessFull + 48))
    runTest.submitTestResult(isTestSuccessFull, runTest.writeWithoutResponse)


    # Data size > MTU - 3 send notification test
    bleAdapter.setNotificationCallBack(notificationMTUCb)
    bleAdapter.subscribeForNotification(runTest.DUT_NOTIFY_CHAR_UUID) #subscribe for next test
    isTestSuccessFull = True
    mainloop.run()
    isTestSuccessFull = runTest.isNotificationDeclinedSuccessFull
    runTest.submitTestResult(isTestSuccessFull, runTest.notification)

    # unsubscribe
    isTestSuccessFull = bleAdapter.subscribeForNotification(runTest.DUT_NOTIFY_CHAR_UUID, subscribe = False) #unsubscribe
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.removeNotification)


    isTestSuccessFull &= bleAdapter.disconnect()
    time.sleep(2) #wait for connection parameters update
    runTest.printTestsSummary()
    agent = teardown_test(agent)
Exemplo n.º 9
0
def main():
    scan_filter = dict()

    bleAdapter.init()
    agent = securityAgent.createSecurityAgent()

    scan_filter.update({"UUIDs": [runTest.DUT_UUID]})
    bleAdapter.setDiscoveryFilter(scan_filter)

    #Discovery test
    bleAdapter.startDiscovery(discoveryEventCb)
    mainloop.run()
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.advertisement)
    bleAdapter.stopDiscovery()

    #Simple Connection test
    testDevice = runTest.getTestDevice()
    isTestSuccessFull = bleAdapter.connect(testDevice)
    runTest.submitTestResult(isTestSuccessFull, runTest.simpleConnection)
    time.sleep(2)  #wait for connection parameters update

    #Discover all primary services
    isTestSuccessFull = runTest.discoverPrimaryServices()
    runTest.submitTestResult(isTestSuccessFull,
                             runTest.discoverPrimaryServices)

    bleAdapter.gatt.updateLocalAttributeTable()

    #Check device not present. After discovery of services, advertisement should have stopped.
    runTest.stopAdvertisement(scan_filter)

    #Change MTU size
    #bleAdapter.readLocalMTU()

    #Check attribute table UUIDs
    bleAdapter.gatt.updateLocalAttributeTable()
    isTestSuccessFull = runTest.checkUUIDs(bleAdapter.gatt)
    runTest.submitTestResult(isTestSuccessFull, runTest.checkUUIDs)

    #Check attribute table properties
    isTestSuccessFull = runTest.checkProperties(bleAdapter.gatt)
    runTest.submitTestResult(isTestSuccessFull, runTest.checkProperties)

    #Check read/write, simple connection
    isTestSuccessFull = runTest.readWriteSimpleConnection()
    runTest.submitTestResult(isTestSuccessFull,
                             runTest.readWriteSimpleConnection)

    #check write without response
    isTestSuccessFull = runTest.writeWithoutResponse()
    runTest.submitTestResult(isTestSuccessFull, runTest.writeWithoutResponse)

    #Enable and receive notification and indication then disable.
    bleAdapter.setNotificationCallBack(notificationCb)
    bleAdapter.subscribeForNotification(
        runTest.DUT_NOTIFY_CHAR_UUID)  #subscribe for next test
    bleAdapter.subscribeForNotification(
        runTest.DUT_INDICATE_CHAR_UUID)  #subscribe for next test

    isTestSuccessFull = True
    mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.notification)

    isTestSuccessFull = True
    mainloop.run()
    runTest.submitTestResult(isTestSuccessFull, runTest.indication)

    isTestSuccessFull = bleAdapter.subscribeForNotification(
        runTest.DUT_NOTIFY_CHAR_UUID, subscribe=False)  #unsubscribe
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.removeNotification)

    isTestSuccessFull = bleAdapter.subscribeForNotification(
        runTest.DUT_INDICATE_CHAR_UUID, subscribe=False)  #unsubscribe
    isTestSuccessFull = True
    runTest.submitTestResult(isTestSuccessFull, runTest.removeIndication)

    #Check writing to protected characteristic triggers pairing
    isTestSuccessFull = runTest.pairing()
    runTest.submitTestResult(isTestSuccessFull, runTest.pairing)
    bleAdapter.bondToRemoteDevice()

    #Check writing to protected characteristic after successfull pairing succeed
    time.sleep(2)  #wait before starting next test
    isTestSuccessFull = runTest.readWriteProtectedAttributesWhilePaired()
    runTest.submitTestResult(isTestSuccessFull,
                             runTest.readWriteProtectedAttributesWhilePaired)

    #disconnect, Note it is not a test happening on bluez, the DUT is waiting for a disconnect Cb
    runTest.disconnect()

    #reconnect! Since devices bonded, it should not ask for pairing again. Security agent can be destroyed
    securityAgent.removeSecurityAgent(
    )  #remove security agent so as not to trigger auto pairing.
    bleAdapter.setDiscoveryFilter(scan_filter)
    bleAdapter.startDiscovery(
        discoveryStartedCb)  #wait for DUT to start advertising
    mainloop.run()
    bleAdapter.stopDiscovery()
    runTest.reconnectWhileBonded()

    #reconnect while not bonded. Pairing should fail since Just works is not accepted
    bleAdapter.disconnect()
    bleAdapter.removeBondedDevices()
    time.sleep(2)  #wait for bonded devices to be deleted
    bleAdapter.setDiscoveryFilter(scan_filter)
    bleAdapter.startDiscovery(discoveryEventCb)
    mainloop.run()
    bleAdapter.stopDiscovery()

    agent = securityAgent.createSecurityAgent("NoInputNoOutput", agent)
    runTest.reconnectWhileNotBonded()

    time.sleep(2)
    runTest.printTestsSummary()