Esempio n. 1
0
 def _scan_discovery_with_timer(bleAdapter):
     bleAdapter.startDiscovery(runTest.discoveryStartedCb)
     StartScan = time.time()
     runTest.mainloop.run()
     ScanTime = time.time() - StartScan
     bleAdapter.stopDiscovery()
     return ScanTime
Esempio n. 2
0
    def _advertisement_start(scan_filter, UUID, discoveryEvent_Cb, bleAdapter):
        scan_filter.update({"UUIDs": [UUID]})
        bleAdapter.setDiscoveryFilter(scan_filter)

        # Discovery test
        bleAdapter.startDiscovery(discoveryEvent_Cb)
        runTest.mainloop.run()
        bleAdapter.stopDiscovery()
Esempio n. 3
0
 def stopAdvertisement(scan_filter):
     timerHandle = GObject.timeout_add(
         runTest.STOP_ADVERTISEMENT_TEST_TIMEOUT, discoveryStoppedCb)
     bleAdapter.setDiscoveryFilter(scan_filter)
     bleAdapter.startDiscovery(
         discoveryStoppedCb)  #wait for DUT to start advertising
     mainloop.run()
     runTest.submitTestResult(testResult, runTest.stopAdvertisement)
     bleAdapter.stopDiscovery()
    def stopAdvertisement(scan_filter):
        #Do one cycle of discovery to remove cached messages.
        timerHandle = GObject.timeout_add(runTest.STOP_ADVERTISEMENT_TEST_TIMEOUT, runTest.discoveryStoppedCb)
        bleAdapter.setDiscoveryFilter(scan_filter)
        bleAdapter.startDiscovery(runTest.discoveryStoppedCb)#wait for DUT to start advertising
        runTest.mainloop.run()
        bleAdapter.stopDiscovery()

        #All cached message have been remove. Try again a discovery.
        timerHandle = GObject.timeout_add(runTest.STOP_ADVERTISEMENT_TEST_TIMEOUT, runTest.discoveryStoppedCb)
        bleAdapter.setDiscoveryFilter(scan_filter)
        bleAdapter.startDiscovery(runTest.discoveryStoppedCb)#wait for DUT to start advertising
        runTest.mainloop.run()
        runTest.submitTestResult(testResult, runTest.stopAdvertisement)
        bleAdapter.stopDiscovery()
Esempio n. 5
0
    def Send_Data_After_Disconnected(scan_filter, bleAdapter):
        runTest._advertisement_start(
            scan_filter=scan_filter,
            UUID=runTest.DUT_UUID_128,
            discoveryEvent_Cb=runTest.discoveryEventCb,
            bleAdapter=bleAdapter)
        runTest._simple_connect()

        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
        # wait for DUT to start advertising
        bleAdapter.startDiscovery(runTest.discoveryStartedCb)
        runTest.mainloop.run()
        bleAdapter.stopDiscovery()
        runTest._simple_connect()

        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()

        return isTestSuccessFull
def main():
    scan_filter = dict()

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

    scan_filter.update({"UUIDs": [runTest.DUT_UUID_128]})
    bleAdapter.setDiscoveryFilter(scan_filter)
    # Discovery test
    bleAdapter.startDiscovery(runTest.discoveryEventCb)
    runTest.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 long write
    isTestSuccessFull = runTest.writeLongCharacteristic()
    runTest.submitTestResult(isTestSuccessFull,
                             runTest.writeLongCharacteristic)

    # 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(runTest.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
    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)

    # 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
    # remove security agent so as not to trigger auto pairing.
    securityAgent.removeSecurityAgent()
    bleAdapter.setDiscoveryFilter(scan_filter)
    # wait for DUT to start advertising
    bleAdapter.startDiscovery(runTest.discoveryStartedCb)
    runTest.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(runTest.discoveryEventCb)
    runTest.mainloop.run()
    bleAdapter.stopDiscovery()

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

    time.sleep(2)
    runTest.printTestsSummary()