Remove unused rust file
This commit is contained in:
Alex Crichton
parent
7c4745061a
commit
5a444d58f2
311
src/qc.rs
311
src/qc.rs
|
|
@ -1,311 +0,0 @@
|
||||||
// When testing functions, QuickCheck (QC) uses small values for integer (`u*`/`i*`) arguments
|
|
||||||
// (~ `[-100, 100]`), but these values don't stress all the code paths in our intrinsics. Here we
|
|
||||||
// create newtypes over the primitive integer types with the goal of having full control over the
|
|
||||||
// random values that will be used to test our intrinsics.
|
|
||||||
|
|
||||||
use std::boxed::Box;
|
|
||||||
use std::fmt;
|
|
||||||
use core::{f32, f64};
|
|
||||||
|
|
||||||
use quickcheck::{Arbitrary, Gen};
|
|
||||||
|
|
||||||
use int::LargeInt;
|
|
||||||
use float::Float;
|
|
||||||
|
|
||||||
// Generates values in the full range of the integer type
|
|
||||||
macro_rules! arbitrary {
|
|
||||||
($TY:ident : $ty:ident) => {
|
|
||||||
#[derive(Clone, Copy, PartialEq)]
|
|
||||||
pub struct $TY(pub $ty);
|
|
||||||
|
|
||||||
impl Arbitrary for $TY {
|
|
||||||
fn arbitrary<G>(g: &mut G) -> $TY
|
|
||||||
where G: Gen
|
|
||||||
{
|
|
||||||
// NOTE Generate edge cases with a 10% chance
|
|
||||||
let t = if g.gen_weighted_bool(10) {
|
|
||||||
*g.choose(&[
|
|
||||||
$ty::min_value(),
|
|
||||||
0,
|
|
||||||
$ty::max_value(),
|
|
||||||
]).unwrap()
|
|
||||||
} else {
|
|
||||||
g.gen()
|
|
||||||
};
|
|
||||||
|
|
||||||
$TY(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn shrink(&self) -> Box<Iterator<Item=$TY>> {
|
|
||||||
struct Shrinker {
|
|
||||||
x: $ty,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Iterator for Shrinker {
|
|
||||||
type Item = $TY;
|
|
||||||
|
|
||||||
fn next(&mut self) -> Option<$TY> {
|
|
||||||
self.x /= 2;
|
|
||||||
if self.x == 0 {
|
|
||||||
None
|
|
||||||
} else {
|
|
||||||
Some($TY(self.x))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if self.0 == 0 {
|
|
||||||
::quickcheck::empty_shrinker()
|
|
||||||
} else {
|
|
||||||
Box::new(Shrinker { x: self.0 })
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Debug for $TY {
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
||||||
fmt::Debug::fmt(&self.0, f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
arbitrary!(I32: i32);
|
|
||||||
arbitrary!(U32: u32);
|
|
||||||
|
|
||||||
// These integers are "too large". If we generate e.g. `u64` values in the full range then there's
|
|
||||||
// only `1 / 2^32` chance of seeing a value smaller than `2^32` (i.e. whose higher "word" (32-bits)
|
|
||||||
// is `0`)! But this is an important group of values to tests because we have special code paths for
|
|
||||||
// them. Instead we'll generate e.g. `u64` integers this way: uniformly pick between (a) setting the
|
|
||||||
// low word to 0 and generating a random high word, (b) vice versa: high word to 0 and random low
|
|
||||||
// word or (c) generate both words randomly. This let's cover better the code paths in our
|
|
||||||
// intrinsics.
|
|
||||||
macro_rules! arbitrary_large {
|
|
||||||
($TY:ident : $ty:ident) => {
|
|
||||||
#[derive(Clone, Copy, PartialEq)]
|
|
||||||
pub struct $TY(pub $ty);
|
|
||||||
|
|
||||||
impl Arbitrary for $TY {
|
|
||||||
fn arbitrary<G>(g: &mut G) -> $TY
|
|
||||||
where G: Gen
|
|
||||||
{
|
|
||||||
// NOTE Generate edge cases with a 10% chance
|
|
||||||
let t = if g.gen_weighted_bool(10) {
|
|
||||||
*g.choose(&[
|
|
||||||
$ty::min_value(),
|
|
||||||
0,
|
|
||||||
$ty::max_value(),
|
|
||||||
]).unwrap()
|
|
||||||
} else {
|
|
||||||
match g.gen_range(0, 3) {
|
|
||||||
0 => $ty::from_parts(g.gen(), g.gen()),
|
|
||||||
1 => $ty::from_parts(0, g.gen()),
|
|
||||||
2 => $ty::from_parts(g.gen(), 0),
|
|
||||||
_ => unreachable!(),
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
$TY(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn shrink(&self) -> Box<Iterator<Item=$TY>> {
|
|
||||||
struct Shrinker {
|
|
||||||
x: $ty,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Iterator for Shrinker {
|
|
||||||
type Item = $TY;
|
|
||||||
|
|
||||||
fn next(&mut self) -> Option<$TY> {
|
|
||||||
self.x /= 2;
|
|
||||||
if self.x == 0 {
|
|
||||||
None
|
|
||||||
} else {
|
|
||||||
Some($TY(self.x))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if self.0 == 0 {
|
|
||||||
::quickcheck::empty_shrinker()
|
|
||||||
} else {
|
|
||||||
Box::new(Shrinker { x: self.0 })
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Debug for $TY {
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
||||||
fmt::Debug::fmt(&self.0, f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
arbitrary_large!(I64: i64);
|
|
||||||
arbitrary_large!(U64: u64);
|
|
||||||
arbitrary_large!(I128: i128);
|
|
||||||
arbitrary_large!(U128: u128);
|
|
||||||
|
|
||||||
macro_rules! arbitrary_float {
|
|
||||||
($TY:ident : $ty:ident) => {
|
|
||||||
#[derive(Clone, Copy)]
|
|
||||||
pub struct $TY(pub $ty);
|
|
||||||
|
|
||||||
impl Arbitrary for $TY {
|
|
||||||
fn arbitrary<G>(g: &mut G) -> $TY
|
|
||||||
where G: Gen
|
|
||||||
{
|
|
||||||
let special = [
|
|
||||||
-0.0, 0.0, $ty::NAN, $ty::INFINITY, -$ty::INFINITY
|
|
||||||
];
|
|
||||||
|
|
||||||
if g.gen_weighted_bool(10) { // Random special case
|
|
||||||
$TY(*g.choose(&special).unwrap())
|
|
||||||
} else if g.gen_weighted_bool(10) { // NaN variants
|
|
||||||
let sign: bool = g.gen();
|
|
||||||
let exponent: <$ty as Float>::Int = g.gen();
|
|
||||||
let significand: <$ty as Float>::Int = 0;
|
|
||||||
$TY($ty::from_parts(sign, exponent, significand))
|
|
||||||
} else if g.gen() { // Denormalized
|
|
||||||
let sign: bool = g.gen();
|
|
||||||
let exponent: <$ty as Float>::Int = 0;
|
|
||||||
let significand: <$ty as Float>::Int = g.gen();
|
|
||||||
$TY($ty::from_parts(sign, exponent, significand))
|
|
||||||
} else { // Random anything
|
|
||||||
let sign: bool = g.gen();
|
|
||||||
let exponent: <$ty as Float>::Int = g.gen();
|
|
||||||
let significand: <$ty as Float>::Int = g.gen();
|
|
||||||
$TY($ty::from_parts(sign, exponent, significand))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn shrink(&self) -> Box<Iterator<Item=$TY>> {
|
|
||||||
::quickcheck::empty_shrinker()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Debug for $TY {
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
||||||
fmt::Debug::fmt(&self.0, f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialEq for $TY {
|
|
||||||
fn eq(&self, other: &$TY) -> bool {
|
|
||||||
self.0.eq_repr(other.0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
arbitrary_float!(F32: f32);
|
|
||||||
arbitrary_float!(F64: f64);
|
|
||||||
|
|
||||||
// Convenience macro to test intrinsics against their reference implementations.
|
|
||||||
//
|
|
||||||
// Each intrinsic is tested against both the `gcc_s` library as well as
|
|
||||||
// `compiler-rt`. These libraries are defined in the `gcc_s` crate as well as
|
|
||||||
// the `compiler-rt` crate in this repository. Both load a dynamic library and
|
|
||||||
// lookup symbols through that dynamic library to ensure that we're using the
|
|
||||||
// right intrinsic.
|
|
||||||
//
|
|
||||||
// This macro hopefully allows you to define a bare minimum of how to test an
|
|
||||||
// intrinsic without worrying about these implementation details. A sample
|
|
||||||
// invocation looks like:
|
|
||||||
//
|
|
||||||
//
|
|
||||||
// check! {
|
|
||||||
// // First argument is the function we're testing (either from this lib
|
|
||||||
// // or a dynamically loaded one. Further arguments are all generated by
|
|
||||||
// // quickcheck.
|
|
||||||
// fn __my_intrinsic(f: extern fn(i32) -> i32,
|
|
||||||
// a: I32)
|
|
||||||
// -> Option<(i32, i64)> {
|
|
||||||
//
|
|
||||||
// // Discard tests by returning Some
|
|
||||||
// if a.0 == 0 {
|
|
||||||
// return None
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// // Return the result via `Some` if the test can run
|
|
||||||
// let mut other_result = 0;
|
|
||||||
// let result = f(a.0, &mut other_result);
|
|
||||||
// Some((result, other_result))
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// If anything returns `None` then the test is discarded, otherwise the two
|
|
||||||
// results are compared for equality and the test fails if this equality check
|
|
||||||
// fails.
|
|
||||||
macro_rules! check {
|
|
||||||
($(
|
|
||||||
$(#[$cfg:meta])*
|
|
||||||
fn $name:ident($f:ident: extern $abi:tt fn($($farg:ty),*) -> $fret:ty,
|
|
||||||
$($arg:ident: $t:ty),*)
|
|
||||||
-> Option<$ret:ty>
|
|
||||||
{
|
|
||||||
$($code:tt)*
|
|
||||||
}
|
|
||||||
)*) => (
|
|
||||||
$(
|
|
||||||
$(#[$cfg])*
|
|
||||||
fn $name($f: extern $abi fn($($farg),*) -> $fret,
|
|
||||||
$($arg: $t),*) -> Option<$ret> {
|
|
||||||
$($code)*
|
|
||||||
}
|
|
||||||
)*
|
|
||||||
|
|
||||||
mod _test {
|
|
||||||
use qc::*;
|
|
||||||
use std::mem;
|
|
||||||
use quickcheck::TestResult;
|
|
||||||
|
|
||||||
$(
|
|
||||||
$(#[$cfg])*
|
|
||||||
#[test]
|
|
||||||
fn $name() {
|
|
||||||
fn my_check($($arg:$t),*) -> TestResult {
|
|
||||||
let my_answer = super::$name(super::super::$name,
|
|
||||||
$($arg),*);
|
|
||||||
let compiler_rt_fn = ::compiler_rt::get(stringify!($name));
|
|
||||||
let compiler_rt_answer = unsafe {
|
|
||||||
super::$name(mem::transmute(compiler_rt_fn),
|
|
||||||
$($arg),*)
|
|
||||||
};
|
|
||||||
let gcc_s_answer =
|
|
||||||
match ::gcc_s::get(stringify!($name)) {
|
|
||||||
Some(f) => unsafe {
|
|
||||||
Some(super::$name(mem::transmute(f),
|
|
||||||
$($arg),*))
|
|
||||||
},
|
|
||||||
None => None,
|
|
||||||
};
|
|
||||||
|
|
||||||
let print_values = || {
|
|
||||||
print!("{} - Args: ", stringify!($name));
|
|
||||||
$(print!("{:?} ", $arg);)*
|
|
||||||
print!("\n");
|
|
||||||
println!(" compiler-builtins: {:?}", my_answer);
|
|
||||||
println!(" compiler_rt: {:?}", compiler_rt_answer);
|
|
||||||
println!(" gcc_s: {:?}", gcc_s_answer);
|
|
||||||
};
|
|
||||||
|
|
||||||
if my_answer != compiler_rt_answer {
|
|
||||||
print_values();
|
|
||||||
TestResult::from_bool(false)
|
|
||||||
} else if gcc_s_answer.is_some() &&
|
|
||||||
my_answer != gcc_s_answer.unwrap() {
|
|
||||||
print_values();
|
|
||||||
TestResult::from_bool(false)
|
|
||||||
} else {
|
|
||||||
TestResult::from_bool(true)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
::quickcheck::quickcheck(my_check as fn($($t),*) -> TestResult)
|
|
||||||
}
|
|
||||||
)*
|
|
||||||
}
|
|
||||||
)
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue