#[cfg(test)]
mod tests {
    use super::sort_desc;

    fn do_test(number: u64, expected: u64) {
        let actual = sort_desc(number);
        assert_eq!(actual, expected, "For {} expected {} but got {}", number, expected, actual);
    }
    
    #[test]
    fn test_sort_desc() {
        do_test(0, 0);
        do_test(1, 1);
        do_test(12, 21);
        do_test(123, 321);
        do_test(12345, 54321);
        do_test(123456789, 987654321);
        do_test(1234567890, 9876543210);
    }

    #[test]
    fn random_test() {
        fn solution(number: u64) -> u64 {
            let mut number = number.to_string().chars().map(|c| c.to_digit(10).unwrap() as u64).collect::<Vec<u64>>();
            number.sort();
            number.iter().rev().map(|c| c.to_string()).collect::<Vec<String>>().join("").parse::<u64>().unwrap()
        }
        
        for _ in 0..100 {
            let number = rand::random::<u32>();
            do_test(number as u64, solution(number as u64));
        }
    }
}

#[cfg(test)]
mod tests {
    use super::disemvowel;
    use rand::Rng;

    fn do_test(string: &str, expected: &str) {
        assert_eq!(disemvowel(string), expected);
    }

#[test]
fn test() {
    do_test("HI GUYS", "H GYS");
    do_test("AEIOU", "");
    do_test("Shrek is an orge", "Shrk s n rg");
}

#[test]
fn random_tests() {
    for _ in 0..100 {
        let string = (0..rand::thread_rng().gen_range(0..20))
            .map(|_| rand::Rng::sample(&mut rand::thread_rng(), rand::distributions::Alphanumeric) as char)
            .collect::<String>();
        let expected = string.chars().filter(|&c| !"AEIOUaeiou".contains(c)).collect::<String>();
        do_test(&string, &expected);
    }
    }    
}

#[cfg(test)]
mod test {
    use super::make_move;
    fn do_test(init: (i32, i32), sequence: &str, expected: (i32, i32)) {
        assert_eq!(make_move(init, sequence), expected);
    }

    #[test]
    fn simple_test() {
        do_test((0, 0), "ttrbrrbllrt", (2, 1));
        do_test((4, 1), "bllbrt", (3, 0));
        do_test((-2, 4), "trlbb", (-2, 3));
        do_test((5, 5), "trlbrb", (6, 4));
    }
    #[test]
    fn random_test() {
        use rand::Rng;
        use std::iter;
        fn generate(len: usize) -> String {
            const CHARSET: &[u8] = b"lrbt";
            let mut rng = rand::thread_rng();
            let one_char = || CHARSET[rng.gen_range(0..CHARSET.len())] as char;
            iter::repeat_with(one_char).take(len).collect()
        }
        fn solution(init: (i32, i32), sequence: &str) -> (i32, i32) {
            sequence.chars().fold(init, |(x, y), c| {
                (
                    x + match c {
                        'r' => 1,
                        'l' => -1,
                        _ => 0,
                    },
                    y + match c {
                        't' => 1,
                        'b' => -1,
                        _ => 0,
                    },
                )
            })
        }

        for _ in 0..100 {
            let init = (
                rand::thread_rng().gen_range(-100..100),
                rand::thread_rng().gen_range(-100..100),
            );
            let sequence = generate(rand::thread_rng().gen_range(0..100));
            let expected = solution(init, &sequence);
            do_test(init, &sequence, expected);
        }
    }
}

#[cfg(test)]
mod tests {
    use rand::distributions::{Alphanumeric, Distribution};
    use rand::Rng;
    use std::collections::BTreeSet;

    use super::is_unique;

    fn do_test(input: &str, expected: bool) {
        let actual = is_unique(input);
        assert_eq!(actual, expected, "failed for input: \"{}\"", input);
    }

    #[test]
    fn test_unique() {
        do_test("abcdef", true);
        do_test("Aabcdef", true);
        do_test("gino", true);
        do_test("glhf", true);
    }

    #[test]
    fn test_repeated() {
        do_test("aabcdef", false);
        do_test("gg", false);
        do_test("phillip", false);
    }

    #[test]
    fn test_empty() {
        do_test("", true);
    }
    
    #[test]
    fn random_test() {
        for _ in 0..100 {
        let length: usize = rand::thread_rng().gen_range(0..10);
        let input: String = Alphanumeric
            .sample_iter(&mut rand::thread_rng())
            .take(length)
            .map(char::from)
            .collect();
        let expected = input.chars().collect::<BTreeSet<_>>().len() == input.len();

        do_test(&input, expected);
    }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    fn dotest(route: Vec<&str>, departure_time: &str, expected: &str) {
        let actual = arrival_time(route.clone(), departure_time);
        println!(
            "route: {:?}, departure_time: {:?}, expected: {:?}, actual: {:?}",
            route, departure_time, expected, actual
        );
        assert!(
            actual == expected,
            "route: {:?}, departure_time: {:?}, expected: {:?}, actual: {:?}",
            route,
            departure_time,
            expected,
            actual
        );
    }

    #[test]
    fn single_destination_test() {
        dotest(vec!["Crystalium"], "10:00", "12:15");
        dotest(vec!["Skyport"], "22:00", "23:00");
    }

    #[test]
    fn multiple_destination_test() {
        dotest(vec!["Nexus", "Nexus"], "20:15", "01:30");
        dotest(vec!["Crystalium", "Skyport", "Oasis"], "10:00", "17:45");
        dotest(vec!["Nexus", "Skyport", "Oasis"], "21:30", "09:15");
    }

    #[test]
    fn empty_route_test() {
        dotest(vec![], "10:00", "The Train Driver has the day off");
    }

    #[test]
    fn overtime_test() {
        dotest(vec!["Crystalium", "Nexus"], "23:50", "08:30");
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rand::Rng;

    fn dotest(n: u64, exp: u64) -> () {
        assert_eq!(print(n), exp, "{}", format!("{} should return {} ", n, exp));
    }
    #[test]
    fn simple_test() {
        dotest(4, 4);
        dotest(12, 21);
        dotest(101, 110);
        dotest(400000005000007000, 754000000000000000);
        dotest(307778062924466824, 988777666444322200);
}   

    #[test]
    fn random_test() {
        let mut rng = rand::thread_rng();
        for _ in 0..10 {
            let n = rng.gen_range(1..100000);
            let exp = print(n);
            dotest(n, exp);
        }
    }   
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn test_sum() {
        assert_eq!(sum(&[1, 2, 3]), 6);
    }
    #[test]
    fn test_empty_sum() {
        assert_eq!(sum(&[]), 0);
    }

    }

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_even_numbers_in_array() {
        let v = &[-567, 2, 100, -34, 1000, 99, 101, -1000, 200, 7, -100];
        let r = v.iter().fold(0, |count, &num| count + (num & 1 == 0) as usize);
        assert_eq!(calculate_even_numbers(v), r);
    }

    #[test]
    fn test_empty_array() {
        assert_eq!(calculate_even_numbers(&[]), 0);
    }

    #[test]
    fn test_no_even_numbers() {
        let v = &[5, 7, 9, 1, 21, 33, 77, 57, 33, 91, 111, 23451];
        assert_eq!(calculate_even_numbers(v), 0);
    }

    #[test]
    fn test_multiple_even_numbers() {
        let v = &[60, 180, 99, 100, 101, 103];
        assert_eq!(calculate_even_numbers(v), 3);
    }

    #[test]
    fn test_large_numbers() {
        let v = &[10_000_000, 90_000, 700_000_000, 2, 70, 44];
        assert_eq!(calculate_even_numbers(v), 6);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(hello_world(true), "Hello, World");
        assert_eq!(hello_world(false), "Goodbye, World");
    }
}