Change on-target testing to use QEMU

Author: newAM

.github/workflows/on-target.yml

@@ -0,0 +1,32 @@
+on:
+  push:
+    branches: [ staging, trying, master ]
+  pull_request:
+
+name: QEMU
+
+jobs:
+  qemu:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          target: thumbv7m-none-eabi
+      - name: Build testsuite
+        run: cargo build -p testsuite --target thumbv7m-none-eabi --features testsuite/semihosting
+      - name: Install QEMU
+        run: sudo apt-get update && sudo apt-get install qemu qemu-system-arm
+      - name: Run testsuite
+        run: |
+          qemu-system-arm \
+            -cpu cortex-m3 \
+            -machine lm3s6965evb \
+            -nographic \
+            -semihosting-config enable=on,target=native \
+            -kernel target/thumbv7m-none-eabi/debug/testsuite

.github/workflows/qemu.yml

@@ -5,8 +5,19 @@ publish = false
 edition = "2018"
 version = "0.1.0"
 
+[features]
+rtt = ["rtt-target", "minitest/rtt"]
+semihosting = ["cortex-m-semihosting", "minitest/semihosting"]
+
 [dependencies]
 cortex-m-rt.path = "../cortex-m-rt"
 cortex-m.path = ".."
 minitest.path = "minitest"
-rtt-target = "0.3.1"
+
+[dependencies.rtt-target]
+version = "0.3.1"
+optional = true
+
+[dependencies.cortex-m-semihosting]
+path = "../cortex-m-semihosting"
+optional = true

testsuite/Cargo.toml

@@ -1,58 +1,88 @@
 # Testsuite
 
-This workspace contains on-target tests.
+This workspace contains tests that run on physical and simulated Cortex-M CPUs.
 
 ## Building
 
+Exactly one of these features are required:
+
+* `semihosting` Use semihosting for logging, this is used for QEMU.
+* `rtt` Use RTT for logging, this is used with physical cortex-m CPUs.
+
 Assuming you are at the root of the repository you can build like this:
 
 ```console
-$ cargo build -p testsuite --target thumbv6m-none-eabi
+$ cargo build -p testsuite --target thumbv6m-none-eabi --features testsuite/rtt
    Compiling testsuite v0.1.0 (cortex-m/testsuite)
     Finished dev [unoptimized + debuginfo] target(s) in 0.08
 ```
 
-## Running
+## Running with QEMU
 
-No implementation-specific features are tested right now; any `thumbv6m-none-eabi` target should work.
+* Use the `semihosting` feature for logging, QEMU does not have native support for RTT
+* Build for the `thumbv7m-none-eabi` target to match the Cortex-M3 lm3s6965evb machine
 
-Tests are executed with [probe-run](https://github.com/knurling-rs/probe-run):
+For more information on QEMU reference the QEMU section in [The Embedded Rust Book].
 
 ```console
+$ cargo build -p testsuite --target thumbv7m-none-eabi --features testsuite/semihosting
+   Compiling testsuite v0.1.0 (cortex-m/testsuite)
+    Finished dev [unoptimized + debuginfo] target(s) in 0.08
+$ qemu-system-arm \
+  -cpu cortex-m3 \
+  -machine lm3s6965evb \
+  -nographic \
+  -semihosting-config enable=on,target=native \
+  -kernel target/thumbv7m-none-eabi/debug/testsuite
+Timer with period zero, disabling
+(1/3) running `assert_true`...
+(2/3) running `assert_flag`...
+(3/3) running `printing`...
+Hello, World!
+all tests passed!
+```
+
+## Running with Physical Hardware
+
+No implementation-specific features are tested right now; any physical `thumbv6m-none-eabi` target should work.
+
+Tests are executed with [probe-run](https://github.com/knurling-rs/probe-run).
+
+This example is provided for the `STM32F070RBTx`, if using a different target:
+
+* Change the `probe-run` chip argument to match your chip, supported chips can be found with `probe-run --list-chips`
+* Modify `stm32-memory.x` to match the memory layout of your target
+* Change the build target to match your CPU
+
+```console
+$ cargo build -p testsuite --target thumbv6m-none-eabi --features testsuite/rtt
+   Compiling testsuite v0.1.0 (cortex-m/testsuite)
+    Finished dev [unoptimized + debuginfo] target(s) in 0.08
 $ probe-run --chip STM32F070RBTx --connect-under-reset target/thumbv6m-none-eabi/debug/testsuite
-(HOST) INFO  flashing program (12.80 KiB)
+(HOST) INFO  flashing program (14.26 KiB)
 (HOST) INFO  success!
 ────────────────────────────────────────────────────────────────────────────────
-(1/2) running `assert_true`...
-(2/2) running `assert_flag`...
+(1/3) running `assert_true`...
+(2/3) running `assert_flag`...
+(3/3) running `printing`...
+Hello, World!
 all tests passed!
 ────────────────────────────────────────────────────────────────────────────────
 stack backtrace:
    0: lib::inline::__bkpt
         at ./asm/inline.rs:13:5
    1: __bkpt
         at ./asm/lib.rs:49:17
-   2: minitest::export::exit
-        at testsuite/minitest/src/export.rs:6:9
-   3: main
-        at testsuite/src/main.rs:23:1
-   4: Reset
+   2: minitest::exit
+        at testsuite/minitest/src/lib.rs:55:9
+   3: testsuite::tests::__cortex_m_rt___minitest_entry
+        at testsuite/src/main.rs:19:1
+   4: main
+        at testsuite/src/main.rs:19:1
+   5: Reset
 (HOST) WARN  call stack was corrupted; unwinding could not be completed
 (HOST) INFO  device halted without error
 ```
 
-## CI
-
-These tests are run automatically in continuous integration.  A self-hosted github actions runner with a NUCLEO-F070RB board is hosted by [newAM](https://github.com/newAM).
-
-The runner is equiped with a limited selection of packages:
-* [Unix Commands](https://en.wikipedia.org/wiki/List_of_Unix_commands)
-* clang
-* gcc-arm-embedded
-* git
-* probe-run
-* rustup
-
-The complete host configuration can be found here [here](https://github.com/newAM/nixfiles/blob/main/t430s/configuration.nix).
-
-⚠️ Hosting a github actions runner in a public repository goes directly against [github's advice](https://docs.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners#self-hosted-runner-security-with-public-repositories), do not do this yourself unless you are prepared to accept the risks.
+[The Embedded Rust Book]: https://docs.rust-embedded.org/book/start/qemu.html
+[probe-run]: https://github.com/knurling-rs/probe-run

testsuite/README.md

@@ -0,0 +1,26 @@
+use std::{env, fs, path::PathBuf};
+
+fn main() {
+    #[cfg(any(
+        not(any(feature = "semihosting", feature = "rtt")),
+        all(feature = "semihosting", feature = "rtt")
+    ))]
+    {
+        eprintln!("Exactly one of these features must be enabled: rtt, semihosting");
+        std::process::exit(1);
+    }
+
+    println!("cargo:rerun-if-changed=qemu-memory.x");
+    println!("cargo:rerun-if-changed=stm32-memory.x");
+
+    let out_dir: PathBuf =
+        PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR environment variable not set"));
+
+    println!("cargo:rustc-link-search={}", out_dir.display());
+
+    #[cfg(feature = "semihosting")]
+    fs::copy("qemu-memory.x", out_dir.join("memory.x")).unwrap();
+
+    #[cfg(feature = "rtt")]
+    fs::copy("stm32-memory.x", out_dir.join("memory.x")).unwrap();
+}

testsuite/build.rs

@@ -5,8 +5,19 @@ publish = false
 edition = "2018"
 version = "0.1.0"
 
+[features]
+semihosting = ["cortex-m-semihosting", "minitest-macros/semihosting"]
+rtt = ["rtt-target", "minitest-macros/rtt"]
+
 [dependencies]
 cortex-m.path = "../.."
 cortex-m-rt.path = "../../cortex-m-rt"
-minitest-macros = { version = "=0.1.0", path = "macros" }
-rtt-target = "0.3.1"
+minitest-macros.path = "macros"
+
+[dependencies.rtt-target]
+version = "0.3.1"
+optional = true
+
+[dependencies.cortex-m-semihosting]
+path = "../../cortex-m-semihosting"
+optional = true

testsuite/minitest/Cargo.toml

@@ -1,4 +1,4 @@
-# rtt-test
+# mini-test
 
 This is an embedded test framework forked from knurling's excellent [`defmt-test`] crate.
 

testsuite/minitest/README.md

@@ -8,6 +8,10 @@ version = "0.1.0"
 [lib]
 proc-macro = true
 
+[features]
+semihosting = []
+rtt = []
+
 [dependencies]
 proc-macro2 = "1.0.29"
 quote = "1.0.10"

testsuite/minitest/macros/Cargo.toml

@@ -201,8 +201,9 @@ fn tests_impl(args: TokenStream, input: TokenStream) -> parse::Result<TokenStrea
         )
     };
 
-    let init_rtt = quote!({
-        let channels = rtt_target::rtt_init! {
+    #[cfg(feature = "rtt")]
+    let init_logging = quote!({
+        let channels = ::rtt_target::rtt_init! {
             up: {
                 0: {
                     size: 256
@@ -212,31 +213,31 @@ fn tests_impl(args: TokenStream, input: TokenStream) -> parse::Result<TokenStrea
             }
         };
         unsafe {
-            rtt_target::set_print_channel_cs(
+            ::rtt_target::set_print_channel_cs(
                 channels.up.0,
                 &((|arg, f| cortex_m::interrupt::free(|_| f(arg)))
                     as rtt_target::CriticalSectionFunc),
             );
         }
     });
 
+    #[cfg(not(feature = "rtt"))]
+    let init_logging = quote!({});
+
     let unit_test_progress = tests
         .iter()
         .map(|test| {
-            let message = format!(
-                "({{}}/{{}}) running `{}`...",
-                test.func.sig.ident
-            );
+            let message = format!("({{}}/{{}}) running `{}`...", test.func.sig.ident);
             quote_spanned! {
-                test.func.sig.ident.span() => rtt_target::rprintln!(#message, __minitest_number, __MINITEST_COUNT);
+                test.func.sig.ident.span() => #krate::log!(#message, __minitest_number, __MINITEST_COUNT);
             }
         })
         .collect::<Vec<_>>();
     Ok(quote!(mod #ident {
         #(#untouched_tokens)*
         #[cortex_m_rt::entry]
         fn __minitest_entry() -> ! {
-            #init_rtt
+            #init_logging
             #declare_test_count
             #init_expr
 
@@ -250,8 +251,8 @@ fn tests_impl(args: TokenStream, input: TokenStream) -> parse::Result<TokenStrea
                 }
             )*
 
-            rtt_target::rprintln!("all tests passed!");
-            #krate::export::exit()
+            #krate::log!("all tests passed!");
+            #krate::exit()
         }
 
         #init_fn

testsuite/minitest/macros/src/lib.rs

@@ -1,12 +1,6 @@
 use crate::TestOutcome;
 use cortex_m_rt as _;
 
-pub fn exit() -> ! {
-    loop {
-        cortex_m::asm::bkpt()
-    }
-}
-
 pub fn check_outcome<T: TestOutcome>(outcome: T, should_error: bool) {
     if outcome.is_success() == should_error {
         let note: &str = if should_error {

testsuite/minitest/src/export.rs

@@ -33,3 +33,37 @@ impl<T: Debug, E: Debug> TestOutcome for Result<T, E> {
         self.is_ok()
     }
 }
+
+#[macro_export]
+macro_rules! log {
+    ($s:literal $(, $x:expr)* $(,)?)  => {
+        {
+            #[cfg(feature = "semihosting")]
+            ::cortex_m_semihosting::hprintln!($s $(, $x)*);
+            #[cfg(feature = "rtt")]
+            ::rtt_target::rprintln!($s $(, $x)*);
+            #[cfg(not(any(feature = "semihosting", feature="rtt")))]
+            let _ = ($( & $x ),*);
+        }
+    };
+}
+
+/// Stop all tests without failure.
+pub fn exit() -> ! {
+    loop {
+        #[cfg(feature = "rtt")]
+        cortex_m::asm::bkpt();
+        #[cfg(feature = "semihosting")]
+        cortex_m_semihosting::debug::exit(cortex_m_semihosting::debug::EXIT_SUCCESS);
+    }
+}
+
+/// Stop all tests and report a failure.
+pub fn fail() -> ! {
+    loop {
+        #[cfg(feature = "rtt")]
+        cortex_m::asm::udf();
+        #[cfg(feature = "semihosting")]
+        cortex_m_semihosting::debug::exit(cortex_m_semihosting::debug::EXIT_FAILURE);
+    }
+}

testsuite/minitest/src/lib.rs

@@ -0,0 +1,7 @@
+MEMORY
+{
+  /* NOTE 1 K = 1 KiBi = 1024 bytes */
+  /* These values correspond to the LM3S6965, one of the few devices QEMU can emulate */
+  FLASH : ORIGIN = 0x00000000, LENGTH = 256K
+  RAM : ORIGIN = 0x20000000, LENGTH = 64K
+}