Add some tests for foreign library interface

Chapter06/build.rs

@@ -5,13 +5,13 @@ use std::path::Path;
 fn main() {
     let out_dir = env::var("OUT_DIR").unwrap();
 
-    Command::new("gcc").args(&["src/magic.c", "-c", "-fPIC", "-o"])
-                       .arg(&format!("{}/magic.o", out_dir))
+    Command::new("gcc").args(&["src/elevator_magic.c", "-c", "-fPIC", "-o"])
+                       .arg(&format!("{}/elevator_magic.o", out_dir))
                        .status().unwrap();
-    Command::new("ar").args(&["crus", "libmagic.a", "magic.o"])
+    Command::new("ar").args(&["crus", "libelevatormagic.a", "elevator_magic.o"])
                       .current_dir(&Path::new(&out_dir))
                       .status().unwrap();
 
     println!("cargo:rustc-link-search=native={}", out_dir);
-    println!("cargo:rustc-link-lib=static=magic");
+    println!("cargo:rustc-link-lib=static=elevatormagic");
 }

Chapter06/src/elevator_magic.c

@@ -1,4 +1,8 @@
 
+void issue_override_code(int code) {
+   //C Code
+}
+
 int poll_override_code() {
    //C Code
    return 0;
@@ -9,7 +13,7 @@ int poll_override_input_floor() {
    return 0;
 }
 
-int poll_override_errors() {
+int poll_override_error() {
    //C Code
    return 0;
 }
@@ -23,12 +27,12 @@ void free_override_session(void* session) {
    //C Code
 }
 
-void* poll_physical_override_privileged() {
+void* poll_physical_override_privileged_session() {
    //C Code
    return 0;
 }
 
-void* poll_physical_override_admin() {
+void* poll_physical_override_admin_session() {
    //C Code
    return 0;
 }

Chapter06/src/lib.rs

@@ -2,3 +2,4 @@
 extern crate libc;
 
 mod magic;
+mod tests;

Chapter06/src/magic.rs

@@ -1,67 +1,19 @@
 use libc::{c_int, c_void};
 
-#[link(name = "poll_override_code")]
+#[link(name = "elevatormagic")]
 extern {
+   pub fn issue_override_code(code: c_int);
    pub fn poll_override_code() -> c_int;
-}
-
-#[link(name = "poll_override_input_floor")]
-extern {
    pub fn poll_override_input_floor() -> c_int;
-}
-
-#[link(name = "poll_override_errors")]
-extern {
-   pub fn poll_override_errors() -> c_int;
-}
-
-#[link(name = "poll_override_session")]
-extern {
+   pub fn poll_override_error() -> c_int;
    pub fn poll_override_session() -> *const c_void;
-}
-
-#[link(name = "free_override_session")]
-extern {
    pub fn free_override_session(session: *const c_void);
-}
-
-#[link(name = "poll_physical_override_privileged")]
-extern {
-   pub fn poll_physical_override_privileged() -> *const c_void;
-}
-
-#[link(name = "poll_physical_override_admin")]
-extern {
-   pub fn poll_physical_override_admin() -> *const c_void;
-}
-
-
-#[link(name = "override_manual_mode")]
-extern {
+   pub fn poll_physical_override_privileged_session() -> *const c_void;
+   pub fn poll_physical_override_admin_session() -> *const c_void;
    pub fn override_manual_mode();
-}
-
-#[link(name = "override_normal_mode")]
-extern {
    pub fn override_normal_mode();
-}
-
-#[link(name = "override_reset_state")]
-extern {
    pub fn override_reset_state();
-}
-
-#[link(name = "elevator_display_flash")]
-extern {
    pub fn elevator_display_flash(pattern: c_int);
-}
-
-#[link(name = "elevator_display_toggle_light")]
-extern {
    pub fn elevator_display_toggle_light(light_id: c_int);
-}
-
-#[link(name = "elevator_display_set_light_color")]
-extern {
    pub fn elevator_display_set_light_color(light_id: c_int, color: c_int);
 }

Chapter06/src/tests.rs

@@ -0,0 +1,95 @@
+use magic;
+use libc::{c_void};
+
+#[test]
+fn issue_override_code() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(1);
+      assert!(magic::poll_override_code() == 1);
+      assert!(magic::poll_override_error() == 0);
+   }
+}
+#[test]
+fn issue_privileged_code() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(2);
+      assert!(magic::poll_override_code() == 2);
+      assert!(magic::poll_override_error() == 0);
+   }
+}
+#[test]
+fn issue_admin_code() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(3);
+      assert!(magic::poll_override_code() == 3);
+      assert!(magic::poll_override_error() == 0);
+   }
+}
+
+#[test]
+fn authorize_override_success() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(1);
+      let session = magic::poll_override_session();
+      assert!(session != (0 as *const c_void));
+      magic::free_override_session(session);
+      assert!(magic::poll_override_error() == 0);
+   }
+}
+#[test]
+fn authorize_privileged_success() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(2);
+      let session = magic::poll_physical_override_privileged_session();
+      assert!(session != (0 as *const c_void));
+      magic::free_override_session(session);
+      assert!(magic::poll_override_error() == 0);
+   }
+}
+#[test]
+fn authorize_admin_success() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(3);
+      let session = magic::poll_physical_override_admin_session();
+      assert!(session != (0 as *const c_void));
+      magic::free_override_session(session);
+      assert!(magic::poll_override_error() == 0);
+   }
+}
+
+#[test]
+fn double_override_failure() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(1);
+      magic::issue_override_code(1);
+      assert!(magic::poll_override_session() == (0 as *const c_void));
+      assert!(magic::poll_override_error() == 1);
+   }
+}
+#[test]
+fn double_privileged_failure() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(1);
+      magic::issue_override_code(1);
+      assert!(magic::poll_physical_override_privileged_session() == (0 as *const c_void));
+      assert!(magic::poll_override_error() == 1);
+   }
+}
+#[test]
+fn double_admin_failure() {
+   unsafe {
+      magic::override_reset_state();
+      magic::issue_override_code(1);
+      magic::issue_override_code(1);
+      assert!(magic::poll_physical_override_admin_session() == (0 as *const c_void));
+      assert!(magic::poll_override_error() == 1);
+   }
+}