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 {
  31             x: u8,
  32         },
  33         #[weight(2)]
  34         Right {
  35             y: bool,
  36         },
  37     }
  38
  39     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  40     struct TestStructUnit;
  41
  42     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  43     struct TestStructUnnamed(u8, i32);
  44
  45     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
  46     struct TestStructNamed {
  47         x: u8,
  48         y: i32,
  49     }
  50
  51     #[test]
  52     fn test_enum_unit() {
  53         let mut rng = rng();
  54         assert_eq!(
  55             repeat(6, || TestEnumUnit::generate_random(&mut rng),),
  56             vec![
  57                 TestEnumUnit::Right,
  58                 TestEnumUnit::Right,
  59                 TestEnumUnit::Left,
  60                 TestEnumUnit::Right,
  61                 TestEnumUnit::Right,
  62                 TestEnumUnit::Right,
  63             ]
  64         );
  65     }
  66
  67     #[test]
  68     fn test_enum_unnamed() {
  69         let mut rng = rng();
  70         assert_eq!(
  71             repeat(6, || TestEnumUnnamed::generate_random(&mut rng),),
  72             vec![
  73                 TestEnumUnnamed::Right(false),
  74                 TestEnumUnnamed::Left(142),
  75                 TestEnumUnnamed::Right(false),
  76                 TestEnumUnnamed::Right(true),
  77                 TestEnumUnnamed::Right(false),
  78                 TestEnumUnnamed::Left(19),
  79             ]
  80         );
  81     }
  82
  83     #[test]
  84     fn test_enum_named() {
  85         let mut rng = rng();
  86         assert_eq!(
  87             repeat(6, || TestEnumNamed::generate_random(&mut rng),),
  88             vec![
  89                 TestEnumNamed::Right { y: false },
  90                 TestEnumNamed::Left { x: 142 },
  91                 TestEnumNamed::Right { y: false },
  92                 TestEnumNamed::Right { y: true },
  93                 TestEnumNamed::Right { y: false },
  94                 TestEnumNamed::Left { x: 19 },
  95             ]
  96         );
  97     }
  98
  99     #[test]
 100     fn test_struct_unit() {
 101         let mut rng = rng();
 102         assert_eq!(TestStructUnit::generate_random(&mut rng), TestStructUnit);
 103     }
 104
 105     #[test]
 106     fn test_struct_unnamed() {
 107         let mut rng = rng();
 108         assert_eq!(
 109             TestStructUnnamed::generate_random(&mut rng),
 110             TestStructUnnamed(55, -896102575)
 111         );
 112     }
 113
 114     #[test]
 115     fn test_struct_named() {
 116         let mut rng = rng();
 117         assert_eq!(
 118             TestStructNamed::generate_random(&mut rng),
 119             TestStructNamed {
 120                 x: 55,
 121                 y: -896102575,
 122             }
 123         );
 124     }
 125 }