tests/src/lib.rs

   1 #[cfg(test)]
   2 mod tests {
   3     use generate_random::GenerateRandom;
   4
   5     fn rng() -> impl rand::Rng {
   6         use rand::SeedableRng;
   7         rand_chacha::ChaCha8Rng::from(rand_chacha::ChaCha8Core::from_seed([37; 32]))
   8     }
   9
  10     fn repeat<T>(count: usize, f: impl FnMut() -> T) -> Vec<T> {
  11         std::iter::repeat_with(f).take(count).collect()
  12     }
  13
  14     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  15     enum TestEnumUnit {
  16         Left,
  17         #[weight(2)]
  18         Right,
  19     }
  20
  21     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  22     enum TestEnumUnnamed {
  23         Left(u8),
  24         #[weight(2)]
  25         Right(bool),
  26     }
  27
  28     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  29     enum TestEnumNamed {
  30         Left { x: u8 },
  31         #[weight(2)]
  32         Right { y: bool },
  33     }
  34
  35     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  36     struct TestStructUnit;
  37
  38     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  39     struct TestStructUnnamed(u8, i32);
  40
  41     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  42     struct TestStructNamed {
  43         x: u8,
  44         y: i32,
  45     }
  46
  47     #[test]
  48     fn test_enum_unit() {
  49         let mut rng = rng();
  50         assert_eq!(
  51             repeat(
  52                 6,
  53                 || TestEnumUnit::generate_random(&mut rng),
  54             ),
  55             vec![
  56                 TestEnumUnit::Right,
  57                 TestEnumUnit::Right,
  58                 TestEnumUnit::Left,
  59                 TestEnumUnit::Right,
  60                 TestEnumUnit::Right,
  61                 TestEnumUnit::Right,
  62             ]);
  63     }
  64
  65     #[test]
  66     fn test_enum_unnamed() {
  67         let mut rng = rng();
  68         assert_eq!(
  69             repeat(
  70                 6,
  71                 || TestEnumUnnamed::generate_random(&mut rng),
  72             ),
  73             vec![
  74                 TestEnumUnnamed::Right(false),
  75                 TestEnumUnnamed::Left(142),
  76                 TestEnumUnnamed::Right(false),
  77                 TestEnumUnnamed::Right(true),
  78                 TestEnumUnnamed::Right(false),
  79                 TestEnumUnnamed::Left(19),
  80             ]);
  81     }
  82
  83     #[test]
  84     fn test_enum_named() {
  85         let mut rng = rng();
  86         assert_eq!(
  87             repeat(
  88                 6,
  89                 || TestEnumNamed::generate_random(&mut rng),
  90             ),
  91             vec![
  92                 TestEnumNamed::Right { y: false },
  93                 TestEnumNamed::Left { x: 142 },
  94                 TestEnumNamed::Right { y: false },
  95                 TestEnumNamed::Right { y: true },
  96                 TestEnumNamed::Right { y: false },
  97                 TestEnumNamed::Left { x: 19 },
  98             ]);
  99     }
 100
 101     #[test]
 102     fn test_struct_unit() {
 103         let mut rng = rng();
 104         assert_eq!(
 105             TestStructUnit::generate_random(&mut rng),
 106             TestStructUnit
 107         );
 108     }
 109
 110     #[test]
 111     fn test_struct_unnamed() {
 112         let mut rng = rng();
 113         assert_eq!(
 114             TestStructUnnamed::generate_random(&mut rng),
 115             TestStructUnnamed(55, -896102575)
 116         );
 117     }
 118
 119     #[test]
 120     fn test_struct_named() {
 121         let mut rng = rng();
 122         assert_eq!(
 123             TestStructNamed::generate_random(&mut rng),
 124             TestStructNamed {
 125                 x: 55,
 126                 y: -896102575,
 127             }
 128         );
 129     }
 130 }