-#![feature(rustc_private)]
+#![feature(rustc_private, custom_attribute)]
+#![allow(unused_attributes)]
extern crate miri;
extern crate rustc;
}
}
+#[miri_run]
fn main() {
let args: Vec<String> = std::env::args().collect();
rustc_driver::run_compiler(&args, &mut MiriCompilerCalls);
--- /dev/null
+#![feature(custom_attribute)]
+#![allow(dead_code, unused_attributes)]
+
+// error-pattern:can't handle intrinsic: discriminant_value
+
+#[miri_run]
+fn main() {
+ assert_eq!(None::<i32>, None);
+}
--- /dev/null
+#![feature(custom_attribute)]
+#![allow(dead_code, unused_attributes)]
+
+// error-pattern:can't handle intrinsic: size_of_val
+
+#[miri_run]
+fn memcmp() {
+ assert_eq!("", "");
+}
+
+fn main() {}
--- /dev/null
+#![feature(custom_attribute)]
+#![allow(dead_code, unused_attributes)]
+
+// error-pattern:assertion failed
+
+#[miri_run]
+fn slice() -> u8 {
+ let arr: &[_] = &[101, 102, 103, 104, 105, 106];
+ arr[5]
+}
+
+fn main() {}
fn compile_test() {
run_mode("compile-fail");
run_mode("run-pass");
+ run_mode("run-fail");
}
--- /dev/null
+// error-pattern:no mir for DefId
+
+use std::env;
+use std::process::{Command, Output};
+
+fn run_miri(file: &str, sysroot: &str) -> Output {
+ let path = env::current_dir().unwrap();
+ let libpath = path.join("target").join("debug");
+ let libpath = libpath.to_str().unwrap();
+ let libpath2 = path.join("target").join("debug").join("deps");
+ let libpath2 = libpath2.to_str().unwrap();
+ Command::new("cargo")
+ .args(&[
+ "run", "--",
+ "--sysroot", sysroot,
+ "-L", libpath,
+ "-L", libpath2,
+ file
+ ])
+ .output()
+ .unwrap_or_else(|e| panic!("failed to execute process: {}", e))
+}
+
+fn main() {
+ let sysroot = env::var("RUST_SYSROOT").expect("env variable `RUST_SYSROOT` not set");
+ let test_run = run_miri("src/bin/miri.rs", &sysroot);
+
+ if test_run.status.code().unwrap_or(-1) != 0 {
+ println!("{}", String::from_utf8(test_run.stdout).unwrap());
+ panic!("{}", String::from_utf8(test_run.stderr).unwrap());
+ }
+}
[]
}
+#[miri_run]
+fn mini_array() -> [u16; 1] {
+ [42]
+}
+
#[miri_run]
fn big_array() -> [u16; 5] {
[5, 4, 3, 2, 1]
[42; 8]
}
-fn main() {}
+#[miri_run]
+fn main() {
+ //assert_eq!(empty_array(), []);
+ assert_eq!(index_unsafe(), 20);
+ assert_eq!(index(), 20);
+ /*
+ assert_eq!(big_array(), [5, 4, 3, 2, 1]);
+ assert_eq!(array_array(), [[5, 4], [3, 2], [1, 0]]);
+ assert_eq!(array_repeat(), [42; 8]);
+ */
+}
}
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert!(boolean());
+ assert_eq!(if_false(), 0);
+ assert_eq!(if_true(), 1);
+ assert_eq!(match_bool(), 1);
+}
}
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert!(unsafe_match());
+}
::std::mem::size_of::<Option<i32>>()
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(call(), 2);
+ assert_eq!(factorial_recursive(), 3628800);
+ //assert_eq!(call_generic(), (42, true));
+ assert_eq!(cross_crate_fn_call(), 1);
+ //assert_eq!(test_size_of(), 8);
+}
// y
// }
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(simple(), 12);
+}
box (1, 2)
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(*make_box(), (1, 2));
+ assert_eq!(*make_box_syntax(), (1, 2));
+}
}
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(ret(), 1);
+ assert_eq!(neg(), -1);
+ assert_eq!(add(), 3);
+ assert_eq!(indirect_add(), 3);
+ assert_eq!(arith(), 5*5);
+ assert_eq!(match_int(), 20);
+ assert_eq!(match_int_range(), 4);
+}
sum
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(factorial_loop(), 3628800);
+ assert_eq!(index_for_loop(), 60);
+ assert_eq!(for_loop(), 60);
+}
&*b as *const i32
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(one_line_ref(), 1);
+ assert_eq!(basic_ref(), 1);
+ assert_eq!(basic_ref_mut(), 3);
+ assert_eq!(basic_ref_mut_var(), 3);
+ assert_eq!(tuple_ref_mut(), (10, 22));
+ assert_eq!(match_ref_mut(), 42);
+ // FIXME: improve this test... how?
+ assert!(dangling_pointer() != std::ptr::null());
+}
(1, 2, 3, 4, 5)
}
+#[derive(Debug, PartialEq)]
struct Pair { x: i8, y: i8 }
#[miri_run]
(p.x, p.y)
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(tuple(), (1,));
+ assert_eq!(tuple_2(), (1, 2));
+ assert_eq!(tuple_5(), (1, 2, 3, 4, 5));
+ assert_eq!(pair(), Pair { x: 10, y: 20} );
+ assert_eq!(field_access(), (15, 20));
+}
(i32::is_unit(), <()>::is_unit())
}
-fn main() {}
+fn main() {
+ assert_eq!(specialization(), (false, true));
+}
assert_eq!(1, 1);
}
-fn main() {}
+#[miri_run]
+fn main() {
+ //let x = rc_reference_cycle().0;
+ //assert!(x.borrow().is_some());
+ assert_eq!(*arc(), 42);
+ assert_eq!(rc_cell().get(), 84);
+}
#![feature(custom_attribute)]
#![allow(dead_code, unused_attributes)]
+#[derive(Debug, PartialEq)]
enum Unit { Unit }
#[miri_run]
Unit::Unit
}
+#[derive(Debug, PartialEq)]
enum MyBool { False, True }
#[miri_run]
(None, None)
}
-fn main() {}
+#[miri_run]
+fn main() {
+ //assert_eq!(two_nones(), (None, None));
+ assert_eq!(match_opt_some(), 13);
+ assert_eq!(match_opt_none(), 42);
+ //assert_eq!(return_some(), Some(42));
+ //assert_eq!(return_none(), None);
+ //assert_eq!(return_false(), MyBool::False);
+ //assert_eq!(return_true(), MyBool::True);
+ //assert_eq!(return_unit(), Unit::Unit);
+}
v
}
-fn main() {}
+#[miri_run]
+fn main() {
+ assert_eq!(vec_reallocate().len(), 5);
+ assert_eq!(vec_into_iter(), 30);
+ assert_eq!(make_vec().capacity(), 4);
+}
projects / rust.git / commitdiff