#![feature(i128_type, i128)] extern crate cast; extern crate rand; use std::collections::HashMap; use std::fmt::Write as FmtWrite; use std::fs::{self, OpenOptions}; use std::io::Write; use std::hash::{Hash, Hasher}; use std::path::PathBuf; use std::{env, mem}; use std::fmt; use self::cast::{f32, f64, u32, u64, u128, i32, i64, i128}; use self::rand::Rng; const NTESTS: usize = 1_000; fn main() { let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap()); let out_file = out_dir.join("generated.rs"); drop(fs::remove_file(&out_file)); let target = env::var("TARGET").unwrap(); let target_arch_arm = target.contains("arm") || target.contains("thumb"); let target_arch_mips = target.contains("mips"); // TODO accept NaNs. We don't do that right now because we can't check // for NaN-ness on the thumb targets (due to missing intrinsics) // float/add.rs gen(|(a, b): (MyF64, MyF64)| { let c = a.0 + b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::add::__adddf3(a, b)"); gen(|(a, b): (MyF32, MyF32)| { let c = a.0 + b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::add::__addsf3(a, b)"); // float/cmp.rs gen(|(a, b): (MyF64, MyF64)| { let (a, b) = (a.0, b.0); if a.is_nan() || b.is_nan() { return None; } if a.is_nan() || b.is_nan() { Some(-1) } else if a < b { Some(-1) } else if a > b { Some(1) } else { Some(0) } }, "compiler_builtins::float::cmp::__gedf2(a, b)"); gen(|(a, b): (MyF32, MyF32)| { let (a, b) = (a.0, b.0); if a.is_nan() || b.is_nan() { return None; } if a.is_nan() || b.is_nan() { Some(-1) } else if a < b { Some(-1) } else if a > b { Some(1) } else { Some(0) } }, "compiler_builtins::float::cmp::__gesf2(a, b)"); gen(|(a, b): (MyF64, MyF64)| { let (a, b) = (a.0, b.0); if a.is_nan() || b.is_nan() { return None; } if a.is_nan() || b.is_nan() { Some(1) } else if a < b { Some(-1) } else if a > b { Some(1) } else { Some(0) } }, "compiler_builtins::float::cmp::__ledf2(a, b)"); gen(|(a, b): (MyF32, MyF32)| { let (a, b) = (a.0, b.0); if a.is_nan() || b.is_nan() { return None; } if a.is_nan() || b.is_nan() { Some(1) } else if a < b { Some(-1) } else if a > b { Some(1) } else { Some(0) } }, "compiler_builtins::float::cmp::__lesf2(a, b)"); if target_arch_arm { gen(|(a, b): (MyF32, MyF32)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 <= b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_fcmple(a, b)"); gen(|(a, b): (MyF32, MyF32)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 >= b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_fcmpge(a, b)"); gen(|(a, b): (MyF32, MyF32)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 == b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_fcmpeq(a, b)"); gen(|(a, b): (MyF32, MyF32)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 < b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_fcmplt(a, b)"); gen(|(a, b): (MyF32, MyF32)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 > b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_fcmpgt(a, b)"); gen(|(a, b): (MyF64, MyF64)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 <= b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_dcmple(a, b)"); gen(|(a, b): (MyF64, MyF64)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 >= b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_dcmpge(a, b)"); gen(|(a, b): (MyF64, MyF64)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 == b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_dcmpeq(a, b)"); gen(|(a, b): (MyF64, MyF64)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 < b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_dcmplt(a, b)"); gen(|(a, b): (MyF64, MyF64)| { if a.0.is_nan() || b.0.is_nan() { return None; } let c = (a.0 > b.0) as i32; Some(c) }, "compiler_builtins::float::cmp::__aeabi_dcmpgt(a, b)"); } // float/conv.rs gen(|a: MyF64| i64(a.0).ok(), "compiler_builtins::float::conv::__fixdfdi(a)"); gen(|a: MyF64| i32(a.0).ok(), "compiler_builtins::float::conv::__fixdfsi(a)"); gen(|a: MyF32| i64(a.0).ok(), "compiler_builtins::float::conv::__fixsfdi(a)"); gen(|a: MyF32| i32(a.0).ok(), "compiler_builtins::float::conv::__fixsfsi(a)"); gen(|a: MyF32| i128(a.0).ok(), "compiler_builtins::float::conv::__fixsfti(a)"); gen(|a: MyF64| i128(a.0).ok(), "compiler_builtins::float::conv::__fixdfti(a)"); gen(|a: MyF64| u64(a.0).ok(), "compiler_builtins::float::conv::__fixunsdfdi(a)"); gen(|a: MyF64| u32(a.0).ok(), "compiler_builtins::float::conv::__fixunsdfsi(a)"); gen(|a: MyF32| u64(a.0).ok(), "compiler_builtins::float::conv::__fixunssfdi(a)"); gen(|a: MyF32| u32(a.0).ok(), "compiler_builtins::float::conv::__fixunssfsi(a)"); gen(|a: MyF32| u128(a.0).ok(), "compiler_builtins::float::conv::__fixunssfti(a)"); gen(|a: MyF64| u128(a.0).ok(), "compiler_builtins::float::conv::__fixunsdfti(a)"); gen(|a: MyI64| Some(f64(a.0)), "compiler_builtins::float::conv::__floatdidf(a)"); gen(|a: MyI32| Some(f64(a.0)), "compiler_builtins::float::conv::__floatsidf(a)"); gen(|a: MyI32| Some(f32(a.0)), "compiler_builtins::float::conv::__floatsisf(a)"); gen(|a: MyU64| Some(f64(a.0)), "compiler_builtins::float::conv::__floatundidf(a)"); gen(|a: MyU32| Some(f64(a.0)), "compiler_builtins::float::conv::__floatunsidf(a)"); gen(|a: MyU32| Some(f32(a.0)), "compiler_builtins::float::conv::__floatunsisf(a)"); gen(|a: MyU128| f32(a.0).ok(), "compiler_builtins::float::conv::__floatuntisf(a)"); if !target_arch_mips { gen(|a: MyI128| Some(f32(a.0)), "compiler_builtins::float::conv::__floattisf(a)"); gen(|a: MyI128| Some(f64(a.0)), "compiler_builtins::float::conv::__floattidf(a)"); gen(|a: MyU128| Some(f64(a.0)), "compiler_builtins::float::conv::__floatuntidf(a)"); } // float/pow.rs gen(|(a, b): (MyF64, MyI32)| { let c = a.0.powi(b.0); if a.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::pow::__powidf2(a, b)"); gen(|(a, b): (MyF32, MyI32)| { let c = a.0.powi(b.0); if a.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::pow::__powisf2(a, b)"); // float/sub.rs gen(|(a, b): (MyF64, MyF64)| { let c = a.0 - b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::sub::__subdf3(a, b)"); gen(|(a, b): (MyF32, MyF32)| { let c = a.0 - b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::sub::__subsf3(a, b)"); // float/mul.rs gen(|(a, b): (MyF64, MyF64)| { let c = a.0 * b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::mul::__muldf3(a, b)"); gen(|(a, b): (LargeF32, LargeF32)| { let c = a.0 * b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::mul::__mulsf3(a, b)"); if target_arch_arm { gen(|(a, b): (MyF64, MyF64)| { let c = a.0 * b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::mul::__muldf3vfp(a, b)"); gen(|(a, b): (LargeF32, LargeF32)| { let c = a.0 * b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() { None } else { Some(c) } }, "compiler_builtins::float::mul::__mulsf3vfp(a, b)"); } // float/div.rs gen(|(a, b): (MyF64, MyF64)| { if b.0 == 0.0 { return None } let c = a.0 / b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() || c.abs() <= unsafe { mem::transmute(4503599627370495u64) } { None } else { Some(c) } }, "compiler_builtins::float::div::__divdf3(a, b)"); gen(|(a, b): (LargeF32, LargeF32)| { if b.0 == 0.0 { return None } let c = a.0 / b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() || c.abs() <= unsafe { mem::transmute(16777215u32) } { None } else { Some(c) } }, "compiler_builtins::float::div::__divsf3(a, b)"); if target_arch_arm { gen(|(a, b): (MyF64, MyF64)| { if b.0 == 0.0 { return None } let c = a.0 / b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() || c.abs() <= unsafe { mem::transmute(4503599627370495u64) } { None } else { Some(c) } }, "compiler_builtins::float::div::__divdf3vfp(a, b)"); gen(|(a, b): (LargeF32, LargeF32)| { if b.0 == 0.0 { return None } let c = a.0 / b.0; if a.0.is_nan() || b.0.is_nan() || c.is_nan() || c.abs() <= unsafe { mem::transmute(16777215u32) } { None } else { Some(c) } }, "compiler_builtins::float::div::__divsf3vfp(a, b)"); } // int/addsub.rs gen(|(a, b): (MyU128, MyU128)| Some(a.0.wrapping_add(b.0)), "compiler_builtins::int::addsub::rust_u128_add(a, b)"); gen(|(a, b): (MyI128, MyI128)| Some(a.0.wrapping_add(b.0)), "compiler_builtins::int::addsub::rust_i128_add(a, b)"); gen(|(a, b): (MyU128, MyU128)| Some(a.0.overflowing_add(b.0)), "compiler_builtins::int::addsub::rust_u128_addo(a, b)"); gen(|(a, b): (MyI128, MyI128)| Some(a.0.overflowing_add(b.0)), "compiler_builtins::int::addsub::rust_i128_addo(a, b)"); gen(|(a, b): (MyU128, MyU128)| Some(a.0.wrapping_sub(b.0)), "compiler_builtins::int::addsub::rust_u128_sub(a, b)"); gen(|(a, b): (MyI128, MyI128)| Some(a.0.wrapping_sub(b.0)), "compiler_builtins::int::addsub::rust_i128_sub(a, b)"); gen(|(a, b): (MyU128, MyU128)| Some(a.0.overflowing_sub(b.0)), "compiler_builtins::int::addsub::rust_u128_subo(a, b)"); gen(|(a, b): (MyI128, MyI128)| Some(a.0.overflowing_sub(b.0)), "compiler_builtins::int::addsub::rust_i128_subo(a, b)"); // int/mul.rs gen(|(a, b): (MyU64, MyU64)| Some(a.0.wrapping_mul(b.0)), "compiler_builtins::int::mul::__muldi3(a, b)"); gen(|(a, b): (MyI64, MyI64)| Some(a.0.overflowing_mul(b.0)), "{ let mut o = 2; let c = compiler_builtins::int::mul::__mulodi4(a, b, &mut o); (c, match o { 0 => false, 1 => true, _ => panic!() }) }"); gen(|(a, b): (MyI32, MyI32)| Some(a.0.overflowing_mul(b.0)), "{ let mut o = 2; let c = compiler_builtins::int::mul::__mulosi4(a, b, &mut o); (c, match o { 0 => false, 1 => true, _ => panic!() }) }"); gen(|(a, b): (MyI128, MyI128)| Some(a.0.wrapping_mul(b.0)), "compiler_builtins::int::mul::__multi3(a, b)"); if !target_arch_mips { // FIXME(#137) gen(|(a, b): (MyI128, MyI128)| Some(a.0.overflowing_mul(b.0)), "{ let mut o = 2; let c = compiler_builtins::int::mul::__muloti4(a, b, &mut o); (c, match o { 0 => false, 1 => true, _ => panic!() }) }"); } // int/sdiv.rs gen(|(a, b): (MyI64, MyI64)| { if b.0 == 0 { None } else { Some(a.0 / b.0) } }, "compiler_builtins::int::sdiv::__divdi3(a, b)"); gen(|(a, b): (MyI64, MyI64)| { if b.0 == 0 { None } else { Some((a.0 / b.0, a.0 % b.0)) } }, "{ let mut r = 0; (compiler_builtins::int::sdiv::__divmoddi4(a, b, &mut r), r) }"); gen(|(a, b): (MyI32, MyI32)| { if b.0 == 0 { None } else { Some((a.0 / b.0, a.0 % b.0)) } }, "{ let mut r = 0; (compiler_builtins::int::sdiv::__divmodsi4(a, b, &mut r), r) }"); gen(|(a, b): (MyI32, MyI32)| { if b.0 == 0 { None } else { Some(a.0 / b.0) } }, "compiler_builtins::int::sdiv::__divsi3(a, b)"); gen(|(a, b): (MyI32, MyI32)| { if b.0 == 0 { None } else { Some(a.0 % b.0) } }, "compiler_builtins::int::sdiv::__modsi3(a, b)"); gen(|(a, b): (MyI64, MyI64)| { if b.0 == 0 { None } else { Some(a.0 % b.0) } }, "compiler_builtins::int::sdiv::__moddi3(a, b)"); if !target_arch_mips { // FIXME(#137) gen(|(a, b): (MyI128, MyI128)| { if b.0 == 0 { None } else { Some(a.0 / b.0) } }, "compiler_builtins::int::sdiv::__divti3(a, b)"); gen(|(a, b): (MyI128, MyI128)| { if b.0 == 0 { None } else { Some(a.0 % b.0) } }, "compiler_builtins::int::sdiv::__modti3(a, b)"); } // int/shift.rs gen(|(a, b): (MyU64, MyU32)| Some(a.0 << (b.0 % 64)), "compiler_builtins::int::shift::__ashldi3(a, b % 64)"); gen(|(a, b): (MyU128, MyU32)| Some(a.0 << (b.0 % 128)), "compiler_builtins::int::shift::__ashlti3(a, b % 128)"); gen(|(a, b): (MyI64, MyU32)| Some(a.0 >> (b.0 % 64)), "compiler_builtins::int::shift::__ashrdi3(a, b % 64)"); gen(|(a, b): (MyI128, MyU32)| Some(a.0 >> (b.0 % 128)), "compiler_builtins::int::shift::__ashrti3(a, b % 128)"); gen(|(a, b): (MyU64, MyU32)| Some(a.0 >> (b.0 % 64)), "compiler_builtins::int::shift::__lshrdi3(a, b % 64)"); gen(|(a, b): (MyU128, MyU32)| Some(a.0 >> (b.0 % 128)), "compiler_builtins::int::shift::__lshrti3(a, b % 128)"); // int/udiv.rs gen(|(a, b): (MyU64, MyU64)| { if b.0 == 0 { None } else { Some(a.0 / b.0) } }, "compiler_builtins::int::udiv::__udivdi3(a, b)"); gen(|(a, b): (MyU64, MyU64)| { if b.0 == 0 { None } else { Some((a.0 / b.0, a.0 % b.0)) } }, "{ let mut r = 0; (compiler_builtins::int::udiv::__udivmoddi4(a, b, Some(&mut r)), r) }"); gen(|(a, b): (MyU32, MyU32)| { if b.0 == 0 { None } else { Some((a.0 / b.0, a.0 % b.0)) } }, "{ let mut r = 0; (compiler_builtins::int::udiv::__udivmodsi4(a, b, Some(&mut r)), r) }"); gen(|(a, b): (MyU32, MyU32)| { if b.0 == 0 { None } else { Some(a.0 / b.0) } }, "compiler_builtins::int::udiv::__udivsi3(a, b)"); gen(|(a, b): (MyU32, MyU32)| { if b.0 == 0 { None } else { Some(a.0 % b.0) } }, "compiler_builtins::int::udiv::__umodsi3(a, b)"); gen(|(a, b): (MyU64, MyU64)| { if b.0 == 0 { None } else { Some(a.0 % b.0) } }, "compiler_builtins::int::udiv::__umoddi3(a, b)"); if !target_arch_mips { // FIXME(#137) gen(|(a, b): (MyU128, MyU128)| { if b.0 == 0 { None } else { Some(a.0 / b.0) } }, "compiler_builtins::int::udiv::__udivti3(a, b)"); gen(|(a, b): (MyU128, MyU128)| { if b.0 == 0 { None } else { Some(a.0 % b.0) } }, "compiler_builtins::int::udiv::__umodti3(a, b)"); gen(|(a, b): (MyU128, MyU128)| { if b.0 == 0 { None } else { Some((a.0 / b.0, a.0 % b.0)) } }, "{ let mut r = 0; (compiler_builtins::int::udiv::__udivmodti4(a, b, Some(&mut r)), r) }"); } } macro_rules! gen_float { ($name:ident, $fty:ident, $uty:ident, $bits:expr, $significand_bits:expr) => { pub fn $name(rng: &mut R) -> $fty where R: Rng, { const BITS: u8 = $bits; const SIGNIFICAND_BITS: u8 = $significand_bits; const SIGNIFICAND_MASK: $uty = (1 << SIGNIFICAND_BITS) - 1; const SIGN_MASK: $uty = (1 << (BITS - 1)); const EXPONENT_MASK: $uty = !(SIGN_MASK | SIGNIFICAND_MASK); fn mk_f32(sign: bool, exponent: $uty, significand: $uty) -> $fty { unsafe { mem::transmute(((sign as $uty) << (BITS - 1)) | ((exponent & EXPONENT_MASK) << SIGNIFICAND_BITS) | (significand & SIGNIFICAND_MASK)) } } if rng.gen_weighted_bool(10) { // Special values *rng.choose(&[-0.0, 0.0, ::std::$fty::NAN, ::std::$fty::INFINITY, -::std::$fty::INFINITY]) .unwrap() } else if rng.gen_weighted_bool(10) { // NaN patterns mk_f32(rng.gen(), rng.gen(), 0) } else if rng.gen() { // Denormalized mk_f32(rng.gen(), 0, rng.gen()) } else { // Random anything mk_f32(rng.gen(), rng.gen(), rng.gen()) } } } } gen_float!(gen_f32, f32, u32, 32, 23); gen_float!(gen_f64, f64, u64, 64, 52); macro_rules! gen_large_float { ($name:ident, $fty:ident, $uty:ident, $bits:expr, $significand_bits:expr) => { pub fn $name(rng: &mut R) -> $fty where R: Rng, { const BITS: u8 = $bits; const SIGNIFICAND_BITS: u8 = $significand_bits; const SIGNIFICAND_MASK: $uty = (1 << SIGNIFICAND_BITS) - 1; const SIGN_MASK: $uty = (1 << (BITS - 1)); const EXPONENT_MASK: $uty = !(SIGN_MASK | SIGNIFICAND_MASK); fn mk_f32(sign: bool, exponent: $uty, significand: $uty) -> $fty { unsafe { mem::transmute(((sign as $uty) << (BITS - 1)) | ((exponent & EXPONENT_MASK) << SIGNIFICAND_BITS) | (significand & SIGNIFICAND_MASK)) } } if rng.gen_weighted_bool(10) { // Special values *rng.choose(&[-0.0, 0.0, ::std::$fty::NAN, ::std::$fty::INFINITY, -::std::$fty::INFINITY]) .unwrap() } else if rng.gen_weighted_bool(10) { // NaN patterns mk_f32(rng.gen(), rng.gen(), 0) } else if rng.gen() { // Denormalized mk_f32(rng.gen(), 0, rng.gen()) } else { // Random anything rng.gen::<$fty>() } } } } gen_large_float!(gen_large_f32, f32, u32, 32, 23); gen_large_float!(gen_large_f64, f64, u64, 64, 52); trait TestInput: rand::Rand + Hash + Eq + fmt::Debug { fn ty_name() -> String; fn generate_lets(container: &str, cnt: &mut u8) -> String; fn generate_static(&self, dst: &mut String); } trait TestOutput { fn ty_name() -> String; fn generate_static(&self, dst: &mut String); fn generate_expr(container: &str) -> String; } fn gen(mut generate: F, test: &str) where F: FnMut(A) -> Option, A: TestInput + Copy, R: TestOutput, { let rng = &mut rand::thread_rng(); let testname = test.split("::") .last() .unwrap() .split("(") .next() .unwrap(); let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap()); let out_file = out_dir.join("generated.rs"); let mut testcases = HashMap::new(); let mut n = NTESTS; while n > 0 { let input: A = rng.gen(); if testcases.contains_key(&input) { continue } let output = match generate(input) { Some(o) => o, None => continue, }; testcases.insert(input, output); n -= 1; } let mut contents = String::new(); contents.push_str(&format!("mod {} {{\nuse super::*;\n", testname)); contents.push_str("#[test]\n"); contents.push_str("fn test() {\n"); contents.push_str(&format!("static TESTS: [({}, {}); {}] = [\n", A::ty_name(), R::ty_name(), NTESTS)); for (input, output) in testcases { contents.push_str(" ("); input.generate_static(&mut contents); contents.push_str(", "); output.generate_static(&mut contents); contents.push_str("),\n"); } contents.push_str("];\n"); contents.push_str(&format!(r#" for &(inputs, output) in TESTS.iter() {{ {} assert_eq!({}, {}, "inputs {{:?}}", inputs) }} "#, A::generate_lets("inputs", &mut 0), R::generate_expr("output"), test, )); contents.push_str("\n}\n"); contents.push_str("\n}\n"); OpenOptions::new() .write(true) .append(true) .create(true) .open(out_file) .unwrap() .write_all(contents.as_bytes()) .unwrap(); } macro_rules! my_float { ($(struct $name:ident($inner:ident) = $gen:ident;)*) => ($( #[derive(Debug, Clone, Copy)] struct $name($inner); impl TestInput for $name { fn ty_name() -> String { format!("u{}", &stringify!($inner)[1..]) } fn generate_lets(container: &str, cnt: &mut u8) -> String { let me = *cnt; *cnt += 1; format!("let {} = {}::from_bits({});\n", (b'a' + me) as char, stringify!($inner), container) } fn generate_static(&self, dst: &mut String) { write!(dst, "{}", self.0.to_bits()).unwrap(); } } impl rand::Rand for $name { fn rand(r: &mut R) -> $name { $name($gen(r)) } } impl Hash for $name { fn hash(&self, h: &mut H) { self.0.to_bits().hash(h) } } impl PartialEq for $name { fn eq(&self, other: &$name) -> bool { self.0.to_bits() == other.0.to_bits() } } impl Eq for $name {} )*) } my_float! { struct MyF64(f64) = gen_f64; struct LargeF64(f64) = gen_large_f64; struct MyF32(f32) = gen_f32; struct LargeF32(f32) = gen_large_f32; } macro_rules! my_integer { ($(struct $name:ident($inner:ident);)*) => ($( #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)] struct $name($inner); impl TestInput for $name { fn ty_name() -> String { stringify!($inner).to_string() } fn generate_lets(container: &str, cnt: &mut u8) -> String { let me = *cnt; *cnt += 1; format!("let {} = {};\n", (b'a' + me) as char, container) } fn generate_static(&self, dst: &mut String) { write!(dst, "{}", self.0).unwrap(); } } impl rand::Rand for $name { fn rand(rng: &mut R) -> $name { let bits = (0 as $inner).count_zeros(); let mut mk = || { if rng.gen_weighted_bool(10) { *rng.choose(&[ ::std::$inner::MAX >> (bits / 2), 0, ::std::$inner::MIN >> (bits / 2), ]).unwrap() } else { rng.gen::<$inner>() } }; let a = mk(); let b = mk(); $name((a << (bits / 2)) | (b & (!0 << (bits / 2)))) } } )*) } my_integer! { struct MyI32(i32); struct MyI64(i64); struct MyI128(i128); struct MyU32(u32); struct MyU64(u64); struct MyU128(u128); } impl TestInput for (A, B) where A: TestInput, B: TestInput, { fn ty_name() -> String { format!("({}, {})", A::ty_name(), B::ty_name()) } fn generate_lets(container: &str, cnt: &mut u8) -> String { format!("{}{}", A::generate_lets(&format!("{}.0", container), cnt), B::generate_lets(&format!("{}.1", container), cnt)) } fn generate_static(&self, dst: &mut String) { dst.push_str("("); self.0.generate_static(dst); dst.push_str(", "); self.1.generate_static(dst); dst.push_str(")"); } } impl TestOutput for f64 { fn ty_name() -> String { "u64".to_string() } fn generate_static(&self, dst: &mut String) { write!(dst, "{}", self.to_bits()).unwrap(); } fn generate_expr(container: &str) -> String { format!("f64::from_bits({})", container) } } impl TestOutput for f32 { fn ty_name() -> String { "u32".to_string() } fn generate_static(&self, dst: &mut String) { write!(dst, "{}", self.to_bits()).unwrap(); } fn generate_expr(container: &str) -> String { format!("f32::from_bits({})", container) } } macro_rules! plain_test_output { ($($i:tt)*) => ($( impl TestOutput for $i { fn ty_name() -> String { stringify!($i).to_string() } fn generate_static(&self, dst: &mut String) { write!(dst, "{}", self).unwrap(); } fn generate_expr(container: &str) -> String { container.to_string() } } )*) } plain_test_output!(i32 i64 i128 u32 u64 u128 bool); impl TestOutput for (A, B) where A: TestOutput, B: TestOutput, { fn ty_name() -> String { format!("({}, {})", A::ty_name(), B::ty_name()) } fn generate_static(&self, dst: &mut String) { dst.push_str("("); self.0.generate_static(dst); dst.push_str(", "); self.1.generate_static(dst); dst.push_str(")"); } fn generate_expr(container: &str) -> String { container.to_string() } }