// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License..

use sgx_rand::*;

// pub use os::SgxRng
pub fn test_rand_os_sgxrng() {
    let mut os_rng = os::SgxRng::new().unwrap();
    let mut checksum_u32: u32 = 0;
    let mut checksum_u64: u64 = 0;
    let testcount = 1000;
    for _ in 0..testcount {
        checksum_u32 |= os_rng.next_u32();
        checksum_u64 |= os_rng.next_u64();
    }
    assert_ne!(checksum_u32, 0);
    assert_ne!(checksum_u64, 0);

    let mut rand_arr = [0; 1000];
    os_rng.fill_bytes(&mut rand_arr[..]);
    let cmp = [0; 1000].iter().zip(rand_arr.iter()).all(|(x, y)| x == y);
    assert_ne!(cmp, true);
}

// pub mod distribution
// Too hard to test
pub fn test_rand_distributions() {
    use sgx_rand::distributions::Range;
    use sgx_rand::distributions::*;
    use sgx_rand::*;

    // From rust-src/librand/distributions/rand.rs
    should_panic!(Range::new(10, 10));
    should_panic!(Range::new(10, 5));
    let mut rng = thread_rng();
    macro_rules! t {
        ($($ty:ident),*) => {{
            $(
               let v: &[($ty, $ty)] = &[(0, 10),
                                        (10, 127),
                                        ($ty::min_value(), $ty::MAX)];
               for &(low, high) in v {
                    let mut sampler: Range<$ty> = Range::new(low, high);
                    for _ in 0..1000 {
                        let v = sampler.sample(&mut rng);
                        assert!(low <= v && v < high);
                        let v = sampler.ind_sample(&mut rng);
                        assert!(low <= v && v < high);
                    }
                }
             )*
        }}
    }
    t!(i8, i16, i32, i64, isize, u8, u16, u32, u64, usize);

    macro_rules! t {
        ($($ty:ty),*) => {{
            $(
               let v: &[($ty, $ty)] = &[(0.0, 100.0),
                                        (-1e35, -1e25),
                                        (1e-35, 1e-25),
                                        (-1e35, 1e35)];
               for &(low, high) in v {
                    let mut sampler: Range<$ty> = Range::new(low, high);
                    for _ in 0..1000 {
                        let v = sampler.sample(&mut rng);
                        assert!(low <= v && v < high);
                        let v = sampler.ind_sample(&mut rng);
                        assert!(low <= v && v < high);
                    }
                }
             )*
        }}
    }

    t!(f32, f64);

    let mut exp = Exp::new(10.0);
    for _ in 0..1000 {
        assert!(exp.sample(&mut rng) >= 0.0);
        assert!(exp.ind_sample(&mut rng) >= 0.0);
    }

    should_panic!(Exp::new(0.0));
    should_panic!(Exp::new(-10.0));

    // gamma.rs
    use sgx_rand::distributions::{ChiSquared, FisherF, StudentT};
    let mut rng = thread_rng();
    let mut chi = ChiSquared::new(1.0);
    for _ in 0..1000 {
        chi.sample(&mut rng);
        chi.ind_sample(&mut rng);
    }

    let mut chi = ChiSquared::new(0.5);
    for _ in 0..1000 {
        chi.sample(&mut rng);
        chi.ind_sample(&mut rng);
    }

    let mut chi = ChiSquared::new(30.0);
    for _ in 0..1000 {
        chi.sample(&mut rng);
        chi.ind_sample(&mut rng);
    }

    should_panic!(ChiSquared::new(-1.0));
    let mut rng = StdRng::new().unwrap();
    let mut f = FisherF::new(2.0, 32.0);
    for _ in 0..1000 {
        f.sample(&mut rng);
        f.ind_sample(&mut rng);
    }

    let mut t = StudentT::new(11.0);
    for _ in 0..1000 {
        t.sample(&mut rng);
        t.ind_sample(&mut rng);
    }

    // normal.rs
    use sgx_rand::distributions::{LogNormal, Normal};

    let mut norm = Normal::new(10.0, 10.0);
    for _ in 0..1000 {
        norm.sample(&mut rng);
        norm.ind_sample(&mut rng);
    }

    should_panic!(Normal::new(10.0, -1.0));

    let mut lnorm = LogNormal::new(10.0, 10.0);
    for _ in 0..1000 {
        lnorm.sample(&mut rng);
        lnorm.ind_sample(&mut rng);
    }

    should_panic!(LogNormal::new(10.0, -1.0));

    use sgx_rand::distributions::{
        IndependentSample, RandSample, Sample, Weighted, WeightedChoice,
    };

    #[derive(PartialEq, Debug)]
    struct ConstRand(usize);
    impl Rand for ConstRand {
        fn rand<R: Rng>(_: &mut R) -> ConstRand {
            ConstRand(0)
        }
    }

    // 0, 1, 2, 3, ...
    struct CountingRng {
        i: u32,
    }
    impl Rng for CountingRng {
        fn next_u32(&mut self) -> u32 {
            self.i += 1;
            self.i - 1
        }
        fn next_u64(&mut self) -> u64 {
            self.next_u32() as u64
        }
    }

    let mut rand_sample = RandSample::<ConstRand>::new();

    assert_eq!(rand_sample.sample(&mut rng), ConstRand(0));
    assert_eq!(rand_sample.ind_sample(&mut rng), ConstRand(0));

    macro_rules! t {
        ($items:expr, $expected:expr) => {{
            let mut items = $items;
            let wc = WeightedChoice::new(&mut items);
            let expected = $expected;

            let mut rng = CountingRng { i: 0 };

            for &val in &expected {
                assert_eq!(wc.ind_sample(&mut rng), val)
            }
        }};
    }

    t!(
        vec![Weighted {
            weight: 1,
            item: 10
        }],
        [10]
    );

    // skip some
    t!(
        vec![
            Weighted {
                weight: 0,
                item: 20
            },
            Weighted {
                weight: 2,
                item: 21
            },
            Weighted {
                weight: 0,
                item: 22
            },
            Weighted {
                weight: 1,
                item: 23
            }
        ],
        [21, 21, 23]
    );

    // different weights
    t!(
        vec![
            Weighted {
                weight: 4,
                item: 30
            },
            Weighted {
                weight: 3,
                item: 31
            }
        ],
        [30, 30, 30, 30, 31, 31, 31]
    );

    // check that we're binary searching
    // correctly with some vectors of odd
    // length.
    t!(
        vec![
            Weighted {
                weight: 1,
                item: 40
            },
            Weighted {
                weight: 1,
                item: 41
            },
            Weighted {
                weight: 1,
                item: 42
            },
            Weighted {
                weight: 1,
                item: 43
            },
            Weighted {
                weight: 1,
                item: 44
            }
        ],
        [40, 41, 42, 43, 44]
    );
    t!(
        vec![
            Weighted {
                weight: 1,
                item: 50
            },
            Weighted {
                weight: 1,
                item: 51
            },
            Weighted {
                weight: 1,
                item: 52
            },
            Weighted {
                weight: 1,
                item: 53
            },
            Weighted {
                weight: 1,
                item: 54
            },
            Weighted {
                weight: 1,
                item: 55
            },
            Weighted {
                weight: 1,
                item: 56
            }
        ],
        [50, 51, 52, 53, 54, 55, 56]
    );

    should_panic!(WeightedChoice::<isize>::new(&mut []));

    should_panic!({
        let mut t = [
            Weighted { weight: 0, item: 0 },
            Weighted { weight: 0, item: 1 },
        ];
        WeightedChoice::new(&mut t);
    });

    let x = (!0) as u32 / 2; // x + x + 2 is the overflow
    should_panic!({
        WeightedChoice::new(&mut [
            Weighted { weight: x, item: 0 },
            Weighted { weight: 1, item: 1 },
            Weighted { weight: x, item: 2 },
            Weighted { weight: 1, item: 3 },
        ]);
    });
}

// pub use isaac::{IsaacRng, Isaac64Rng};
// We cannot test because methods are private
pub fn test_rand_isaac_isaacrng() {
    let mut unseeded_32 = IsaacRng::new_unseeded();
    let mut u32_arr = [0; 32];
    for i in 0..32 {
        u32_arr[i] = unseeded_32.next_u32();
    }
    assert_eq!(
        u32_arr,
        [
            1909923794, 3041581799, 3564668249, 3277924858, 568073897, 1018722762, 3627754367,
            4198294973, 2365883657, 3626931337, 3678742600, 3391154246, 1343199022, 250607936,
            14072211, 3155345791, 3971560663, 4015545006, 1861263481, 249057481, 1397017464,
            4117866301, 1748577758, 2418980344, 2932544972, 3384981086, 3677243665, 3631899496,
            1984325203, 1082540525, 1970086400, 1634359601
        ]
    );

    let mut unseeded_64 = Isaac64Rng::new_unseeded();
    let mut u64_arr = [0; 32];
    for i in 0..32 {
        u64_arr[i] = unseeded_64.next_u64();
    }
    assert_eq!(
        u64_arr,
        [
            17761629189777429372,
            9558052838949843840,
            18366607087662878139,
            5554737638101975254,
            9657764456686032042,
            1042790411024899657,
            18326046843346171767,
            6155338025429880858,
            604674934004978847,
            15021509919615502100,
            3524189203627442317,
            3491674822202243807,
            2812011890713530556,
            6197411209201204330,
            3423587972865533405,
            13333204927595598570,
            8278113110980066893,
            16728828598150967100,
            4739548913818718572,
            12247507049266305179,
            13400017821939308292,
            14607632686415099658,
            9600795998696455796,
            5780363980783644600,
            4671476687197924946,
            1273203271378292130,
            11668772324252115302,
            5778980740914384907,
            3192360781399669869,
            8925632526356214095,
            13227689911971237637,
            16127447699671226298
        ]
    );

    unseeded_32.reseed(&[1, 2, 3, 4]);
    for i in 0..32 {
        u32_arr[i] = unseeded_32.next_u32();
    }
    assert_eq!(
        u32_arr,
        [
            3673720382, 1957022519, 2949967219, 2273082436, 2412264859, 1616913581, 4286187434,
            1337573575, 3564981768, 3931377724, 180676801, 4234301014, 3123903540, 804531392,
            1687941800, 3180870208, 3007460037, 1643580469, 1601966685, 385631690, 3412228283,
            2633128738, 2786818767, 1385157572, 3925804522, 4251266711, 4219473709, 3054074232,
            4185095632, 2891236088, 1792921516, 1421268925
        ]
    );

    unseeded_64.reseed(&[5, 6, 7, 8]);
    for i in 0..32 {
        u64_arr[i] = unseeded_64.next_u64();
    }
    assert_eq!(
        u64_arr,
        [
            1519553293257924390,
            8496251504967724708,
            4814852879883820893,
            701662672566014897,
            4253212733272379994,
            14710390856535061408,
            13525913188857210438,
            4176812646507392158,
            5274347845703478634,
            7494101755291139543,
            12433257569627749800,
            13555030297923086622,
            12912035290107031759,
            10277213319518338357,
            13212221592643678736,
            14214333261821823450,
            13451082182892489478,
            17471061581144953786,
            663937856451252907,
            7794799705525010541,
            8878465633657608553,
            11684451817656999723,
            3085412699425654134,
            7996244368322668557,
            9264264892592899720,
            18202308129527220178,
            14762563311397316905,
            7967643698755143779,
            13033364966409644229,
            2619244012980533217,
            2251084057656619285,
            16661636750341142669
        ]
    );

    let mut from_seed_obj = IsaacRng::from_seed(&[1, 2, 3, 4]);
    for i in 0..32 {
        u32_arr[i] = from_seed_obj.next_u32();
    }
    assert_eq!(
        u32_arr,
        [
            3673720382, 1957022519, 2949967219, 2273082436, 2412264859, 1616913581, 4286187434,
            1337573575, 3564981768, 3931377724, 180676801, 4234301014, 3123903540, 804531392,
            1687941800, 3180870208, 3007460037, 1643580469, 1601966685, 385631690, 3412228283,
            2633128738, 2786818767, 1385157572, 3925804522, 4251266711, 4219473709, 3054074232,
            4185095632, 2891236088, 1792921516, 1421268925
        ]
    );

    let mut from_seed_obj_64 = Isaac64Rng::from_seed(&[5, 6, 7, 8]);
    for i in 0..32 {
        u64_arr[i] = from_seed_obj_64.next_u64();
    }
    assert_eq!(
        u64_arr,
        [
            1519553293257924390,
            8496251504967724708,
            4814852879883820893,
            701662672566014897,
            4253212733272379994,
            14710390856535061408,
            13525913188857210438,
            4176812646507392158,
            5274347845703478634,
            7494101755291139543,
            12433257569627749800,
            13555030297923086622,
            12912035290107031759,
            10277213319518338357,
            13212221592643678736,
            14214333261821823450,
            13451082182892489478,
            17471061581144953786,
            663937856451252907,
            7794799705525010541,
            8878465633657608553,
            11684451817656999723,
            3085412699425654134,
            7996244368322668557,
            9264264892592899720,
            18202308129527220178,
            14762563311397316905,
            7967643698755143779,
            13033364966409644229,
            2619244012980533217,
            2251084057656619285,
            16661636750341142669
        ]
    );

    let mut isaac_rand = IsaacRng::rand(&mut unseeded_32);
    for i in 0..32 {
        u32_arr[i] = isaac_rand.next_u32();
    }
    assert_eq!(
        u32_arr,
        [
            3731735955, 1060971802, 2060608277, 2017700212, 2906693947, 983683489, 2442131015,
            1804959108, 133350985, 1854001588, 1536802647, 1681331746, 3926133099, 2418741330,
            2933560360, 3445159402, 372862460, 584055518, 3889338902, 2010948997, 156911533,
            1516660418, 2985909906, 2363648761, 3441715164, 1549975272, 1594543237, 4051120660,
            4197709030, 3816779293, 3783690383, 2208018815
        ]
    );

    let mut isaac_rand64 = Isaac64Rng::rand(&mut unseeded_64);
    for i in 0..32 {
        u64_arr[i] = isaac_rand64.next_u64();
    }
    assert_eq!(
        u64_arr,
        [
            9641310933002597978,
            1377462969700517843,
            505161414013526504,
            15945732720326764686,
            15418802195980990528,
            16470443181580299993,
            2257820220688421011,
            11605056212052353438,
            16446934715429265221,
            2703881146695451334,
            13779048927678904385,
            3096257807787648519,
            8078370161234145075,
            11428361090362647425,
            11163353455881119221,
            2479568798082945555,
            12997537085833811642,
            15719812629115354877,
            11384722140468426949,
            1034436110230828879,
            13933827272989341125,
            16841927942905074390,
            18283030736011842727,
            18161628412401034420,
            5992070539860306822,
            14657980260306047343,
            4240530741486241664,
            16128750684074755458,
            13382816331913570910,
            1450784801074240917,
            12172859719381448420,
            11561024719408488519
        ]
    );
}

// pub use chacha::ChaChaRng;
pub fn test_rand_chacharng() {
    let mut chacha_obj = ChaChaRng::new_unseeded();
    let mut arr_32 = [0; 32];
    let mut arr_64 = [0; 32];
    for i in 0..32 {
        arr_32[i] = chacha_obj.next_u32();
        arr_64[i] = chacha_obj.next_u64();
    }
    assert_eq!(
        arr_32,
        [
            2917185654, 683509331, 3438229160, 2370328401, 4105716586, 2254827186, 2090318488,
            1768285000, 1981921065, 3577337972, 520806828, 3781961315, 2576249230, 1572053161,
            4248444456, 3230977993, 1486888979, 180343358, 882336707, 772637944, 4294454303,
            2115397425, 3755235835, 720939292, 261668430, 2229903491, 3478228973, 1178947740,
            3612365086, 3675722242, 2702218887, 562719562
        ]
    );
    assert_eq!(
        arr_64,
        [
            10393729188386987328,
            13265865887038934432,
            14343251829215281626,
            4602718913620007096,
            2062956584559347651,
            13755971968358175061,
            939050496938282955,
            4491151038014484018,
            4850067409370051029,
            2891290281678408273,
            8020199878315477293,
            635428310198806553,
            14295220693338866608,
            7509513789169826591,
            2214742853367878259,
            7093718481497530944,
            7734567148921168085,
            2355867238271518203,
            11858361224218268717,
            1394059717204795920,
            6203934356551920360,
            8397145010625398571,
            12762635603290365669,
            15798090700413956747,
            14488165283315532822,
            14534818617999799127,
            5587461883115671776,
            438217751243844519,
            12085977715001316377,
            14462731156256673612,
            5957300949303581564,
            9621633472041422470
        ]
    );

    let mut chacha_obj = ChaChaRng::new_unseeded();
    chacha_obj.set_counter(0, 1234567890u64);
    for i in 0..32 {
        arr_32[i] = chacha_obj.next_u32();
        arr_64[i] = chacha_obj.next_u64();
    }
    assert_eq!(
        arr_32,
        [
            3689073239, 2242961698, 417536494, 1503493075, 2585895478, 1865454281, 2938464816,
            3998462791, 1427673087, 2023308892, 3934458784, 2154405649, 4261926467, 944974180,
            1017947150, 1858486886, 2081637745, 6698551, 2593531725, 989113434, 952425310,
            2821646029, 2012236296, 2466857171, 1705021287, 2712374590, 2467996873, 2529275143,
            3691921567, 4164253542, 88339832, 3139246687
        ]
    );
    assert_eq!(
        arr_64,
        [
            5208214742801571470,
            12560379081283373091,
            16366572874613089836,
            5810973028396244379,
            5062530146601697561,
            217785109116347749,
            10945155018052356834,
            3830068552016855006,
            8631305173908678621,
            2826768761480962968,
            10354302052483333752,
            14791155778847304997,
            9236871951464247547,
            10565693803420516117,
            2303174007018927082,
            11829861525625440339,
            17157070760956407958,
            18121029959197227032,
            15895614391418239344,
            16692872359552745709,
            364895533855401959,
            15289680275263377042,
            14444259489219757497,
            6497689978530420464,
            7473989280813969277,
            3566235157971589227,
            5502428546971923888,
            15258817180873710847,
            1169964352668698116,
            5863926115043645599,
            15610749783507155661,
            5502704700771473503
        ]
    );

    chacha_obj.reseed(&[1, 2, 3, 4]);
    for i in 0..32 {
        arr_32[i] = chacha_obj.next_u32();
    }
    assert_eq!(
        arr_32,
        [
            3931434082, 34647919, 2091071039, 2892552082, 3564830854, 314912736, 3076587290,
            3191577189, 2464328121, 2779997206, 4263592728, 2125004658, 1054360779, 3051661270,
            3060579487, 3656634963, 1388834776, 581640397, 1637469323, 1640397641, 2995955648,
            4048658223, 1600465837, 1968152875, 1014202063, 3686500314, 3021394822, 2541451384,
            2305439270, 1469542314, 3487304956, 2286598508
        ]
    );

    let mut chacha_obj = ChaChaRng::from_seed(&[5, 6, 7, 8]);
    for i in 0..32 {
        arr_32[i] = chacha_obj.next_u32();
    }
    assert_eq!(
        arr_32,
        [
            337897705, 1044901876, 2470587838, 3671677287, 1941090964, 2010394378, 3290836538,
            1347698920, 2248500576, 2681774419, 1002813011, 65452860, 1850555370, 3036027713,
            2306938851, 3450488430, 2195520755, 38533316, 692482625, 3410200303, 1052930979,
            4087429478, 2501438173, 2495319620, 277097193, 1034107694, 2396644634, 3334027496,
            3808708279, 3705622889, 874306690, 1237186790
        ]
    );

    let mut chacha_obj = ChaChaRng::rand(&mut chacha_obj);
    for i in 0..32 {
        arr_32[i] = chacha_obj.next_u32();
    }
    assert_eq!(
        arr_32,
        [
            1225539984, 2122523891, 4046438709, 2772996924, 2441149875, 4253841608, 2837944766,
            1256279550, 134014938, 192621923, 4187133245, 45039689, 3455715024, 3744176230,
            3194372814, 3469543760, 1107844861, 3990938641, 4095630261, 3461287666, 321560749,
            934078781, 2671586377, 1048877492, 1523056052, 3373403085, 913407943, 2835509350,
            3232974874, 3910156243, 3652032104, 442368320
        ]
    );
}

// reseeding.rs
pub fn test_rand_reseeding() {
    use std::prelude::v1::*;

    use sgx_rand::reseeding::{ReseedWithDefault, ReseedingRng};

    struct Counter {
        i: u32,
    }

    impl Rng for Counter {
        fn next_u32(&mut self) -> u32 {
            self.i += 1;
            // very random
            self.i - 1
        }
    }
    impl Default for Counter {
        /// Constructs a `Counter` with initial value zero.
        fn default() -> Counter {
            Counter { i: 0 }
        }
    }
    impl SeedableRng<u32> for Counter {
        fn reseed(&mut self, seed: u32) {
            self.i = seed;
        }
        fn from_seed(seed: u32) -> Counter {
            Counter { i: seed }
        }
    }
    type MyRng = ReseedingRng<Counter, ReseedWithDefault>;

    let mut rs = ReseedingRng::new(Counter { i: 0 }, 400, ReseedWithDefault);

    let mut i = 0;
    for _ in 0..1000 {
        assert_eq!(rs.next_u32(), i % 100);
        i += 1;
    }

    let mut ra: MyRng = SeedableRng::from_seed((ReseedWithDefault, 2));
    let mut rb: MyRng = SeedableRng::from_seed((ReseedWithDefault, 2));
    assert!(ra
        .gen_ascii_chars()
        .take(100)
        .eq(rb.gen_ascii_chars().take(100)));

    let mut r: MyRng = SeedableRng::from_seed((ReseedWithDefault, 3));
    let string1: String = r.gen_ascii_chars().take(100).collect();

    r.reseed((ReseedWithDefault, 3));

    let string2: String = r.gen_ascii_chars().take(100).collect();
    assert_eq!(string1, string2);

    const FILL_BYTES_V_LEN: usize = 13579;

    let mut v = vec![0; FILL_BYTES_V_LEN];
    let mut rng = StdRng::new().unwrap();
    rng.fill_bytes(&mut v);

    // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
    // recursed.
    assert_eq!(v.len(), FILL_BYTES_V_LEN);

    // To test that `fill_bytes` actually did something, check that the
    // average of `v` is not 0.
    let mut sum = 0.0;
    for &x in &v {
        sum += x as f64;
    }
    assert!(sum / v.len() as f64 != 0.0);
}

// No need for testing others
// Already included in the above tests