From 8ffeebaf74961cdef1517b39075421f69ce47d60 Mon Sep 17 00:00:00 2001 From: Andrey Tolstoy Date: Tue, 9 Jul 2024 22:58:27 +0700 Subject: [PATCH] [test] wiring/ble_centeral_peripheral: update tests with connect + scan --- .../ble_central/central.cpp | 90 ++++++++++++++ .../ble_peripheral/peripheral.cpp | 116 ++++++++++++++++++ 2 files changed, 206 insertions(+) diff --git a/user/tests/wiring/ble_central_peripheral/ble_central/central.cpp b/user/tests/wiring/ble_central_peripheral/ble_central/central.cpp index efd567efde..ce338774ce 100644 --- a/user/tests/wiring/ble_central_peripheral/ble_central/central.cpp +++ b/user/tests/wiring/ble_central_peripheral/ble_central/central.cpp @@ -60,6 +60,9 @@ using namespace particle::test; constexpr uint16_t LOCAL_DESIRED_ATT_MTU = 100; constexpr uint16_t PEER_DESIRED_ATT_MTU = 123; +Thread* scanThread = nullptr; +volatile unsigned scanResults = 0; + test(BLE_000_Central_Cloud_Connect) { subscribeEvents(BLE_ROLE_PERIPHERAL); Particle.connect(); @@ -579,5 +582,92 @@ test(BLE_32_Att_Mtu_Exchange) { } } +test(BLE_33_Central_Can_Connect_While_Scanning) { + BleScanParams params = {}; + params.size = sizeof(BleScanParams); + params.timeout = 0; + params.interval = 8000; // *0.625ms = 5s + params.window = 8000; // *0.625 = 5s + params.active = true; // Send scan request + params.filter_policy = BLE_SCAN_FP_ACCEPT_ALL; + assertEqual(0, BLE.setScanParameters(¶ms)); + + scanThread = new Thread("test", [](void* param) -> os_thread_return_t { + BLE.scanWithFilter(BleScanFilter().allowDuplicates(true), +[](const BleScanResult *result, void *param) -> void { + auto scanResults = (volatile unsigned int*)param; + (*scanResults)++; + }, param); + }, (void*)&scanResults); + + assertTrue(BLE.scanning()); + assertFalse(BLE.connected()); + peer = BLE.connect(peerAddr, false); + assertTrue(peer.connected()); + assertTrue(BLE.scanning()); + SCOPE_GUARD({ + SCOPE_GUARD ({ + delay(500); + assertEqual(BLE.disconnect(peer), (int)SYSTEM_ERROR_NONE); + assertFalse(BLE.connected()); + delay(500); + }); + }); + scanResults = 0; + delay(2000); +#if !HAL_PLATFORM_NRF52840 + assertMoreOrEqual((unsigned)scanResults, 1); +#endif + assertTrue(peer.connected()); +} + +test(BLE_34_Central_Can_Connect_While_Scanning_After_Disconnect) { + SCOPE_GUARD({ + if (BLE.scanning() && scanThread) { + assertEqual(0, BLE.stopScanning()); + scanThread->join(); + delete scanThread; + } + }); + assertTrue(BLE.scanning()); + assertFalse(BLE.connected()); + scanResults = 0; + delay(5000); + assertMoreOrEqual((unsigned)scanResults, 1); +} + +test(BLE_35_Central_Can_Connect_While_Peripheral_Is_Scanning_Prepare) { +} + +test(BLE_36_Central_Can_Connect_While_Peripheral_Is_Scanning) { + peer = BLE.connect(peerAddr, false); + assertTrue(peer.connected()); + delay(5000); + { + SCOPE_GUARD ({ + delay(500); + assertEqual(BLE.disconnect(peer), (int)SYSTEM_ERROR_NONE); + assertFalse(BLE.connected()); + delay(500); + }); + } +} + +test(BLE_37_Central_Can_Connect_While_Peripheral_Is_Scanning_And_Stops_Scanning_Prepare) { +} + +test(BLE_38_Central_Can_Connect_While_Peripheral_Is_Scanning_And_Stops_Scanning) { + peer = BLE.connect(peerAddr, false); + assertTrue(peer.connected()); + delay(5000); + { + SCOPE_GUARD ({ + delay(500); + assertEqual(BLE.disconnect(peer), (int)SYSTEM_ERROR_NONE); + assertFalse(BLE.connected()); + delay(500); + }); + } +} + #endif // #if Wiring_BLE == 1 diff --git a/user/tests/wiring/ble_central_peripheral/ble_peripheral/peripheral.cpp b/user/tests/wiring/ble_central_peripheral/ble_peripheral/peripheral.cpp index 023c1ac71b..8533605cf4 100644 --- a/user/tests/wiring/ble_central_peripheral/ble_peripheral/peripheral.cpp +++ b/user/tests/wiring/ble_central_peripheral/ble_peripheral/peripheral.cpp @@ -69,6 +69,9 @@ using namespace particle::test; constexpr uint16_t LOCAL_DESIRED_ATT_MTU = 123; constexpr uint16_t PEER_DESIRED_ATT_MTU = 100; +Thread* scanThread = nullptr; +volatile unsigned scanResults = 0; + test(BLE_000_Peripheral_Cloud_Connect) { subscribeEvents(BLE_ROLE_PERIPHERAL); Particle.connect(); @@ -487,5 +490,118 @@ test(BLE_32_Att_Mtu_Exchange) { } } +test(BLE_33_Central_Can_Connect_While_Scanning) { + assertTrue(waitFor(BLE.connected, 20000)); + SCOPE_GUARD ({ + assertTrue(waitFor([]{ return !BLE.connected(); }, 10000)); + assertFalse(BLE.connected()); + }); +} + +test(BLE_34_Central_Can_Connect_While_Scanning_After_Disconnect) { +} + +test(BLE_35_Central_Can_Connect_While_Peripheral_Is_Scanning_Prepare) { + BleScanParams params = {}; + params.size = sizeof(BleScanParams); + params.timeout = 0; + params.interval = 8000; // *0.625ms = 5s + params.window = 8000; // *0.625 = 5s + params.active = true; // Send scan request + params.filter_policy = BLE_SCAN_FP_ACCEPT_ALL; + assertEqual(0, BLE.setScanParameters(¶ms)); + + scanThread = new Thread("test", [](void* param) -> os_thread_return_t { + BLE.scanWithFilter(BleScanFilter().allowDuplicates(true), +[](const BleScanResult *result, void *context) -> void { + scanResults++; + }, nullptr); + }, nullptr); + assertTrue((bool)scanThread); +} + +test(BLE_36_Central_Can_Connect_While_Peripheral_Is_Scanning) { + SCOPE_GUARD({ + if (BLE.scanning() && scanThread) { + BLE.stopScanning(); + scanThread->join(); + delete scanThread; + scanThread = nullptr; + } + }); + assertTrue(BLE.scanning()); + assertTrue(waitFor(BLE.connected, 60000)); + scanResults = 0; + delay(2000); +#if !HAL_PLATFORM_NRF52840 + assertMoreOrEqual((unsigned)scanResults, 1); +#endif + SCOPE_GUARD ({ + assertTrue(waitFor([]{ return !BLE.connected(); }, 10000)); + assertFalse(BLE.connected()); + + scanResults = 0; + delay(2000); +#if !HAL_PLATFORM_NRF52840 + assertMoreOrEqual((unsigned)scanResults, 1); +#endif + + assertEqual(0, BLE.stopScanning()); + assertFalse(BLE.scanning()); + scanThread->join(); + delete scanThread; + scanThread = nullptr; + }); +} + +test(BLE_37_Central_Can_Connect_While_Peripheral_Is_Scanning_And_Stops_Scanning_Prepare) { + BleScanParams params = {}; + params.size = sizeof(BleScanParams); + params.timeout = 0; + params.interval = 8000; // *0.625ms = 5s + params.window = 8000; // *0.625 = 5s + params.active = true; // Send scan request + params.filter_policy = BLE_SCAN_FP_ACCEPT_ALL; + assertEqual(0, BLE.setScanParameters(¶ms)); + + scanThread = new Thread("test", [](void* param) -> os_thread_return_t { + BLE.scanWithFilter(BleScanFilter().allowDuplicates(true), +[](const BleScanResult *result, void *context) -> void { + scanResults++; + }, nullptr); + }, nullptr); + assertTrue((bool)scanThread); +} + +test(BLE_38_Central_Can_Connect_While_Peripheral_Is_Scanning_And_Stops_Scanning) { + SCOPE_GUARD({ + if (BLE.scanning() && scanThread) { + BLE.stopScanning(); + scanThread->join(); + delete scanThread; + scanThread = nullptr; + } + }); + assertTrue(BLE.scanning()); + assertTrue(waitFor(BLE.connected, 60000)); + scanResults = 0; + delay(2000); +#if !HAL_PLATFORM_NRF52840 + assertMoreOrEqual((unsigned)scanResults, 1); +#endif + + assertEqual(0, BLE.stopScanning()); + assertFalse(BLE.scanning()); + scanThread->join(); + delete scanThread; + scanThread = nullptr; + + assertTrue(BLE.connected()); + + SCOPE_GUARD ({ + assertTrue(waitFor([]{ return !BLE.connected(); }, 10000)); + assertFalse(BLE.connected()); + }); +} + + #endif // #if Wiring_BLE == 1