Remove unused rust file

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)
-                }
-            )*
-        }
-    )
-}