test wip

README.md

@@ -6,6 +6,7 @@ TrouBLE is a Bluetooth Low Energy (BLE) Host implementation written in Rust, wit
 
 ## What is a Host?
 
+
 A BLE Host is one side of the Host Controller Interface (HCI). The BLE specification defines the software of a BLE implementation in terms of a `controller` (lower layer) and a `host` (upper layer).
 
 These communicate via a standardized protocol, that may run over different transports such as as UART, USB or a custom in-memory IPC implementation.

examples/esp32/src/consts.rs

@@ -1,6 +1,6 @@
 /// Size of L2CAP packets
 #[cfg(not(any(feature = "esp32c2", feature = "esp32c6", feature = "esp32h2")))]
-pub const L2CAP_MTU: usize = 128;
+pub const L2CAP_MTU: usize = 251;
 // Some esp chips only accept an MTU >= 255
 #[cfg(any(feature = "esp32c2", feature = "esp32c6", feature = "esp32h2"))]
 pub const L2CAP_MTU: usize = 255;

examples/tests/src/probe/mod.rs

@@ -33,17 +33,28 @@ impl<'d> DeviceUnderTest<'d> {
     }
 
     pub async fn run(self, firmware: String) -> Result<FirmwareLogs, anyhow::Error> {
-        let mut flasher = Command::new("probe-rs")
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .arg("run")
-            .arg(&firmware)
-            .arg("--chip")
-            .arg(&self.target.config().chip)
-            .arg("--probe")
-            .arg(&self.target.config().probe)
-            .spawn()
-            .unwrap();
+        let mut flasher = if self.target.config().chip.starts_with("esp32") {
+            Command::new("espflash")
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .arg("flash")
+                .arg(&firmware)
+                .arg("--monitor")
+                .spawn()
+                .unwrap()
+        } else {
+            Command::new("probe-rs")
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .arg("run")
+                .arg(&firmware)
+                .arg("--chip")
+                .arg(&self.target.config().chip)
+                .arg("--probe")
+                .arg(&self.target.config().probe)
+                .spawn()
+                .unwrap()
+        };
 
         let stdout = flasher.stdout.take().unwrap();
         let stderr = flasher.stderr.take().unwrap();

examples/tests/tests/ble_l2cap_central.rs

@@ -1,4 +1,4 @@
-use futures::future::select;
+use futures::future::join;
 use std::time::Duration;
 use tokio::select;
 use trouble_example_tests::{serial, TestContext};
@@ -107,11 +107,15 @@ async fn run_l2cap_central_test(labels: &[(&str, &str)], firmware: &str) {
         }
     });
 
-    tokio::time::timeout(Duration::from_secs(60), select(central, peripheral))
+    tokio::time::timeout(Duration::from_secs(60), join(peripheral, central))
         .await
         .map_err(|_| {
             println!("Test timed out");
             assert!(false);
         })
+        .map(|(p, c)| {
+            p.expect("peripheral failed").unwrap();
+            c.expect("central failed").unwrap();
+        })
         .unwrap();
 }

examples/tests/tests/ble_l2cap_peripheral.rs

@@ -1,4 +1,4 @@
-use futures::future::select;
+use futures::future::join;
 use std::time::Duration;
 use tokio::select;
 use trouble_example_tests::{serial, TestContext};
@@ -92,11 +92,15 @@ async fn run_l2cap_peripheral_test(labels: &[(&str, &str)], firmware: &str) {
         }
     });
 
-    tokio::time::timeout(Duration::from_secs(60), select(peripheral, central))
+    tokio::time::timeout(Duration::from_secs(60), join(peripheral, central))
         .await
         .map_err(|_| {
             println!("Test timed out");
             assert!(false);
         })
+        .map(|(p, c)| {
+            p.expect("peripheral failed").unwrap();
+            c.expect("central failed").unwrap();
+        })
         .unwrap();
 }