use rand::Rng;
pub struct RandomGenerator {
rng: rand::rngs::ThreadRng,
}
impl RandomGenerator {
pub fn new() -> Self {
Self {
rng: rand::thread_rng(),
}
}
pub fn generate(&mut self, length: usize, count: usize) -> Vec<u64> {
if length == 0 || count == 0 {
return Vec::new();
}
let mut result = Vec::with_capacity(count);
let min_value = if length == 1 { 0 } else { 10_u64.pow((length - 1) as u32) };
let max_value = 10_u64.pow(length as u32) - 1;
for _ in 0..count {
let random_num = self.rng.gen_range(min_value..=max_value);
result.push(random_num);
}
result
}
pub fn generate_strings(&mut self, length: usize, count: usize) -> Vec<String> {
if length == 0 || count == 0 {
return Vec::new();
}
let mut result = Vec::with_capacity(count);
for _ in 0..count {
let mut num_str = String::new();
for _ in 0..length {
let digit = self.rng.gen_range(0..=9);
num_str.push_str(&digit.to_string());
}
result.push(num_str);
}
result
}
}
impl Default for RandomGenerator {
fn default() -> Self {
Self::new()
}
}
pub fn generate_random_numbers(length: usize, count: usize) -> Vec<u64> {
let mut generator = RandomGenerator::new();
generator.generate(length, count)
}
pub fn generate_random_strings(length: usize, count: usize) -> Vec<String> {
let mut generator = RandomGenerator::new();
generator.generate_strings(length, count)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_generate_random_numbers() {
let numbers = generate_random_numbers(3, 5);
assert_eq!(numbers.len(), 5);
for num in &numbers {
assert!(*num >= 100 && *num <= 999);
}
}
#[test]
fn test_generate_single_digit() {
let numbers = generate_random_numbers(1, 10);
assert_eq!(numbers.len(), 10);
for num in &numbers {
assert!(*num <= 9);
}
}
#[test]
fn test_generate_zero_count() {
let numbers = generate_random_numbers(3, 0);
assert_eq!(numbers.len(), 0);
}
#[test]
fn test_generate_zero_length() {
let numbers = generate_random_numbers(0, 5);
assert_eq!(numbers.len(), 0);
}
#[test]
fn test_generator_struct() {
let mut generator = RandomGenerator::new();
let numbers = generator.generate(4, 3);
assert_eq!(numbers.len(), 3);
for num in &numbers {
assert!(*num >= 1000 && *num <= 9999);
}
}
#[test]
fn test_generate_strings() {
let numbers = generate_random_strings(4, 5);
assert_eq!(numbers.len(), 5);
for num_str in &numbers {
assert_eq!(num_str.len(), 4);
assert!(num_str.chars().all(|c| c.is_ascii_digit()));
}
}
#[test]
fn test_generator_strings_method() {
let mut generator = RandomGenerator::new();
let numbers = generator.generate_strings(3, 2);
assert_eq!(numbers.len(), 2);
for num_str in &numbers {
assert_eq!(num_str.len(), 3);
assert!(num_str.chars().all(|c| c.is_ascii_digit()));
}
}
}