library/core/tests/ops.rs

   1 use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
   2 use core::ops::{Deref, DerefMut};
   3
   4 // Test the Range structs and syntax.
   5
   6 #[test]
   7 fn test_range() {
   8     let r = Range { start: 2, end: 10 };
   9     let mut count = 0;
  10     for (i, ri) in r.enumerate() {
  11         assert_eq!(ri, i + 2);
  12         assert!(ri >= 2 && ri < 10);
  13         count += 1;
  14     }
  15     assert_eq!(count, 8);
  16 }
  17
  18 #[test]
  19 fn test_range_from() {
  20     let r = RangeFrom { start: 2 };
  21     let mut count = 0;
  22     for (i, ri) in r.take(10).enumerate() {
  23         assert_eq!(ri, i + 2);
  24         assert!(ri >= 2 && ri < 12);
  25         count += 1;
  26     }
  27     assert_eq!(count, 10);
  28 }
  29
  30 #[test]
  31 fn test_range_to() {
  32     // Not much to test.
  33     let _ = RangeTo { end: 42 };
  34 }
  35
  36 #[test]
  37 fn test_full_range() {
  38     // Not much to test.
  39     let _ = RangeFull;
  40 }
  41
  42 #[test]
  43 fn test_range_inclusive() {
  44     let mut r = RangeInclusive::new(1i8, 2);
  45     assert_eq!(r.next(), Some(1));
  46     assert_eq!(r.next(), Some(2));
  47     assert_eq!(r.next(), None);
  48
  49     r = RangeInclusive::new(127i8, 127);
  50     assert_eq!(r.next(), Some(127));
  51     assert_eq!(r.next(), None);
  52
  53     r = RangeInclusive::new(-128i8, -128);
  54     assert_eq!(r.next_back(), Some(-128));
  55     assert_eq!(r.next_back(), None);
  56
  57     // degenerate
  58     r = RangeInclusive::new(1, -1);
  59     assert_eq!(r.size_hint(), (0, Some(0)));
  60     assert_eq!(r.next(), None);
  61 }
  62
  63 #[test]
  64 fn test_range_to_inclusive() {
  65     // Not much to test.
  66     let _ = RangeToInclusive { end: 42 };
  67 }
  68
  69 #[test]
  70 fn test_range_is_empty() {
  71     assert!(!(0.0..10.0).is_empty());
  72     assert!((-0.0..0.0).is_empty());
  73     assert!((10.0..0.0).is_empty());
  74
  75     assert!(!(f32::NEG_INFINITY..f32::INFINITY).is_empty());
  76     assert!((f32::EPSILON..f32::NAN).is_empty());
  77     assert!((f32::NAN..f32::EPSILON).is_empty());
  78     assert!((f32::NAN..f32::NAN).is_empty());
  79
  80     assert!(!(0.0..=10.0).is_empty());
  81     assert!(!(-0.0..=0.0).is_empty());
  82     assert!((10.0..=0.0).is_empty());
  83
  84     assert!(!(f32::NEG_INFINITY..=f32::INFINITY).is_empty());
  85     assert!((f32::EPSILON..=f32::NAN).is_empty());
  86     assert!((f32::NAN..=f32::EPSILON).is_empty());
  87     assert!((f32::NAN..=f32::NAN).is_empty());
  88 }
  89
  90 #[test]
  91 fn test_bound_cloned_unbounded() {
  92     assert_eq!(Bound::<&u32>::Unbounded.cloned(), Bound::Unbounded);
  93 }
  94
  95 #[test]
  96 fn test_bound_cloned_included() {
  97     assert_eq!(Bound::Included(&3).cloned(), Bound::Included(3));
  98 }
  99
 100 #[test]
 101 fn test_bound_cloned_excluded() {
 102     assert_eq!(Bound::Excluded(&3).cloned(), Bound::Excluded(3));
 103 }
 104
 105 #[test]
 106 #[allow(unused_comparisons)]
 107 #[allow(unused_mut)]
 108 fn test_range_syntax() {
 109     let mut count = 0;
 110     for i in 0_usize..10 {
 111         assert!(i >= 0 && i < 10);
 112         count += i;
 113     }
 114     assert_eq!(count, 45);
 115
 116     let mut count = 0;
 117     let mut range = 0_usize..10;
 118     for i in range {
 119         assert!(i >= 0 && i < 10);
 120         count += i;
 121     }
 122     assert_eq!(count, 45);
 123
 124     let mut count = 0;
 125     let mut rf = 3_usize..;
 126     for i in rf.take(10) {
 127         assert!(i >= 3 && i < 13);
 128         count += i;
 129     }
 130     assert_eq!(count, 75);
 131
 132     let _ = 0_usize..4 + 4 - 3;
 133
 134     fn foo() -> isize {
 135         42
 136     }
 137     let _ = 0..foo();
 138
 139     let _ = { &42..&100 }; // references to literals are OK
 140     let _ = ..42_usize;
 141
 142     // Test we can use two different types with a common supertype.
 143     let x = &42;
 144     {
 145         let y = 42;
 146         let _ = x..&y;
 147     }
 148 }
 149
 150 #[test]
 151 #[allow(dead_code)]
 152 fn test_range_syntax_in_return_statement() {
 153     fn return_range_to() -> RangeTo<i32> {
 154         return ..1;
 155     }
 156     fn return_full_range() -> RangeFull {
 157         return ..;
 158     }
 159     // Not much to test.
 160 }
 161
 162 #[test]
 163 fn range_structural_match() {
 164     // test that all range types can be structurally matched upon
 165
 166     const RANGE: Range<usize> = 0..1000;
 167     match RANGE {
 168         RANGE => {}
 169         _ => unreachable!(),
 170     }
 171
 172     const RANGE_FROM: RangeFrom<usize> = 0..;
 173     match RANGE_FROM {
 174         RANGE_FROM => {}
 175         _ => unreachable!(),
 176     }
 177
 178     const RANGE_FULL: RangeFull = ..;
 179     match RANGE_FULL {
 180         RANGE_FULL => {}
 181     }
 182
 183     const RANGE_INCLUSIVE: RangeInclusive<usize> = 0..=999;
 184     match RANGE_INCLUSIVE {
 185         RANGE_INCLUSIVE => {}
 186         _ => unreachable!(),
 187     }
 188
 189     const RANGE_TO: RangeTo<usize> = ..1000;
 190     match RANGE_TO {
 191         RANGE_TO => {}
 192         _ => unreachable!(),
 193     }
 194
 195     const RANGE_TO_INCLUSIVE: RangeToInclusive<usize> = ..=999;
 196     match RANGE_TO_INCLUSIVE {
 197         RANGE_TO_INCLUSIVE => {}
 198         _ => unreachable!(),
 199     }
 200 }
 201
 202 // Test Deref implementations
 203
 204 #[test]
 205 fn deref_mut_on_ref() {
 206     // Test that `&mut T` implements `DerefMut<T>`
 207
 208     fn inc<T: Deref<Target = isize> + DerefMut>(mut t: T) {
 209         *t += 1;
 210     }
 211
 212     let mut x: isize = 5;
 213     inc(&mut x);
 214     assert_eq!(x, 6);
 215 }
 216
 217 #[test]
 218 fn deref_on_ref() {
 219     // Test that `&T` and `&mut T` implement `Deref<T>`
 220
 221     fn deref<U: Copy, T: Deref<Target = U>>(t: T) -> U {
 222         *t
 223     }
 224
 225     let x: isize = 3;
 226     let y = deref(&x);
 227     assert_eq!(y, 3);
 228
 229     let mut x: isize = 4;
 230     let y = deref(&mut x);
 231     assert_eq!(y, 4);
 232 }