1 files changed, 26 insertions, 24 deletions
diff --git a/tests/cpass/schedule.rs b/tests/cpass/schedule.rs
index 0728d8b3..346f9124 100644
--- a/tests/cpass/schedule.rs
+++ b/tests/cpass/schedule.rs
@@ -1,3 +1,5 @@
+#![deny(unsafe_code)]
+#![deny(warnings)]
 #![no_main]
 #![no_std]
 
@@ -5,52 +7,52 @@ extern crate lm3s6965;
 extern crate panic_halt;
 extern crate rtfm;
 
-use rtfm::{app, Instant};
+use rtfm::Instant;
 
-#[app(device = lm3s6965)]
+#[rtfm::app(device = lm3s6965)]
 const APP: () = {
     #[init(schedule = [foo, bar, baz])]
-    fn init() {
-        let _: Result<(), ()> = schedule.foo(start + 10.cycles());
-        let _: Result<(), u32> = schedule.bar(start + 20.cycles(), 0);
-        let _: Result<(), (u32, u32)> = schedule.baz(start + 30.cycles(), 0, 1);
+    fn init(c: init::Context) {
+        let _: Result<(), ()> = c.schedule.foo(c.start + 10.cycles());
+        let _: Result<(), u32> = c.schedule.bar(c.start + 20.cycles(), 0);
+        let _: Result<(), (u32, u32)> = c.schedule.baz(c.start + 30.cycles(), 0, 1);
     }
 
     #[idle(schedule = [foo, bar, baz])]
-    fn idle() -> ! {
-        let _: Result<(), ()> = schedule.foo(Instant::now() + 40.cycles());
-        let _: Result<(), u32> = schedule.bar(Instant::now() + 50.cycles(), 0);
-        let _: Result<(), (u32, u32)> = schedule.baz(Instant::now() + 60.cycles(), 0, 1);
+    fn idle(c: idle::Context) -> ! {
+        let _: Result<(), ()> = c.schedule.foo(Instant::now() + 40.cycles());
+        let _: Result<(), u32> = c.schedule.bar(Instant::now() + 50.cycles(), 0);
+        let _: Result<(), (u32, u32)> = c.schedule.baz(Instant::now() + 60.cycles(), 0, 1);
 
         loop {}
     }
 
     #[exception(schedule = [foo, bar, baz])]
-    fn SVCall() {
-        let _: Result<(), ()> = schedule.foo(start + 70.cycles());
-        let _: Result<(), u32> = schedule.bar(start + 80.cycles(), 0);
-        let _: Result<(), (u32, u32)> = schedule.baz(start + 90.cycles(), 0, 1);
+    fn SVCall(c: SVCall::Context) {
+        let _: Result<(), ()> = c.schedule.foo(c.start + 70.cycles());
+        let _: Result<(), u32> = c.schedule.bar(c.start + 80.cycles(), 0);
+        let _: Result<(), (u32, u32)> = c.schedule.baz(c.start + 90.cycles(), 0, 1);
     }
 
     #[interrupt(schedule = [foo, bar, baz])]
-    fn UART0() {
-        let _: Result<(), ()> = schedule.foo(start + 100.cycles());
-        let _: Result<(), u32> = schedule.bar(start + 110.cycles(), 0);
-        let _: Result<(), (u32, u32)> = schedule.baz(start + 120.cycles(), 0, 1);
+    fn UART0(c: UART0::Context) {
+        let _: Result<(), ()> = c.schedule.foo(c.start + 100.cycles());
+        let _: Result<(), u32> = c.schedule.bar(c.start + 110.cycles(), 0);
+        let _: Result<(), (u32, u32)> = c.schedule.baz(c.start + 120.cycles(), 0, 1);
     }
 
     #[task(schedule = [foo, bar, baz])]
-    fn foo() {
-        let _: Result<(), ()> = schedule.foo(scheduled + 130.cycles());
-        let _: Result<(), u32> = schedule.bar(scheduled + 140.cycles(), 0);
-        let _: Result<(), (u32, u32)> = schedule.baz(scheduled + 150.cycles(), 0, 1);
+    fn foo(c: foo::Context) {
+        let _: Result<(), ()> = c.schedule.foo(c.scheduled + 130.cycles());
+        let _: Result<(), u32> = c.schedule.bar(c.scheduled + 140.cycles(), 0);
+        let _: Result<(), (u32, u32)> = c.schedule.baz(c.scheduled + 150.cycles(), 0, 1);
     }
 
     #[task]
-    fn bar(_x: u32) {}
+    fn bar(_: bar::Context, _x: u32) {}
 
     #[task]
-    fn baz(_x: u32, _y: u32) {}
+    fn baz(_: baz::Context, _x: u32, _y: u32) {}
 
     extern "C" {
         fn UART1();