Add some test from doctest and rustfmt

Author: dingelish

sgx/gbdt-sgx-test/app/build.rs

@@ -28,12 +28,9 @@
 
 use std::env;
 
-fn main () {
-
-    let sdk_dir = env::var("SGX_SDK")
-                    .unwrap_or_else(|_| "/opt/intel/sgxsdk".to_string());
-    let is_sim = env::var("SGX_MODE")
-                    .unwrap_or_else(|_| "HW".to_string());
+fn main() {
+    let sdk_dir = env::var("SGX_SDK").unwrap_or_else(|_| "/opt/intel/sgxsdk".to_string());
+    let is_sim = env::var("SGX_MODE").unwrap_or_else(|_| "HW".to_string());
 
     println!("cargo:rustc-link-search=native=../lib");
     println!("cargo:rustc-link-lib=static=Enclave_u");
@@ -42,6 +39,6 @@ fn main () {
     match is_sim.as_ref() {
         "SW" => println!("cargo:rustc-link-lib=dylib=sgx_urts_sim"),
         "HW" => println!("cargo:rustc-link-lib=dylib=sgx_urts"),
-        _    => println!("cargo:rustc-link-lib=dylib=sgx_urts"), // Treat undefined as HW
+        _ => println!("cargo:rustc-link-lib=dylib=sgx_urts"), // Treat undefined as HW
     }
 }

sgx/gbdt-sgx-test/app/src/main.rs

@@ -26,26 +26,29 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+extern crate dirs;
 extern crate sgx_types;
 extern crate sgx_urts;
-extern crate dirs;
 use sgx_types::*;
 use sgx_urts::SgxEnclave;
 
-use std::io::{Read, Write};
 use std::fs;
+use std::io::{Read, Write};
 use std::path;
 
 static ENCLAVE_FILE: &'static str = "enclave.signed.so";
 static ENCLAVE_TOKEN: &'static str = "enclave.token";
 
-extern {
-    fn say_something(eid: sgx_enclave_id_t, retval: *mut sgx_status_t,
-                     some_string: *const u8, len: usize) -> sgx_status_t;
+extern "C" {
+    fn say_something(
+        eid: sgx_enclave_id_t,
+        retval: *mut sgx_status_t,
+        some_string: *const u8,
+        len: usize,
+    ) -> sgx_status_t;
 }
 
 fn init_enclave() -> SgxResult<SgxEnclave> {
-
     let mut launch_token: sgx_launch_token_t = [0; 1024];
     let mut launch_token_updated: i32 = 0;
     // Step 1: try to retrieve the launch token saved by last transaction
@@ -58,7 +61,7 @@ fn init_enclave() -> SgxResult<SgxEnclave> {
             println!("[+] Home dir is {}", path.display());
             home_dir = path;
             true
-        },
+        }
         None => {
             println!("[-] Cannot get home dir");
             false
@@ -69,14 +72,17 @@ fn init_enclave() -> SgxResult<SgxEnclave> {
     if use_token == true {
         match fs::File::open(&token_file) {
             Err(_) => {
-                println!("[-] Open token file {} error! Will create one.", token_file.as_path().to_str().unwrap());
-            },
+                println!(
+                    "[-] Open token file {} error! Will create one.",
+                    token_file.as_path().to_str().unwrap()
+                );
+            }
             Ok(mut f) => {
                 println!("[+] Open token file success! ");
                 match f.read(&mut launch_token) {
                     Ok(1024) => {
                         println!("[+] Token file valid!");
-                    },
+                    }
                     _ => println!("[+] Token file invalid, will create new token file"),
                 }
             }
@@ -86,58 +92,62 @@ fn init_enclave() -> SgxResult<SgxEnclave> {
     // Step 2: call sgx_create_enclave to initialize an enclave instance
     // Debug Support: set 2nd parameter to 1
     let debug = 1;
-    let mut misc_attr = sgx_misc_attribute_t {secs_attr: sgx_attributes_t { flags:0, xfrm:0}, misc_select:0};
-    let enclave = try!(SgxEnclave::create(ENCLAVE_FILE,
-                                          debug,
-                                          &mut launch_token,
-                                          &mut launch_token_updated,
-                                          &mut misc_attr));
+    let mut misc_attr = sgx_misc_attribute_t {
+        secs_attr: sgx_attributes_t { flags: 0, xfrm: 0 },
+        misc_select: 0,
+    };
+    let enclave = try!(SgxEnclave::create(
+        ENCLAVE_FILE,
+        debug,
+        &mut launch_token,
+        &mut launch_token_updated,
+        &mut misc_attr
+    ));
 
     // Step 3: save the launch token if it is updated
     if use_token == true && launch_token_updated != 0 {
         // reopen the file with write capablity
         match fs::File::create(&token_file) {
-            Ok(mut f) => {
-                match f.write_all(&launch_token) {
-                    Ok(()) => println!("[+] Saved updated launch token!"),
-                    Err(_) => println!("[-] Failed to save updated launch token!"),
-                }
+            Ok(mut f) => match f.write_all(&launch_token) {
+                Ok(()) => println!("[+] Saved updated launch token!"),
+                Err(_) => println!("[-] Failed to save updated launch token!"),
             },
             Err(_) => {
                 println!("[-] Failed to save updated enclave token, but doesn't matter");
-            },
+            }
         }
     }
 
     Ok(enclave)
 }
 
 fn main() {
-
     let enclave = match init_enclave() {
         Ok(r) => {
             println!("[+] Init Enclave Successful {}!", r.geteid());
             r
-        },
+        }
         Err(x) => {
             println!("[-] Init Enclave Failed {}!", x.as_str());
             return;
-        },
+        }
     };
 
     let input_string = String::from("This is a normal world string passed into Enclave!\n");
 
     let mut retval = sgx_status_t::SGX_SUCCESS;
 
     let result = unsafe {
-        say_something(enclave.geteid(),
-                      &mut retval,
-                      input_string.as_ptr() as * const u8,
-                      input_string.len())
+        say_something(
+            enclave.geteid(),
+            &mut retval,
+            input_string.as_ptr() as *const u8,
+            input_string.len(),
+        )
     };
 
     match result {
-        sgx_status_t::SGX_SUCCESS => {},
+        sgx_status_t::SGX_SUCCESS => {}
         _ => {
             println!("[-] ECALL Enclave Failed {}!", result.as_str());
             return;

sgx/gbdt-sgx-test/enclave/src/lib.rs

@@ -28,7 +28,6 @@
 
 #![crate_name = "gbdtenclave"]
 #![crate_type = "staticlib"]
-
 #![cfg_attr(not(target_env = "sgx"), no_std)]
 #![cfg_attr(target_env = "sgx", feature(rustc_private))]
 
@@ -38,30 +37,29 @@ extern crate sgx_types;
 extern crate sgx_tstd as std;
 extern crate sgx_tunittest;
 
+use sgx_tunittest::*;
 use sgx_types::*;
-use std::string::String;
-use std::vec::Vec;
 use std::io::{self, Write};
 use std::slice;
-use sgx_tunittest::*;
+use std::string::String;
+use std::vec::Vec;
 
 extern crate gbdt_sgx;
 
-mod test_lib;
 mod test_agaricus_lepiota;
+mod test_lib;
 
 #[no_mangle]
 pub extern "C" fn say_something(some_string: *const u8, some_len: usize) -> sgx_status_t {
-
     let str_slice = unsafe { slice::from_raw_parts(some_string, some_len) };
     let _ = io::stdout().write(str_slice);
 
     // A sample &'static string
     let rust_raw_string = "This is a in-Enclave ";
     // An array
-    let word:[u8;4] = [82, 117, 115, 116];
+    let word: [u8; 4] = [82, 117, 115, 116];
     // An vector
-    let word_vec:Vec<u8> = vec![32, 115, 116, 114, 105, 110, 103, 33];
+    let word_vec: Vec<u8> = vec![32, 115, 116, 114, 105, 110, 103, 33];
 
     // Construct a string from &'static string
     let mut hello_string = String::from(rust_raw_string);
@@ -72,21 +70,21 @@ pub extern "C" fn say_something(some_string: *const u8, some_len: usize) -> sgx_
     }
 
     // Rust style convertion
-    hello_string += String::from_utf8(word_vec).expect("Invalid UTF-8")
-                                               .as_str();
+    hello_string += String::from_utf8(word_vec).expect("Invalid UTF-8").as_str();
 
     // Ocall to normal world for output
     println!("{}", &hello_string);
 
-test_agaricus_lepiota::test_main();
+    test_agaricus_lepiota::test_main();
 
     rsgx_unit_tests!(
-test_lib::walk_tree,
-test_lib::decision_tree,
-test_lib::build_decision_tree,
-test_lib::config_express,
-test_lib::loss_type,
-test_lib::fitness);
+        test_lib::walk_tree,
+        test_lib::decision_tree,
+        test_lib::build_decision_tree,
+        test_lib::config_express,
+        test_lib::loss_type,
+        test_lib::fitness
+    );
 
     sgx_status_t::SGX_SUCCESS
 }

sgx/gbdt-sgx-test/enclave/src/test_lib.rs

@@ -154,8 +154,7 @@ pub fn fitness() {
     });
 
     use gbdt_sgx::fitness::{
-        almost_equal, average, label_average, same, weighted_label_median,
-        weighted_residual_median,
+        almost_equal, average, label_average, same, weighted_label_median, weighted_residual_median,
     };
     assert_eq!(true, almost_equal(0.1, 0.100000000001));
     assert_eq!(false, same(&dv, dv.len()));