product-os-random 0.0.32

//! Comprehensive API tests to ensure no breaking changes occur during refactoring.
//! These tests document and validate all public API surfaces.

use product_os_random::*;

// =============================================================================
// Phase 1.1: Core API Tests - RNG Enum and Implementations
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_rng_std_variant_creation() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    assert!(matches!(rng, RNG::Std(_)));
}

#[cfg(all(feature = "core", not(feature = "send_only")))]
#[test]
fn test_rng_thread_variant_creation() {
    use rand::thread_rng;
    let rng = RNG::Thread(thread_rng());
    assert!(matches!(rng, RNG::Thread(_)));
}

#[cfg(feature = "core")]
#[test]
fn test_rng_os_variant_creation() {
    use rand::rngs::OsRng;
    let rng = RNG::OS(OsRng);
    assert!(matches!(rng, RNG::OS(_)));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_rng_implements_rng_core() {
    use rand::SeedableRng;
    let mut rng = RNG::Std(StdRng::seed_from_u64(42));

    // Test next_u32
    let _val = rng.next_u32();

    // Test next_u64
    let _val = rng.next_u64();

    // Test fill_bytes
    let mut buf = [0u8; 10];
    rng.fill_bytes(&mut buf);

    // Test try_fill_bytes
    let mut buf2 = [0u8; 10];
    let result = rng.try_fill_bytes(&mut buf2);
    assert!(result.is_ok());
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_rng_clone() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let _cloned = rng.clone();
}

// =============================================================================
// Phase 1.1: CryptoRNG Enum Tests
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_crypto_rng_std_variant() {
    use rand::SeedableRng;
    let rng = CryptoRNG::Std(StdRng::seed_from_u64(42));
    assert!(matches!(rng, CryptoRNG::Std(_)));
}

#[cfg(feature = "core")]
#[test]
fn test_crypto_rng_os_variant() {
    use rand::rngs::OsRng;
    let rng = CryptoRNG::OS(OsRng);
    assert!(matches!(rng, CryptoRNG::OS(_)));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_crypto_rng_implements_rng_core() {
    use rand::SeedableRng;
    let mut rng = CryptoRNG::Std(StdRng::seed_from_u64(42));

    let _val = rng.next_u32();
    let _val = rng.next_u64();

    let mut buf = [0u8; 10];
    rng.fill_bytes(&mut buf);

    let mut buf2 = [0u8; 10];
    let result = rng.try_fill_bytes(&mut buf2);
    assert!(result.is_ok());
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_crypto_rng_clone() {
    use rand::SeedableRng;
    let rng = CryptoRNG::Std(StdRng::seed_from_u64(42));
    let _cloned = rng.clone();
}

// =============================================================================
// Phase 1.1: CustomRng Tests
// =============================================================================

#[cfg(feature = "custom")]
#[test]
fn test_custom_rng_creation() {
    use rand::SeedableRng;
    let seed_rng = StdRng::seed_from_u64(42);
    let custom = CustomRng::new(seed_rng);
    let _ = custom;
}

#[cfg(feature = "custom")]
#[test]
fn test_custom_rng_implements_rng_core() {
    use rand::SeedableRng;
    let seed_rng = StdRng::seed_from_u64(42);
    let mut custom = CustomRng::new(seed_rng);

    let _val = custom.next_u32();
    let _val = custom.next_u64();

    let mut buf = [0u8; 10];
    custom.fill_bytes(&mut buf);

    let mut buf2 = [0u8; 10];
    let result = custom.try_fill_bytes(&mut buf2);
    assert!(result.is_ok());
}

#[cfg(feature = "custom")]
#[test]
fn test_custom_rng_clone() {
    use rand::SeedableRng;
    let seed_rng = StdRng::seed_from_u64(42);
    let custom = CustomRng::new(seed_rng);
    let _cloned = custom.clone();
}

// =============================================================================
// Phase 1.1: CustomCryptoRng Tests
// =============================================================================

#[cfg(feature = "custom")]
#[test]
fn test_custom_crypto_rng_creation() {
    use rand::SeedableRng;

    // Create a type that implements RngCrypto
    #[derive(Clone)]
    struct TestCryptoRng(StdRng);

    impl RngCore for TestCryptoRng {
        fn next_u32(&mut self) -> u32 {
            self.0.next_u32()
        }
        fn next_u64(&mut self) -> u64 {
            self.0.next_u64()
        }
        fn fill_bytes(&mut self, dest: &mut [u8]) {
            self.0.fill_bytes(dest)
        }
        fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
            self.0.try_fill_bytes(dest)
        }
    }

    impl CryptoRng for TestCryptoRng {}
    impl RngCrypto for TestCryptoRng {}

    let seed_rng = TestCryptoRng(StdRng::seed_from_u64(42));
    let custom = CustomCryptoRng::new(seed_rng);
    let _ = custom;
}

// =============================================================================
// Phase 1.1: RandomGenerator Tests - Struct Creation
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_new_with_rng() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let gen = RandomGenerator::new(Some(rng));
    let _ = gen;
}

#[cfg(feature = "core")]
#[test]
fn test_random_generator_new_without_rng() {
    let gen = RandomGenerator::new(None);
    let _ = gen;
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_clone() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let gen = RandomGenerator::new(Some(rng));
    let _cloned = gen.clone();
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Key Generation
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_generate_simple_key_one_time() {
    let key = RandomGenerator::generate_simple_key_one_time(16);
    assert_eq!(key.len(), 16);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_generate_key_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let key = RandomGenerator::generate_key_one_time(16, &mut rng);
    assert_eq!(key.len(), 16);
}

#[cfg(feature = "core")]
#[test]
fn test_generate_key_one_time_without_rng() {
    let key = RandomGenerator::generate_key_one_time(16, &mut None::<RNG>);
    assert_eq!(key.len(), 16);
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Random Bytes
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_simple_random_bytes_one_time() {
    let bytes = RandomGenerator::get_simple_random_bytes_one_time(10);
    assert_eq!(bytes.len(), 10);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_bytes_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let bytes = RandomGenerator::get_random_bytes_one_time(10, &mut rng);
    assert_eq!(bytes.len(), 10);
}

#[cfg(feature = "core")]
#[test]
fn test_get_random_bytes_one_time_without_rng() {
    let bytes = RandomGenerator::get_random_bytes_one_time(10, &mut None::<RNG>);
    assert_eq!(bytes.len(), 10);
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Random Usize
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_simple_random_usize_one_time() {
    let val = RandomGenerator::get_simple_random_usize_one_time(1, 100);
    assert!(val >= 1 && val <= 100);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_usize_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let val = RandomGenerator::get_random_usize_one_time(1, 100, &mut rng);
    assert!(val >= 1 && val <= 100);
}

#[cfg(feature = "core")]
#[test]
fn test_get_random_usize_one_time_without_rng() {
    let val = RandomGenerator::get_random_usize_one_time(1, 100, &mut None::<RNG>);
    assert!(val >= 1 && val <= 100);
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Random String
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_simple_random_string_one_time() {
    let s = RandomGenerator::get_simple_random_string_one_time(10);
    assert_eq!(s.len(), 10);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_string_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let s = RandomGenerator::get_random_string_one_time(10, &mut rng);
    assert_eq!(s.len(), 10);
}

#[cfg(feature = "core")]
#[test]
fn test_get_random_string_one_time_without_rng() {
    let s = RandomGenerator::get_random_string_one_time(10, &mut None::<RNG>);
    assert_eq!(s.len(), 10);
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Random from Characters
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_simple_random_from_characters_one_time() {
    let s = RandomGenerator::get_simple_random_from_characters_one_time(10, "abc");
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c == 'a' || c == 'b' || c == 'c'));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_from_characters_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let s = RandomGenerator::get_random_from_characters_one_time(10, "abc", &mut rng);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c == 'a' || c == 'b' || c == 'c'));
}

#[cfg(feature = "core")]
#[test]
fn test_get_random_from_characters_one_time_without_rng() {
    let s = RandomGenerator::get_random_from_characters_one_time(10, "abc", &mut None::<RNG>);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c == 'a' || c == 'b' || c == 'c'));
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Random Alphanumeric
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_simple_random_alphanumeric_one_time() {
    let s = RandomGenerator::get_simple_random_alphanumeric_one_time(10);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c.is_alphanumeric()));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_alphanumeric_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let s = RandomGenerator::get_random_alphanumeric_one_time(10, &mut rng);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c.is_alphanumeric()));
}

#[cfg(feature = "core")]
#[test]
fn test_get_random_alphanumeric_one_time_without_rng() {
    let s = RandomGenerator::get_random_alphanumeric_one_time(10, &mut None::<RNG>);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c.is_alphanumeric()));
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Random Password
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_simple_random_password_one_time() {
    let s = RandomGenerator::get_simple_random_password_one_time(10);
    assert_eq!(s.len(), 10);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_password_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let s = RandomGenerator::get_random_password_one_time(10, &mut rng);
    assert_eq!(s.len(), 10);
}

#[cfg(feature = "core")]
#[test]
fn test_get_random_password_one_time_without_rng() {
    let s = RandomGenerator::get_random_password_one_time(10, &mut None::<RNG>);
    assert_eq!(s.len(), 10);
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Email (requires names feature)
// =============================================================================

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_simple_random_email_one_time() {
    let domains = vec!["example.com".to_string(), "test.com".to_string()];
    let email = RandomGenerator::get_simple_random_email_one_time(None, None, None, domains);
    assert!(email.contains('@'));
}

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_random_email_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let domains = vec!["example.com".to_string(), "test.com".to_string()];
    let email = RandomGenerator::get_random_email_one_time(None, None, None, domains, &mut rng);
    assert!(email.contains('@'));
}

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_random_email_one_time_without_rng() {
    let domains = vec!["example.com".to_string()];
    let email =
        RandomGenerator::get_random_email_one_time(None, None, None, domains, &mut None::<RNG>);
    assert!(email.contains('@'));
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Username (requires names feature)
// =============================================================================

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_simple_random_username_one_time() {
    let username = RandomGenerator::get_simple_random_username_one_time(None, None, None);
    assert!(!username.is_empty());
}

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_random_username_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let username = RandomGenerator::get_random_username_one_time(None, None, None, &mut rng);
    assert!(!username.is_empty());
}

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_random_username_one_time_without_rng() {
    let username =
        RandomGenerator::get_random_username_one_time(None, None, None, &mut None::<RNG>);
    assert!(!username.is_empty());
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Name (requires names feature)
// =============================================================================

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_simple_random_name_one_time() {
    let name = RandomGenerator::get_simple_random_name_one_time();
    assert!(!name.is_empty());
}

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_random_name_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let name = RandomGenerator::get_random_name_one_time(&mut rng);
    assert!(!name.is_empty());
}

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_random_name_one_time_without_rng() {
    let name = RandomGenerator::get_random_name_one_time(&mut None::<RNG>);
    assert!(!name.is_empty());
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - First Name
// =============================================================================

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_simple_random_first_name_one_time() {
    let name = RandomGenerator::get_simple_random_first_name_one_time();
    assert!(!name.is_empty());
}

#[cfg(all(feature = "core", feature = "first_names"))]
#[test]
fn test_get_random_first_name_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let name = RandomGenerator::get_random_first_name_one_time(&mut rng);
    assert!(!name.is_empty());
}

#[cfg(all(feature = "core", feature = "first_names"))]
#[test]
fn test_get_random_first_name_one_time_without_rng() {
    let name = RandomGenerator::get_random_first_name_one_time(&mut None::<RNG>);
    assert!(!name.is_empty());
}

// =============================================================================
// Phase 1.1: RandomGenerator Static Methods - Last Name
// =============================================================================

#[cfg(all(feature = "core", feature = "names"))]
#[test]
fn test_get_simple_random_last_name_one_time() {
    let name = RandomGenerator::get_simple_random_last_name_one_time();
    assert!(!name.is_empty());
}

#[cfg(all(feature = "last_names", feature = "core"))]
#[test]
fn test_get_random_last_name_one_time_with_rng() {
    use rand::SeedableRng;
    let mut rng = Some(StdRng::seed_from_u64(42));
    let name = RandomGenerator::get_random_last_name_one_time(&mut rng);
    assert!(!name.is_empty());
}

#[cfg(all(feature = "last_names", feature = "core"))]
#[test]
fn test_get_random_last_name_one_time_without_rng() {
    let name = RandomGenerator::get_random_last_name_one_time(&mut None::<RNG>);
    assert!(!name.is_empty());
}

// =============================================================================
// Phase 1.1: RandomGeneratorTemplate Trait Tests
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_bytes() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let bytes = gen.get_random_bytes(10);
    assert_eq!(bytes.len(), 10);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_usize() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let val = gen.get_random_usize(1, 100);
    assert!(val >= 1 && val <= 100);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_u32() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let _val = gen.get_random_u32();
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_u64() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let _val = gen.get_random_u64();
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_string() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let s = gen.get_random_string(10);
    assert_eq!(s.len(), 10);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_from_characters() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let s = gen.get_random_from_characters(10, "abc");
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c == 'a' || c == 'b' || c == 'c'));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_get_random_alphanumeric() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let s = gen.get_random_alphanumeric(10);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c.is_alphanumeric()));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_random_generator_template_generate_key() {
    use rand::SeedableRng;
    let rng = RNG::Std(StdRng::seed_from_u64(42));
    let mut gen = RandomGenerator::new(Some(rng));
    let key = gen.generate_key(16);
    assert_eq!(key.len(), 16);
}

// =============================================================================
// Phase 1.2: Feature Flag Tests - Default Features
// =============================================================================

#[cfg(all(feature = "rand", not(feature = "core")))]
#[test]
fn test_default_features_compile() {
    // With default features, this test file compiles and links against rand.
}

// =============================================================================
// Phase 1.3: Backwards Compatibility - Panic Behavior
// =============================================================================

#[cfg(all(
    feature = "constrained",
    not(feature = "core"),
    not(feature = "send_only")
))]
#[test]
#[should_panic(expected = "No generator provided")]
fn test_generate_key_one_time_panics_without_rng_in_constrained() {
    let _key = RandomGenerator::generate_key_one_time(16, &mut None::<RNG>);
}

#[cfg(all(
    feature = "constrained",
    not(feature = "core"),
    not(feature = "send_only")
))]
#[test]
#[should_panic(expected = "No generator provided")]
fn test_get_random_bytes_one_time_panics_without_rng_in_constrained() {
    let _bytes = RandomGenerator::get_random_bytes_one_time(10, &mut None::<RNG>);
}

// =============================================================================
// Phase 1.3: Re-exported Types Tests
// =============================================================================

#[test]
fn test_reexported_rng_trait() {
    // Ensure Rng trait is accessible via re-export
    fn _assert_rng<T: product_os_random::Rng>() {}
}

#[test]
fn test_reexported_seedable_rng_trait() {
    // Ensure SeedableRng trait is accessible via re-export
    fn _assert_seedable_rng<T: product_os_random::SeedableRng>() {}
}

#[test]
fn test_reexported_rng_core_trait() {
    // Ensure RngCore trait is accessible
    fn _assert_rng_core<T: RngCore>() {}
}

#[test]
fn test_reexported_crypto_rng_trait() {
    // Ensure CryptoRng trait is accessible
    fn _assert_crypto_rng<T: CryptoRng>() {}
}

#[test]
fn test_reexported_error_type() {
    // Ensure Error type is accessible
    let _: Option<Error> = None;
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_reexported_std_rng() {
    use rand::SeedableRng;
    let _rng = StdRng::seed_from_u64(42);
}

#[cfg(all(feature = "core", not(feature = "send_only")))]
#[test]
fn test_reexported_thread_rng() {
    use rand::rngs::ThreadRng;
    let _: Option<ThreadRng> = None;
}

#[cfg(feature = "core")]
#[test]
fn test_reexported_os_rng() {
    use rand::rngs::OsRng;
    let _rng = OsRng;
}

// =============================================================================
// Phase 1.3: Edge Cases and Boundary Tests
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_generate_key_zero_length() {
    let key = RandomGenerator::generate_simple_key_one_time(0);
    assert_eq!(key.len(), 0);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_bytes_zero_length() {
    let bytes = RandomGenerator::get_random_bytes_one_time(0, &mut None::<RNG>);
    assert_eq!(bytes.len(), 0);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_string_zero_length() {
    let s = RandomGenerator::get_random_string_one_time(0, &mut None::<RNG>);
    assert_eq!(s.len(), 0);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_usize_same_min_max() {
    let val = RandomGenerator::get_simple_random_usize_one_time(5, 5);
    assert_eq!(val, 5);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_string_length_consistency() {
    for len in [1, 5, 10, 100] {
        let s = RandomGenerator::get_random_string_one_time(len, &mut None::<RNG>);
        assert_eq!(
            s.len(),
            len,
            "String length mismatch for requested length {}",
            len
        );
    }
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_get_random_alphanumeric_length_consistency() {
    for len in [1, 5, 10, 100] {
        let s = RandomGenerator::get_random_alphanumeric_one_time(len, &mut None::<RNG>);
        assert_eq!(
            s.len(),
            len,
            "Alphanumeric string length mismatch for requested length {}",
            len
        );
    }
}

// =============================================================================
// Top-level Convenience Functions
// =============================================================================

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_usize() {
    let val = product_os_random::random_usize(1, 100);
    assert!(val >= 1 && val <= 100);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_usize_same_min_max() {
    let val = product_os_random::random_usize(42, 42);
    assert_eq!(val, 42);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_string() {
    let s = product_os_random::random_string(10);
    assert_eq!(s.len(), 10);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_string_zero_length() {
    let s = product_os_random::random_string(0);
    assert_eq!(s.len(), 0);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_alphanumeric() {
    let s = product_os_random::random_alphanumeric(10);
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| c.is_alphanumeric()));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_bytes() {
    let bytes = product_os_random::random_bytes(16);
    assert_eq!(bytes.len(), 16);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_bytes_zero_length() {
    let bytes = product_os_random::random_bytes(0);
    assert_eq!(bytes.len(), 0);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_password() {
    let pw = product_os_random::random_password(16);
    assert_eq!(pw.len(), 16);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_from_characters() {
    let s = product_os_random::random_from_characters(10, "abc123");
    assert_eq!(s.len(), 10);
    assert!(s.chars().all(|c| "abc123".contains(c)));
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_generate_random_key() {
    let key = product_os_random::generate_random_key(32);
    assert_eq!(key.len(), 32);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_generate_random_key_zero_length() {
    let key = product_os_random::generate_random_key(0);
    assert_eq!(key.len(), 0);
}

#[cfg(any(feature = "core", feature = "send_only"))]
#[test]
fn test_convenience_random_alphanumeric_length_consistency() {
    for len in [1, 5, 10, 50, 100] {
        let s = product_os_random::random_alphanumeric(len);
        assert_eq!(s.len(), len, "Alphanumeric length mismatch for {}", len);
        assert!(
            s.chars().all(|c| c.is_alphanumeric()),
            "Non-alphanumeric char found for len {}",
            len
        );
    }
}