library/core/tests/ops.rs

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