library/core/tests/nonzero.rs

   1 use core::convert::TryFrom;
   2 use core::num::{
   3     IntErrorKind, NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize,
   4     NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
   5 };
   6 use core::option::Option::{self, None, Some};
   7 use std::mem::size_of;
   8
   9 #[test]
  10 fn test_create_nonzero_instance() {
  11     let _a = unsafe { NonZeroU32::new_unchecked(21) };
  12 }
  13
  14 #[test]
  15 fn test_size_nonzero_in_option() {
  16     assert_eq!(size_of::<NonZeroU32>(), size_of::<Option<NonZeroU32>>());
  17     assert_eq!(size_of::<NonZeroI32>(), size_of::<Option<NonZeroI32>>());
  18 }
  19
  20 #[test]
  21 fn test_match_on_nonzero_option() {
  22     let a = Some(unsafe { NonZeroU32::new_unchecked(42) });
  23     match a {
  24         Some(val) => assert_eq!(val.get(), 42),
  25         None => panic!("unexpected None while matching on Some(NonZeroU32(_))"),
  26     }
  27
  28     match unsafe { Some(NonZeroU32::new_unchecked(43)) } {
  29         Some(val) => assert_eq!(val.get(), 43),
  30         None => panic!("unexpected None while matching on Some(NonZeroU32(_))"),
  31     }
  32 }
  33
  34 #[test]
  35 fn test_match_option_empty_vec() {
  36     let a: Option<Vec<isize>> = Some(vec![]);
  37     match a {
  38         None => panic!("unexpected None while matching on Some(vec![])"),
  39         _ => {}
  40     }
  41 }
  42
  43 #[test]
  44 fn test_match_option_vec() {
  45     let a = Some(vec![1, 2, 3, 4]);
  46     match a {
  47         Some(v) => assert_eq!(v, [1, 2, 3, 4]),
  48         None => panic!("unexpected None while matching on Some(vec![1, 2, 3, 4])"),
  49     }
  50 }
  51
  52 #[test]
  53 fn test_match_option_rc() {
  54     use std::rc::Rc;
  55
  56     let five = Rc::new(5);
  57     match Some(five) {
  58         Some(r) => assert_eq!(*r, 5),
  59         None => panic!("unexpected None while matching on Some(Rc::new(5))"),
  60     }
  61 }
  62
  63 #[test]
  64 fn test_match_option_arc() {
  65     use std::sync::Arc;
  66
  67     let five = Arc::new(5);
  68     match Some(five) {
  69         Some(a) => assert_eq!(*a, 5),
  70         None => panic!("unexpected None while matching on Some(Arc::new(5))"),
  71     }
  72 }
  73
  74 #[test]
  75 fn test_match_option_empty_string() {
  76     let a = Some(String::new());
  77     match a {
  78         None => panic!("unexpected None while matching on Some(String::new())"),
  79         _ => {}
  80     }
  81 }
  82
  83 #[test]
  84 fn test_match_option_string() {
  85     let five = "Five".to_string();
  86     match Some(five) {
  87         Some(s) => assert_eq!(s, "Five"),
  88         None => panic!("{}", "unexpected None while matching on Some(String { ... })"),
  89     }
  90 }
  91
  92 mod atom {
  93     use core::num::NonZeroU32;
  94
  95     #[derive(PartialEq, Eq)]
  96     pub struct Atom {
  97         index: NonZeroU32, // private
  98     }
  99     pub const FOO_ATOM: Atom = Atom { index: unsafe { NonZeroU32::new_unchecked(7) } };
 100 }
 101
 102 macro_rules! atom {
 103     ("foo") => {
 104         atom::FOO_ATOM
 105     };
 106 }
 107
 108 #[test]
 109 fn test_match_nonzero_const_pattern() {
 110     match atom!("foo") {
 111         // Using as a pattern is supported by the compiler:
 112         atom!("foo") => {}
 113         _ => panic!("Expected the const item as a pattern to match."),
 114     }
 115 }
 116
 117 #[test]
 118 fn test_from_nonzero() {
 119     let nz = NonZeroU32::new(1).unwrap();
 120     let num: u32 = nz.into();
 121     assert_eq!(num, 1u32);
 122 }
 123
 124 #[test]
 125 fn test_from_signed_nonzero() {
 126     let nz = NonZeroI32::new(1).unwrap();
 127     let num: i32 = nz.into();
 128     assert_eq!(num, 1i32);
 129 }
 130
 131 #[test]
 132 fn test_from_str() {
 133     assert_eq!("123".parse::<NonZeroU8>(), Ok(NonZeroU8::new(123).unwrap()));
 134     assert_eq!("0".parse::<NonZeroU8>().err().map(|e| e.kind().clone()), Some(IntErrorKind::Zero));
 135     assert_eq!(
 136         "-1".parse::<NonZeroU8>().err().map(|e| e.kind().clone()),
 137         Some(IntErrorKind::InvalidDigit)
 138     );
 139     assert_eq!(
 140         "-129".parse::<NonZeroI8>().err().map(|e| e.kind().clone()),
 141         Some(IntErrorKind::NegOverflow)
 142     );
 143     assert_eq!(
 144         "257".parse::<NonZeroU8>().err().map(|e| e.kind().clone()),
 145         Some(IntErrorKind::PosOverflow)
 146     );
 147 }
 148
 149 #[test]
 150 fn test_nonzero_bitor() {
 151     let nz_alt = NonZeroU8::new(0b1010_1010).unwrap();
 152     let nz_low = NonZeroU8::new(0b0000_1111).unwrap();
 153
 154     let both_nz: NonZeroU8 = nz_alt | nz_low;
 155     assert_eq!(both_nz.get(), 0b1010_1111);
 156
 157     let rhs_int: NonZeroU8 = nz_low | 0b1100_0000u8;
 158     assert_eq!(rhs_int.get(), 0b1100_1111);
 159
 160     let rhs_zero: NonZeroU8 = nz_alt | 0u8;
 161     assert_eq!(rhs_zero.get(), 0b1010_1010);
 162
 163     let lhs_int: NonZeroU8 = 0b0110_0110u8 | nz_alt;
 164     assert_eq!(lhs_int.get(), 0b1110_1110);
 165
 166     let lhs_zero: NonZeroU8 = 0u8 | nz_low;
 167     assert_eq!(lhs_zero.get(), 0b0000_1111);
 168 }
 169
 170 #[test]
 171 fn test_nonzero_bitor_assign() {
 172     let mut target = NonZeroU8::new(0b1010_1010).unwrap();
 173
 174     target |= NonZeroU8::new(0b0000_1111).unwrap();
 175     assert_eq!(target.get(), 0b1010_1111);
 176
 177     target |= 0b0001_0000;
 178     assert_eq!(target.get(), 0b1011_1111);
 179
 180     target |= 0;
 181     assert_eq!(target.get(), 0b1011_1111);
 182 }
 183
 184 #[test]
 185 fn test_nonzero_from_int_on_success() {
 186     assert_eq!(NonZeroU8::try_from(5), Ok(NonZeroU8::new(5).unwrap()));
 187     assert_eq!(NonZeroU32::try_from(5), Ok(NonZeroU32::new(5).unwrap()));
 188
 189     assert_eq!(NonZeroI8::try_from(-5), Ok(NonZeroI8::new(-5).unwrap()));
 190     assert_eq!(NonZeroI32::try_from(-5), Ok(NonZeroI32::new(-5).unwrap()));
 191 }
 192
 193 #[test]
 194 fn test_nonzero_from_int_on_err() {
 195     assert!(NonZeroU8::try_from(0).is_err());
 196     assert!(NonZeroU32::try_from(0).is_err());
 197
 198     assert!(NonZeroI8::try_from(0).is_err());
 199     assert!(NonZeroI32::try_from(0).is_err());
 200 }
 201
 202 #[test]
 203 fn nonzero_const() {
 204     // test that the methods of `NonZeroX>` are usable in a const context
 205     // Note: only tests NonZero8
 206
 207     const NONZERO_U8: NonZeroU8 = unsafe { NonZeroU8::new_unchecked(5) };
 208
 209     const GET: u8 = NONZERO_U8.get();
 210     assert_eq!(GET, 5);
 211
 212     const ZERO: Option<NonZeroU8> = NonZeroU8::new(0);
 213     assert!(ZERO.is_none());
 214
 215     const ONE: Option<NonZeroU8> = NonZeroU8::new(1);
 216     assert!(ONE.is_some());
 217
 218     const FROM_NONZERO_U8: u8 = u8::from(NONZERO_U8);
 219     assert_eq!(FROM_NONZERO_U8, 5);
 220
 221     const NONZERO_CONVERT: NonZeroU32 = NonZeroU32::from(NONZERO_U8);
 222     assert_eq!(NONZERO_CONVERT.get(), 5);
 223 }
 224
 225 #[test]
 226 fn nonzero_leading_zeros() {
 227     assert_eq!(NonZeroU8::new(1).unwrap().leading_zeros(), 7);
 228     assert_eq!(NonZeroI8::new(1).unwrap().leading_zeros(), 7);
 229     assert_eq!(NonZeroU16::new(1).unwrap().leading_zeros(), 15);
 230     assert_eq!(NonZeroI16::new(1).unwrap().leading_zeros(), 15);
 231     assert_eq!(NonZeroU32::new(1).unwrap().leading_zeros(), 31);
 232     assert_eq!(NonZeroI32::new(1).unwrap().leading_zeros(), 31);
 233     assert_eq!(NonZeroU64::new(1).unwrap().leading_zeros(), 63);
 234     assert_eq!(NonZeroI64::new(1).unwrap().leading_zeros(), 63);
 235     assert_eq!(NonZeroU128::new(1).unwrap().leading_zeros(), 127);
 236     assert_eq!(NonZeroI128::new(1).unwrap().leading_zeros(), 127);
 237     assert_eq!(NonZeroUsize::new(1).unwrap().leading_zeros(), usize::BITS - 1);
 238     assert_eq!(NonZeroIsize::new(1).unwrap().leading_zeros(), usize::BITS - 1);
 239
 240     assert_eq!(NonZeroU8::new(u8::MAX >> 2).unwrap().leading_zeros(), 2);
 241     assert_eq!(NonZeroI8::new((u8::MAX >> 2) as i8).unwrap().leading_zeros(), 2);
 242     assert_eq!(NonZeroU16::new(u16::MAX >> 2).unwrap().leading_zeros(), 2);
 243     assert_eq!(NonZeroI16::new((u16::MAX >> 2) as i16).unwrap().leading_zeros(), 2);
 244     assert_eq!(NonZeroU32::new(u32::MAX >> 2).unwrap().leading_zeros(), 2);
 245     assert_eq!(NonZeroI32::new((u32::MAX >> 2) as i32).unwrap().leading_zeros(), 2);
 246     assert_eq!(NonZeroU64::new(u64::MAX >> 2).unwrap().leading_zeros(), 2);
 247     assert_eq!(NonZeroI64::new((u64::MAX >> 2) as i64).unwrap().leading_zeros(), 2);
 248     assert_eq!(NonZeroU128::new(u128::MAX >> 2).unwrap().leading_zeros(), 2);
 249     assert_eq!(NonZeroI128::new((u128::MAX >> 2) as i128).unwrap().leading_zeros(), 2);
 250     assert_eq!(NonZeroUsize::new(usize::MAX >> 2).unwrap().leading_zeros(), 2);
 251     assert_eq!(NonZeroIsize::new((usize::MAX >> 2) as isize).unwrap().leading_zeros(), 2);
 252
 253     assert_eq!(NonZeroU8::new(u8::MAX).unwrap().leading_zeros(), 0);
 254     assert_eq!(NonZeroI8::new(-1i8).unwrap().leading_zeros(), 0);
 255     assert_eq!(NonZeroU16::new(u16::MAX).unwrap().leading_zeros(), 0);
 256     assert_eq!(NonZeroI16::new(-1i16).unwrap().leading_zeros(), 0);
 257     assert_eq!(NonZeroU32::new(u32::MAX).unwrap().leading_zeros(), 0);
 258     assert_eq!(NonZeroI32::new(-1i32).unwrap().leading_zeros(), 0);
 259     assert_eq!(NonZeroU64::new(u64::MAX).unwrap().leading_zeros(), 0);
 260     assert_eq!(NonZeroI64::new(-1i64).unwrap().leading_zeros(), 0);
 261     assert_eq!(NonZeroU128::new(u128::MAX).unwrap().leading_zeros(), 0);
 262     assert_eq!(NonZeroI128::new(-1i128).unwrap().leading_zeros(), 0);
 263     assert_eq!(NonZeroUsize::new(usize::MAX).unwrap().leading_zeros(), 0);
 264     assert_eq!(NonZeroIsize::new(-1isize).unwrap().leading_zeros(), 0);
 265
 266     const LEADING_ZEROS: u32 = NonZeroU16::new(1).unwrap().leading_zeros();
 267     assert_eq!(LEADING_ZEROS, 15);
 268 }
 269
 270 #[test]
 271 fn nonzero_trailing_zeros() {
 272     assert_eq!(NonZeroU8::new(1).unwrap().trailing_zeros(), 0);
 273     assert_eq!(NonZeroI8::new(1).unwrap().trailing_zeros(), 0);
 274     assert_eq!(NonZeroU16::new(1).unwrap().trailing_zeros(), 0);
 275     assert_eq!(NonZeroI16::new(1).unwrap().trailing_zeros(), 0);
 276     assert_eq!(NonZeroU32::new(1).unwrap().trailing_zeros(), 0);
 277     assert_eq!(NonZeroI32::new(1).unwrap().trailing_zeros(), 0);
 278     assert_eq!(NonZeroU64::new(1).unwrap().trailing_zeros(), 0);
 279     assert_eq!(NonZeroI64::new(1).unwrap().trailing_zeros(), 0);
 280     assert_eq!(NonZeroU128::new(1).unwrap().trailing_zeros(), 0);
 281     assert_eq!(NonZeroI128::new(1).unwrap().trailing_zeros(), 0);
 282     assert_eq!(NonZeroUsize::new(1).unwrap().trailing_zeros(), 0);
 283     assert_eq!(NonZeroIsize::new(1).unwrap().trailing_zeros(), 0);
 284
 285     assert_eq!(NonZeroU8::new(1 << 2).unwrap().trailing_zeros(), 2);
 286     assert_eq!(NonZeroI8::new(1 << 2).unwrap().trailing_zeros(), 2);
 287     assert_eq!(NonZeroU16::new(1 << 2).unwrap().trailing_zeros(), 2);
 288     assert_eq!(NonZeroI16::new(1 << 2).unwrap().trailing_zeros(), 2);
 289     assert_eq!(NonZeroU32::new(1 << 2).unwrap().trailing_zeros(), 2);
 290     assert_eq!(NonZeroI32::new(1 << 2).unwrap().trailing_zeros(), 2);
 291     assert_eq!(NonZeroU64::new(1 << 2).unwrap().trailing_zeros(), 2);
 292     assert_eq!(NonZeroI64::new(1 << 2).unwrap().trailing_zeros(), 2);
 293     assert_eq!(NonZeroU128::new(1 << 2).unwrap().trailing_zeros(), 2);
 294     assert_eq!(NonZeroI128::new(1 << 2).unwrap().trailing_zeros(), 2);
 295     assert_eq!(NonZeroUsize::new(1 << 2).unwrap().trailing_zeros(), 2);
 296     assert_eq!(NonZeroIsize::new(1 << 2).unwrap().trailing_zeros(), 2);
 297
 298     assert_eq!(NonZeroU8::new(1 << 7).unwrap().trailing_zeros(), 7);
 299     assert_eq!(NonZeroI8::new(1 << 7).unwrap().trailing_zeros(), 7);
 300     assert_eq!(NonZeroU16::new(1 << 15).unwrap().trailing_zeros(), 15);
 301     assert_eq!(NonZeroI16::new(1 << 15).unwrap().trailing_zeros(), 15);
 302     assert_eq!(NonZeroU32::new(1 << 31).unwrap().trailing_zeros(), 31);
 303     assert_eq!(NonZeroI32::new(1 << 31).unwrap().trailing_zeros(), 31);
 304     assert_eq!(NonZeroU64::new(1 << 63).unwrap().trailing_zeros(), 63);
 305     assert_eq!(NonZeroI64::new(1 << 63).unwrap().trailing_zeros(), 63);
 306     assert_eq!(NonZeroU128::new(1 << 127).unwrap().trailing_zeros(), 127);
 307     assert_eq!(NonZeroI128::new(1 << 127).unwrap().trailing_zeros(), 127);
 308
 309     assert_eq!(
 310         NonZeroUsize::new(1 << (usize::BITS - 1)).unwrap().trailing_zeros(),
 311         usize::BITS - 1
 312     );
 313     assert_eq!(
 314         NonZeroIsize::new(1 << (usize::BITS - 1)).unwrap().trailing_zeros(),
 315         usize::BITS - 1
 316     );
 317
 318     const TRAILING_ZEROS: u32 = NonZeroU16::new(1 << 2).unwrap().trailing_zeros();
 319     assert_eq!(TRAILING_ZEROS, 2);
 320 }
 321
 322 #[test]
 323 fn test_nonzero_uint_div() {
 324     let nz = NonZeroU32::new(1).unwrap();
 325
 326     let x: u32 = 42u32 / nz;
 327     assert_eq!(x, 42u32);
 328 }
 329
 330 #[test]
 331 fn test_nonzero_uint_rem() {
 332     let nz = NonZeroU32::new(10).unwrap();
 333
 334     let x: u32 = 42u32 % nz;
 335     assert_eq!(x, 2u32);
 336 }