test/tensor: add several compile tests for SharedTensor API

Implementation of SharedTensor uses `unsafe` to extend lifetime of memory
references that are returned by read/write family of methods. Those tests
verify that attempts to create dangling pointers or otherwise misuse API
fail at compile time.

Cargo.toml

@@ -22,6 +22,7 @@ num = "0.1"
 lazy_static = "0.1.15"
 
 clippy = { version = "0.0.27", optional = true }
+compiletest_rs = { version = "0.1", optional = true }
 
 [dev-dependencies]
 rand = "0.3"
@@ -35,7 +36,7 @@ opencl = []
 unstable_alloc = [] # faster but unstable memory allocation on native machines
 
 dev = []
-unstable = [] # for travis-cargo
+unstable = ["compiletest_rs"] # for travis-cargo
 travis = ["native"]
 lint = ["clippy"]
 

tests/compile-fail/drop_live_memory.rs

@@ -0,0 +1,13 @@
+extern crate collenchyma;
+use collenchyma::prelude::*;
+
+fn main() {
+    let ntv = Native::new();
+    let dev = ntv.new_device(ntv.hardwares()).unwrap();
+
+    let x = &mut SharedTensor::<f32>::new(&10).unwrap();
+    let m = x.write_only(&dev).unwrap();
+    x.drop_device(&dev);
+    //~^ ERROR error: cannot borrow `*x` as mutable more than once at a time
+}
+

tests/compile-fail/leak_read_reference.rs

@@ -0,0 +1,16 @@
+extern crate collenchyma;
+use collenchyma::prelude::*;
+
+fn main() {
+    let ntv = Native::new();
+    let dev = ntv.new_device(ntv.hardwares()).unwrap();
+
+    let mem = {
+        let x = &mut SharedTensor::<f32>::new(&10).unwrap();
+        //~^ ERROR error: borrowed value does not live long enough
+        x.write_only(&dev).unwrap();
+        let m = x.read(&dev).unwrap();
+        m
+    };
+}
+

tests/compile-fail/leak_write_reference.rs

@@ -0,0 +1,15 @@
+extern crate collenchyma;
+use collenchyma::prelude::*;
+
+fn main() {
+    let ntv = Native::new();
+    let dev = ntv.new_device(ntv.hardwares()).unwrap();
+
+    let mem = {
+        let x = &mut SharedTensor::<f32>::new(&10).unwrap();
+        //~^ ERROR error: borrowed value does not live long enough
+        let m = x.write_only(&dev).unwrap();
+        m
+    };
+}
+

tests/compile-fail/read_write_borrows.rs

@@ -0,0 +1,13 @@
+extern crate collenchyma;
+use collenchyma::prelude::*;
+
+fn main() {
+    let ntv = Native::new();
+    let dev = ntv.new_device(ntv.hardwares()).unwrap();
+
+    let x = &mut SharedTensor::<f32>::new(&10).unwrap();
+    let m1 = x.write_only(&dev).unwrap();
+    let m2 = x.read(&dev).unwrap();
+    //~^ ERROR cannot borrow `*x` as immutable because it is also borrowed as mutable
+}
+

tests/compile-fail/two_write_borrows.rs

@@ -0,0 +1,13 @@
+extern crate collenchyma;
+use collenchyma::prelude::*;
+
+fn main() {
+    let ntv = Native::new();
+    let dev = ntv.new_device(ntv.hardwares()).unwrap();
+
+    let x = &mut SharedTensor::<f32>::new(&10).unwrap();
+    let m1 = x.write_only(&dev).unwrap();
+    let m2 = x.write_only(&dev).unwrap();
+    //~^ ERROR error: cannot borrow `*x` as mutable more than once at a time
+}
+

tests/compiletests.rs

@@ -0,0 +1,22 @@
+#![cfg(feature = "compiletest_rs")]
+extern crate compiletest_rs as compiletest;
+
+use std::path::PathBuf;
+
+fn run_mode(mode: &'static str) {
+    let mut config = compiletest::default_config();
+    let cfg_mode = mode.parse().ok().expect("Invalid mode");
+
+    config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/"
+                                    .to_owned());
+    config.mode = cfg_mode;
+    config.src_base = PathBuf::from(format!("tests/{}", mode));
+
+    compiletest::run_tests(&config);
+}
+
+#[test]
+fn compile_test() {
+    run_mode("compile-fail");
+    run_mode("run-pass");
+}

tests/run-pass/multiple_read_only_borrows.rs

@@ -0,0 +1,15 @@
+extern crate collenchyma;
+use collenchyma::prelude::*;
+
+fn main() {
+    let ntv = Native::new();
+    let dev = ntv.new_device(ntv.hardwares()).unwrap();
+
+    let x = &mut SharedTensor::<f32>::new(&10).unwrap();
+    x.write_only(&dev).unwrap();
+
+    let m1 = x.read(&dev);
+    let m2 = x.read(&dev);
+    let m3 = x.read(&dev);
+}
+