Default -> Std

fuzzers/libfuzzer/src/lib.rs

@@ -8,15 +8,15 @@ use alloc::rc::Rc;
 use core::cell::RefCell;
 
 use afl::corpus::{Corpus, InMemoryCorpus, Testcase};
-use afl::engines::{DefaultEngine, DefaultState, Engine, State};
+use afl::engines::{StdEngine, StdState, Engine, State};
 use afl::executors::inmemory::InMemoryExecutor;
 use afl::executors::{Executor, ExitKind};
 use afl::feedbacks::{create_history_map, MaxMapFeedback};
 use afl::inputs::bytes::BytesInput;
 use afl::mutators::scheduled::HavocBytesMutator;
-use afl::observers::DefaultMapObserver;
+use afl::observers::StdMapObserver;
-use afl::stages::mutational::DefaultMutationalStage;
+use afl::stages::mutational::StdMutationalStage;
-use afl::utils::DefaultRand;
+use afl::utils::StdRand;
 
 const MAP_SIZE: usize = 65536;
 
@@ -39,13 +39,13 @@ fn harness<I>(_executor: &dyn Executor<I>, buf: &[u8]) -> ExitKind {
 
 #[no_mangle]
 pub extern "C" fn afl_libfuzzer_main() {
-    let rand = DefaultRand::new(0).into();
+    let rand = StdRand::new(0).into();
 
     let mut corpus = InMemoryCorpus::<BytesInput, _>::new(&rand);
     let testcase = Testcase::new(vec![0; 4]).into();
     corpus.add(testcase);
 
-    let edges_observer = Rc::new(RefCell::new(DefaultMapObserver::new_from_ptr(
+    let edges_observer = Rc::new(RefCell::new(StdMapObserver::new_from_ptr(
         unsafe { __lafl_edges_map },
         unsafe { __lafl_max_edges_size as usize },
     )));
@@ -53,13 +53,13 @@ pub extern "C" fn afl_libfuzzer_main() {
     let edges_feedback = MaxMapFeedback::new(edges_observer.clone(), edges_history_map);
 
     let executor = InMemoryExecutor::<BytesInput>::new(harness);
-    let mut state = DefaultState::new(corpus, executor);
+    let mut state = StdState::new(corpus, executor);
     state.add_observer(edges_observer);
     state.add_feedback(Box::new(edges_feedback));
 
-    let mut engine = DefaultEngine::new();
+    let mut engine = StdEngine::new();
     let mutator = HavocBytesMutator::new_default(&rand);
-    let stage = DefaultMutationalStage::new(&rand, mutator);
+    let stage = StdMutationalStage::new(&rand, mutator);
     engine.add_stage(Box::new(stage));
 
     for i in 0..1000 {

src/corpus/mod.rs

@@ -326,15 +326,15 @@ mod tests {
     use crate::corpus::Testcase;
     use crate::corpus::{OnDiskCorpus, QueueCorpus};
     use crate::inputs::bytes::BytesInput;
-    use crate::utils::DefaultRand;
+    use crate::utils::StdRand;
 
     use alloc::rc::Rc;
     use std::path::PathBuf;
 
     #[test]
     fn test_queuecorpus() {
-        let mut rand = DefaultRand::new(0);
+        let mut rand = StdRand::new(0);
-        let mut q = QueueCorpus::new(OnDiskCorpus::<BytesInput, DefaultRand>::new(PathBuf::from(
+        let mut q = QueueCorpus::new(OnDiskCorpus::<BytesInput, StdRand>::new(PathBuf::from(
             "fancy/path",
         )));
         let t: Rc<_> =

src/engines/mod.rs

@@ -6,30 +6,21 @@ use alloc::vec::Vec;
 use core::cell::RefCell;
 use core::fmt::Debug;
 
-use hashbrown::HashMap;
-
 use crate::corpus::{Corpus, Testcase};
-use crate::events::EventManager;
 use crate::executors::Executor;
 use crate::feedbacks::Feedback;
 use crate::inputs::Input;
 use crate::observers::Observer;
 use crate::stages::Stage;
-use crate::utils::{HasRand, Rand};
 use crate::AflError;
 
-pub trait StateMetadata: Debug {
+pub trait StateMetadata: Debug {}
-    /// The name of this metadata - used to find it in the list of avaliable metadatas
-    fn name(&self) -> &'static str;
-}
 
-pub trait State<C, E, EM, I, R>: HasRand<R = R>
+pub trait State<C, E, I>
 where
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
     /// Get executions
     fn executions(&self) -> usize;
@@ -37,21 +28,6 @@ where
     /// Set executions
     fn set_executions(&mut self, executions: usize);
 
-    fn events_manager(&self) -> &EM;
-
-    fn events_manager_mut(&mut self) -> &mut EM;
-
-    /// Get all the metadatas into an HashMap
-    fn metadatas(&self) -> &HashMap<&'static str, Box<dyn StateMetadata>>;
-
-    /// Get all the metadatas into an HashMap (mutable)
-    fn metadatas_mut(&mut self) -> &mut HashMap<&'static str, Box<dyn StateMetadata>>;
-
-    /// Add a metadata
-    fn add_metadata(&mut self, meta: Box<dyn StateMetadata>) {
-        self.metadatas_mut().insert(meta.name(), meta);
-    }
-
     /// Get the linked observers
     fn observers(&self) -> &[Rc<RefCell<dyn Observer>>];
 
@@ -129,49 +105,24 @@ where
     }
 }
 
-pub struct DefaultState<C, E, EM, I, R>
+pub struct StdState<C, E, I>
 where
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
-    rand: R,
     executions: usize,
-    events_manager: EM,
-    metadatas: HashMap<&'static str, Box<dyn StateMetadata>>,
     observers: Vec<Rc<RefCell<dyn Observer>>>,
     feedbacks: Vec<Box<dyn Feedback<I>>>,
     corpus: C,
     executor: E,
 }
 
-impl<C, E, EM, I, R> HasRand for DefaultState<C, E, EM, I, R>
+impl<C, E, I> State<C, E, I> for StdState<C, E, I>
 where
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
-{
-    type R = R;
-
-    fn rand(&self) -> &Self::R {
-        &self.rand
-    }
-    fn rand_mut(&mut self) -> &mut Self::R {
-        &mut self.rand
-    }
-}
-
-impl<C, E, EM, I, R> State<C, E, EM, I, R> for DefaultState<C, E, EM, I, R>
-where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    EM: EventManager,
-    I: Input,
-    R: Rand,
 {
     fn executions(&self) -> usize {
         self.executions
@@ -181,21 +132,6 @@ where
         self.executions = executions
     }
 
-    fn events_manager(&self) -> &EM {
-        &self.events_manager
-    }
-    fn events_manager_mut(&mut self) -> &mut EM {
-        &mut self.events_manager
-    }
-
-    fn metadatas(&self) -> &HashMap<&'static str, Box<dyn StateMetadata>> {
-        &self.metadatas
-    }
-
-    fn metadatas_mut(&mut self) -> &mut HashMap<&'static str, Box<dyn StateMetadata>> {
-        &mut self.metadatas
-    }
-
     fn observers(&self) -> &[Rc<RefCell<dyn Observer>>] {
         &self.observers
     }
@@ -229,20 +165,15 @@ where
     }
 }
 
-impl<C, E, EM, I, R> DefaultState<C, E, EM, I, R>
+impl<C, E, I> StdState<C, E, I>
 where
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
-    pub fn new(corpus: C, executor: E, events_manager: EM, rand: R) -> Self {
+    pub fn new(corpus: C, executor: E) -> Self {
-        DefaultState {
+        StdState {
-            rand: rand,
             executions: 0,
-            events_manager: events_manager,
-            metadatas: HashMap::default(),
             observers: vec![],
             feedbacks: vec![],
             corpus: corpus,
@@ -251,25 +182,24 @@ where
     }
 }
 
-pub trait Engine<S, C, E, EM, I, R>
+pub trait Engine<S, C, E, I>
 where
-    S: State<C, E, EM, I, R>,
+    S: State<C, E, I>,
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
-    fn stages(&self) -> &[Box<dyn Stage<S, C, E, EM, I, R>>];
+    fn stages(&self) -> &[Box<dyn Stage<S, C, E, I>>];
 
-    fn stages_mut(&mut self) -> &mut Vec<Box<dyn Stage<S, C, E, EM, I, R>>>;
+    fn stages_mut(&mut self) -> &mut Vec<Box<dyn Stage<S, C, E, I>>>;
 
-    fn add_stage(&mut self, stage: Box<dyn Stage<S, C, E, EM, I, R>>) {
+    fn add_stage(&mut self, stage: Box<dyn Stage<S, C, E, I>>) {
         self.stages_mut().push(stage);
     }
 
     fn fuzz_one(&mut self, state: &mut S) -> Result<usize, AflError> {
-        let (testcase, idx) = state.corpus_mut().next(state.rand_mut())?;
+        let (testcase, idx) = state.corpus_mut().next()?;
+        #[cfg(feature = "std")]
         println!("Cur entry: {}\tExecutions: {}", idx, state.executions());
         for stage in self.stages_mut() {
             stage.perform(testcase.clone(), state)?;
@@ -278,47 +208,41 @@ where
     }
 }
 
-pub struct DefaultEngine<S, C, E, EM, I, R>
+pub struct StdEngine<S, C, E, I>
 where
-    S: State<C, E, EM, I, R>,
+    S: State<C, E, I>,
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
-    stages: Vec<Box<dyn Stage<S, C, E, EM, I, R>>>,
+    stages: Vec<Box<dyn Stage<S, C, E, I>>>,
 }
 
-impl<S, C, E, EM, I, R> Engine<S, C, E, EM, I, R> for DefaultEngine<S, C, E, EM, I, R>
+impl<S, C, E, I> Engine<S, C, E, I> for StdEngine<S, C, E, I>
 where
-    S: State<C, E, EM, I, R>,
+    S: State<C, E, I>,
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
-    fn stages(&self) -> &[Box<dyn Stage<S, C, E, EM, I, R>>] {
+    fn stages(&self) -> &[Box<dyn Stage<S, C, E, I>>] {
         &self.stages
     }
 
-    fn stages_mut(&mut self) -> &mut Vec<Box<dyn Stage<S, C, E, EM, I, R>>> {
+    fn stages_mut(&mut self) -> &mut Vec<Box<dyn Stage<S, C, E, I>>> {
         &mut self.stages
     }
 }
 
-impl<S, C, E, EM, I, R> DefaultEngine<S, C, E, EM, I, R>
+impl<S, C, E, I> StdEngine<S, C, E, I>
 where
-    S: State<C, E, EM, I, R>,
+    S: State<C, E, I>,
-    C: Corpus<I, R>,
+    C: Corpus<I>,
     E: Executor<I>,
-    EM: EventManager,
     I: Input,
-    R: Rand,
 {
     pub fn new() -> Self {
-        DefaultEngine { stages: vec![] }
+        StdEngine { stages: vec![] }
     }
 }
 
@@ -328,16 +252,15 @@ mod tests {
     use alloc::boxed::Box;
 
     use crate::corpus::{Corpus, InMemoryCorpus, Testcase};
-    use crate::engines::{DefaultEngine, DefaultState, Engine};
+    use crate::engines::{StdEngine, StdState, Engine};
-    use crate::events::LoggerEventManager;
     use crate::executors::inmemory::InMemoryExecutor;
     use crate::executors::{Executor, ExitKind};
     use crate::inputs::bytes::BytesInput;
     use crate::mutators::scheduled::{
-        mutation_bitflip, ComposedByMutations, DefaultScheduledMutator,
+        mutation_bitflip, ComposedByMutations, StdScheduledMutator,
     };
-    use crate::stages::mutational::DefaultMutationalStage;
+    use crate::stages::mutational::StdMutationalStage;
-    use crate::utils::DefaultRand;
+    use crate::utils::StdRand;
 
     fn harness<I>(_executor: &dyn Executor<I>, _buf: &[u8]) -> ExitKind {
         ExitKind::Ok
@@ -345,20 +268,19 @@ mod tests {
 
     #[test]
     fn test_engine() {
-        let mut corpus = InMemoryCorpus::<BytesInput, DefaultRand>::new();
+        let rand = StdRand::new(0).into();
+
+        let mut corpus = InMemoryCorpus::<BytesInput, _>::new(&rand);
         let testcase = Testcase::new(vec![0; 4]).into();
         corpus.add(testcase);
 
         let executor = InMemoryExecutor::<BytesInput>::new(harness);
-        let events = LoggerEventManager::new();
+        let mut state = StdState::new(corpus, executor);
-        let rand = DefaultRand::new(0);
 
-        let mut state = DefaultState::new(corpus, executor, events, rand);
+        let mut engine = StdEngine::new();
-
+        let mut mutator = StdScheduledMutator::new(&rand);
-        let mut engine = DefaultEngine::new();
-        let mut mutator = DefaultScheduledMutator::new();
         mutator.add_mutation(mutation_bitflip);
-        let stage = DefaultMutationalStage::new(mutator);
+        let stage = StdMutationalStage::new(&rand, mutator);
         engine.add_stage(Box::new(stage));
 
         //

src/inputs/bytes.rs

@@ -68,11 +68,11 @@ impl BytesInput {
 
 #[cfg(test)]
 mod tests {
-    use crate::utils::{next_pow2, DefaultRand, Rand};
+    use crate::utils::{next_pow2, StdRand, Rand};
 
     #[test]
     fn test_input() {
-        let mut rand = DefaultRand::new(0);
+        let mut rand = StdRand::new(0);
         assert_ne!(rand.next(), rand.next());
         assert!(rand.below(100) < 100);
         assert_eq!(rand.below(1), 0);

src/mutators/mod.rs

@@ -1,6 +1,6 @@
 pub mod scheduled;
 pub use scheduled::ComposedByMutations;
-pub use scheduled::DefaultScheduledMutator;
+pub use scheduled::StdScheduledMutator;
 pub use scheduled::HavocBytesMutator;
 pub use scheduled::ScheduledMutator;
 

src/mutators/scheduled.rs

@@ -79,7 +79,7 @@ where
     }
 }
 
-pub struct DefaultScheduledMutator<S, C, I, R>
+pub struct StdScheduledMutator<S, C, I, R>
 where
     C: Corpus<I, R>,
     I: Input,
@@ -88,7 +88,7 @@ where
     mutations: Vec<MutationFunction<Self, S, I>>,
 }
 
-impl<S, C, I, R> Mutator<S, C, I, R> for DefaultScheduledMutator<S, C, I, R>
+impl<S, C, I, R> Mutator<S, C, I, R> for StdScheduledMutator<S, C, I, R>
 where
     C: Corpus<I, R>,
     I: Input,
@@ -105,7 +105,7 @@ where
     }
 }
 
-impl<S, C, I, R> ComposedByMutations<S, C, I, R> for DefaultScheduledMutator<S, C, I, R>
+impl<S, C, I, R> ComposedByMutations<S, C, I, R> for StdScheduledMutator<S, C, I, R>
 where
     C: Corpus<I, R>,
     I: Input,
@@ -127,7 +127,7 @@ where
     }
 }
 
-impl<C, I, R> ScheduledMutator<C, I, R> for DefaultScheduledMutator<C, I, R>
+impl<C, I, R> ScheduledMutator<C, I, R> for StdScheduledMutator<C, I, R>
 where
     C: Corpus<I, R>,
     I: Input,
@@ -136,20 +136,20 @@ where
     // Just use the default methods
 }
 
-impl<C, I, R> DefaultScheduledMutator<C, I, R>
+impl<C, I, R> StdScheduledMutator<C, I, R>
 where
     C: Corpus<I, R>,
     I: Input,
     R: Rand,
 {
-    /// Create a new DefaultScheduledMutator instance without mutations and corpus
+    /// Create a new StdScheduledMutator instance without mutations and corpus
     pub fn new() -> Self {
-        DefaultScheduledMutator { mutations: vec![] }
+        StdScheduledMutator { mutations: vec![] }
     }
 
-    /// Create a new DefaultScheduledMutator instance specifying mutations and corpus too
+    /// Create a new StdScheduledMutator instance specifying mutations and corpus too
     pub fn new_all(mutations: Vec<MutationFunction<Self, S, I>>) -> Self {
-        DefaultScheduledMutator {
+        StdScheduledMutator {
             mutations: mutations,
         }
     }
@@ -303,15 +303,15 @@ where
     }
 }
 
-impl<C, I, R> HavocBytesMutator<C, I, DefaultScheduledMutator<C, I, R>, R>
+impl<C, I, R> HavocBytesMutator<C, I, StdScheduledMutator<C, I, R>, R>
 where
     C: Corpus<I, R>,
     I: Input + HasBytesVec,
     R: Rand,
 {
-    /// Create a new HavocBytesMutator instance wrapping DefaultScheduledMutator
+    /// Create a new HavocBytesMutator instance wrapping StdScheduledMutator
     pub fn new_default() -> Self {
-        let mut scheduled = DefaultScheduledMutator::<C, I, R>::new();
+        let mut scheduled = StdScheduledMutator::<C, I, R>::new();
         scheduled.add_mutation(mutation_bitflip);
         scheduled.add_mutation(mutation_splice);
         HavocBytesMutator {
@@ -325,7 +325,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::inputs::BytesInput;
-    use crate::mutators::scheduled::{mutation_splice, DefaultScheduledMutator};
+    use crate::mutators::scheduled::{mutation_splice, StdScheduledMutator};
     use crate::utils::{Rand, XKCDRand};
     use crate::{
         corpus::{Corpus, InMemoryCorpus, Testcase},
@@ -348,7 +348,7 @@ mod tests {
 
         rand.set_seed(5);
         let mut mutator =
-            DefaultScheduledMutator::<InMemoryCorpus<_, _>, BytesInput, XKCDRand>::new();
+            StdScheduledMutator::<InMemoryCorpus<_, _>, BytesInput, XKCDRand>::new();
 
         mutation_splice(&mut mutator, &mut corpus, &mut rand, &mut input).unwrap();
 

src/observers/mod.rs

@@ -51,7 +51,7 @@ where
     }
 }
 
-pub struct DefaultMapObserver<'a, T>
+pub struct StdMapObserver<'a, T>
 where
     T: Integer + Copy,
 {
@@ -59,7 +59,7 @@ where
     initial: T,
 }
 
-impl<'a, T> Observer for DefaultMapObserver<'a, T>
+impl<'a, T> Observer for StdMapObserver<'a, T>
 where
     T: Integer + Copy,
 {
@@ -68,7 +68,7 @@ where
     }
 }
 
-impl<'a, T> MapObserver<T> for DefaultMapObserver<'a, T>
+impl<'a, T> MapObserver<T> for StdMapObserver<'a, T>
 where
     T: Integer + Copy,
 {
@@ -93,14 +93,14 @@ where
     }
 }
 
-impl<'a, T> DefaultMapObserver<'a, T>
+impl<'a, T> StdMapObserver<'a, T>
 where
     T: Integer + Copy,
 {
     /// Creates a new MapObserver
     pub fn new(map: &'a mut [T]) -> Self {
         let initial = if map.len() > 0 { map[0] } else { T::zero() };
-        DefaultMapObserver {
+        StdMapObserver {
             map: map,
             initial: initial,
         }
@@ -110,7 +110,7 @@ where
     pub fn new_from_ptr(map_ptr: *mut T, len: usize) -> Self {
         unsafe {
             let initial = if len > 0 { *map_ptr } else { T::zero() };
-            DefaultMapObserver {
+            StdMapObserver {
                 map: from_raw_parts_mut(map_ptr, len),
                 initial: initial,
             }
@@ -118,7 +118,7 @@ where
     }
 }
 
-impl<'a, T> Into<Rc<RefCell<Self>>> for DefaultMapObserver<'a, T>
+impl<'a, T> Into<Rc<RefCell<Self>>> for StdMapObserver<'a, T>
 where
     T: Integer + Copy,
 {

src/stages/mod.rs

@@ -1,5 +1,5 @@
 pub mod mutational;
-pub use mutational::DefaultMutationalStage;
+pub use mutational::StdMutationalStage;
 
 use crate::corpus::testcase::Testcase;
 use crate::corpus::Corpus;

src/stages/mutational.rs

@@ -63,7 +63,7 @@ where
 }
 
 /// The default mutational stage
-pub struct DefaultMutationalStage<M, S, C, E, EM, I, R>
+pub struct StdMutationalStage<M, S, C, E, EM, I, R>
 where
     M: Mutator<C, I, R>,
     S: State<C, E, EM, I, R>,
@@ -78,7 +78,7 @@ where
 }
 
 impl<M, S, C, E, EM, I, R> MutationalStage<M, S, C, E, EM, I, R>
-    for DefaultMutationalStage<M, S, C, E, EM, I, R>
+    for StdMutationalStage<M, S, C, E, EM, I, R>
 where
     M: Mutator<C, I, R>,
     S: State<C, E, EM, I, R>,
@@ -99,7 +99,7 @@ where
     }
 }
 
-impl<M, S, C, E, EM, I, R> Stage<S, C, E, EM, I, R> for DefaultMutationalStage<M, S, C, E, EM, I, R>
+impl<M, S, C, E, EM, I, R> Stage<S, C, E, EM, I, R> for StdMutationalStage<M, S, C, E, EM, I, R>
 where
     M: Mutator<C, I, R>,
     S: State<C, E, EM, I, R>,
@@ -118,7 +118,7 @@ where
     }
 }
 
-impl<M, S, C, E, EM, I, R> DefaultMutationalStage<M, S, C, E, EM, I, R>
+impl<M, S, C, E, EM, I, R> StdMutationalStage<M, S, C, E, EM, I, R>
 where
     M: Mutator<C, I, R>,
     S: State<C, E, EM, I, R>,
@@ -130,7 +130,7 @@ where
 {
     /// Creates a new default mutational stage
     pub fn new(mutator: M) -> Self {
-        DefaultMutationalStage {
+        StdMutationalStage {
             mutator: mutator,
             phantom: PhantomData,
         }

src/utils.rs

@@ -9,7 +9,7 @@ use xxhash_rust::xxh3::xxh3_64_with_seed;
 #[cfg(feature = "std")]
 use std::time::{SystemTime, UNIX_EPOCH};
 
-pub type DefaultRand = Xoshiro256StarRand;
+pub type StdRand = Xoshiro256StarRand;
 
 /// Ways to get random around here
 pub trait Rand: Debug {
@@ -144,7 +144,7 @@ impl Into<Rc<RefCell<Self>>> for Xoshiro256StarRand {
 impl Xoshiro256StarRand {
     /// Creates a new Xoshiro rand with the given seed
     pub fn new(seed: u64) -> Self {
-        let mut ret: Xoshiro256StarRand = Default::default();
+        let mut ret: Self = Default::default();
         ret.set_seed(seed); // TODO: Proper random seed?
         ret
     }
@@ -199,7 +199,7 @@ impl XKCDRand {
 
 /*
 /// A very basic HasRand
-pub struct DefaultHasRand<R>
+pub struct StdHasRand<R>
 where
     R: Rand,
 {
@@ -207,7 +207,7 @@ where
 }
 
 /// A very basic HasRand
-impl<R> HasRand for DefaultHasRand<R>
+impl<R> HasRand for StdHasRand<R>
 where
     R: Rand,
 {
@@ -220,11 +220,11 @@ where
 }
 
 /// A very basic HasRand
-impl<R> DefaultHasRand<R>
+impl<R> StdHasRand<R>
 where
     R: Rand,
 {
-    /// Create a new DefaultHasRand, cloning the refcell
+    /// Create a new StdHasRand, cloning the refcell
     pub fn new(rand: &Rc<RefCell<R>>) -> Self {
         Self {
             rand: Rc::clone(rand),
@@ -246,11 +246,11 @@ pub const fn next_pow2(val: u64) -> u64 {
 
 #[cfg(test)]
 mod tests {
-    use crate::utils::{next_pow2, DefaultRand, HasRand, Rand};
+    use crate::utils::{next_pow2, StdRand, HasRand, Rand};
 
     #[test]
     fn test_rand() {
-        let mut rand = DefaultRand::new(0);
+        let mut rand = StdRand::new(0);
         assert_ne!(rand.next(), rand.next());
         assert!(rand.below(100) < 100);
         assert_eq!(rand.below(1), 0);
@@ -261,8 +261,8 @@ mod tests {
     #[cfg(feature = "std")]
     #[test]
     fn test_rand_preseeded() {
-        let mut rand_fixed = DefaultRand::new(0);
+        let mut rand_fixed = StdRand::new(0);
-        let mut rand = DefaultRand::preseeded();
+        let mut rand = StdRand::preseeded();
         assert_ne!(rand.next(), rand_fixed.next());
         assert_ne!(rand.next(), rand.next());
         assert!(rand.below(100) < 100);
@@ -274,8 +274,8 @@ mod tests {
     /*
     #[test]
     fn test_has_rand() {
-        let rand = DefaultRand::new(0).into();
+        let rand = StdRand::new(0).into();
-        let has_rand = DefaultHasRand::new(&rand);
+        let has_rand = StdHasRand::new(&rand);
 
         assert!(has_rand.rand_below(100) < 100);
         assert_eq!(has_rand.rand_below(1), 0);