stdrandom 0.3.0-alpha.5

use super::*;
use std::collections::HashSet;

#[test]
fn test_u64_random_numbers_are_distinct() {
    let mut numbers = HashSet::new();

    for _ in 0..5 {
        let num = random_u64();
        numbers.insert(num);
    }

    // If all numbers are distinct, the HashSet should contain 5 elements
    assert_eq!(numbers.len(), 5, "Generated numbers are not unique!");
}

#[test]
fn test_u64_random_numbers_are_distinct_st() {
    let mut numbers = HashSet::new();

    for _ in 0..5 {
        let num = fast_u64();
        numbers.insert(num);
    }

    // If all numbers are distinct, the HashSet should contain 5 elements
    assert_eq!(numbers.len(), 5, "Generated numbers are not unique!");
}

#[test]
fn test_random_numbers_are_distinct_u32() {
    let mut numbers = HashSet::new();

    for _ in 0..5 {
        let num = random_u32();
        numbers.insert(num);
    }

    // If all numbers are distinct, the HashSet should contain 5 elements
    assert_eq!(numbers.len(), 5, "Generated numbers are not unique!");
}

#[test]
fn test_random_numbers_are_distinct_st_u32() {
    let mut numbers = HashSet::new();

    for _ in 0..5 {
        let num = fast_u32();
        numbers.insert(num);
    }

    // If all numbers are distinct, the HashSet should contain 5 elements
    assert_eq!(numbers.len(), 5, "Generated numbers are not unique!");
}

#[test]
fn test_fill_bytes_with_randomness() {
    let mut buffer = [0u8; 32]; // Initialize a zeroed-out buffer of 32 bytes
    fill_bytes(&mut buffer, fast_u64);

    // Ensure buffer is filled with non-zero values
    assert!(
        buffer.iter().any(|&byte| byte != 0),
        "Buffer should contain non-zero random bytes"
    );
}

/**
   Ensure multiple calls produce different outputs (not perfect randomness check)
*/
#[test]
fn test_fill_bytes_different() {
    let mut buffer = [0u8; 32];
    fill_bytes(&mut buffer, fast_u64);

    let mut buffer2 = [0u8; 32];
    fill_bytes(&mut buffer2, fast_u64);
    assert_ne!(
        buffer, buffer2,
        "Two buffers should contain different random values"
    );
}

#[test]
fn test_fill_numbers_with_randomness() {
    let mut buffer = [0f32; 32]; // Initialize a zeroed-out buffer of 32 bytes
    fill_numbers(&mut buffer, fast_f32);

    // Ensure buffer is filled with non-zero values
    assert!(
        buffer.iter().any(|&num| num != 0f32),
        "Buffer should contain non-zero random bytes"
    );
}

#[test]
fn test_fast_u128_returns_different_values() {
    let first = fast_u128();
    let second = fast_u128();

    assert_ne!(first, second, "Two calls fast_u128() should return different numbers.");

    // Few more iterations to be sure
    for _ in 0..200 {
        let next = fast_u128();
        assert_ne!(first, next, "Next call fast_u128() should be different from the first one.");
        assert_ne!(second, next, "Next call fast_u128() should be different from the second one.");
    }
}

#[test]
fn test_fast_usize_returns_value_within_usize_range() {
   for _ in 0..200 {
      let random_value: u128 = fast_usize() as u128;
      assert!(random_value <= usize::MAX as u128, "Values should be in usize range.");
   }
}

#[test]
fn test_multiple_calls_to_fast_usize_return_different_values() {
    let first = fast_usize();
    let second = fast_usize();
    // Nemuzeme zarucit odlisnost, ale s vysokou pravdepodobnosti by mely byt ruzne.
    // Testujeme spise na "moznost" ruznosti.
    if first != second {
        assert!(true);
    } else {
        // Provedeme jeste nekolik pokusu, abychom zvysili sanci na odlisnost.
        let mut different_found = false;
        for _ in 0..200 {
            if fast_usize() != first || fast_usize() != second {
                different_found = true;
                break;
            }
        }
        assert!(different_found, "Opakovane volani fast_usize by mela s vysokou pravdepodobnosti vracet ruzne hodnoty.");
    }
}

#[test]
fn test_fast_i128_is_non_negative() {
    for _ in 0..100 {
        let value = fast_i128();
        assert!(value >= 0, "Generated fast_i128 value should be non-negative, but got {}", value);
    }
}

#[test]
fn test_fast_isize_returns_non_negative_value_within_isize_max() {
    for _ in 0..200 {
        let random_value: i128 = fast_isize() as i128;
        assert!(random_value >= 0, "Should not be negative.");
        assert!(random_value <= isize::MAX as i128, "Value should not be greater than isize::MAX.");
    }
}

#[test]
fn test_random_i128_returns_non_negative() {
   for _ in 0..200 {
      let random_value = random_i128();
      assert!(random_value >= 0, "Should not return negative number.");
   }
}