From d2fb62f729de3ad24132b69298e17193ac334df4 Mon Sep 17 00:00:00 2001
From: Jorge Aparicio <jorge@japaric.io>
Date: Sun, 21 Apr 2019 20:13:15 +0200
Subject: update compile-pass tests

---
 tests/cpass/resource.rs | 44 +++++++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 21 deletions(-)

(limited to 'tests/cpass/resource.rs')

diff --git a/tests/cpass/resource.rs b/tests/cpass/resource.rs
index bb83739..4e92a03 100644
--- a/tests/cpass/resource.rs
+++ b/tests/cpass/resource.rs
@@ -1,5 +1,7 @@
 //! Check code generation of resources
 
+#![deny(unsafe_code)]
+#![deny(warnings)]
 #![no_main]
 #![no_std]
 
@@ -7,9 +9,9 @@ extern crate lm3s6965;
 extern crate panic_halt;
 extern crate rtfm;
 
-use rtfm::{app, Exclusive};
+use rtfm::Exclusive;
 
-#[app(device = lm3s6965)]
+#[rtfm::app(device = lm3s6965)]
 const APP: () = {
     static mut O1: u32 = 0; // init
     static mut O2: u32 = 0; // idle
@@ -23,57 +25,57 @@ const APP: () = {
     static S3: u32 = 0;
 
     #[init(resources = [O1, O4, O5, O6, S3])]
-    fn init() {
+    fn init(c: init::Context) {
         // owned by `init` == `&'static mut`
-        let _: &'static mut u32 = resources.O1;
+        let _: &'static mut u32 = c.resources.O1;
 
         // owned by `init` == `&'static` if read-only
-        let _: &'static u32 = resources.O6;
+        let _: &'static u32 = c.resources.O6;
 
         // `init` has exclusive access to all resources
-        let _: &mut u32 = resources.O4;
-        let _: &mut u32 = resources.O5;
-        let _: &mut u32 = resources.S3;
+        let _: &mut u32 = c.resources.O4;
+        let _: &mut u32 = c.resources.O5;
+        let _: &mut u32 = c.resources.S3;
     }
 
     #[idle(resources = [O2, O4, S1, S3])]
-    fn idle() -> ! {
+    fn idle(mut c: idle::Context) -> ! {
         // owned by `idle` == `&'static mut`
-        let _: &'static mut u32 = resources.O2;
+        let _: &'static mut u32 = c.resources.O2;
 
         // owned by `idle` == `&'static` if read-only
-        let _: &'static u32 = resources.O4;
+        let _: &'static u32 = c.resources.O4;
 
         // shared with `idle` == `Mutex`
-        resources.S1.lock(|_| {});
+        c.resources.S1.lock(|_| {});
 
         // `&` if read-only
-        let _: &u32 = resources.S3;
+        let _: &u32 = c.resources.S3;
 
         loop {}
     }
 
     #[interrupt(resources = [O3, S1, S2, S3])]
-    fn UART0() {
+    fn UART0(c: UART0::Context) {
         // owned by interrupt == `&mut`
-        let _: &mut u32 = resources.O3;
+        let _: &mut u32 = c.resources.O3;
 
         // no `Mutex` proxy when access from highest priority task
-        let _: Exclusive<u32> = resources.S1;
+        let _: Exclusive<u32> = c.resources.S1;
 
         // no `Mutex` proxy when co-owned by cooperative (same priority) tasks
-        let _: Exclusive<u32> = resources.S2;
+        let _: Exclusive<u32> = c.resources.S2;
 
         // `&` if read-only
-        let _: &u32 = resources.S3;
+        let _: &u32 = c.resources.S3;
     }
 
     #[interrupt(resources = [S2, O5])]
-    fn UART1() {
+    fn UART1(c: UART1::Context) {
         // owned by interrupt == `&` if read-only
-        let _: &u32 = resources.O5;
+        let _: &u32 = c.resources.O5;
 
         // no `Mutex` proxy when co-owned by cooperative (same priority) tasks
-        let _: Exclusive<u32> = resources.S2;
+        let _: Exclusive<u32> = c.resources.S2;
     }
 };
-- 
cgit v1.2.3