3 use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
4 use core::ops::{Deref, DerefMut};
6 // Test the Range structs and syntax.
10 let r = Range { start: 2, end: 10 };
12 for (i, ri) in r.enumerate() {
13 assert_eq!(ri, i + 2);
14 assert!(ri >= 2 && ri < 10);
21 fn test_range_from() {
22 let r = RangeFrom { start: 2 };
24 for (i, ri) in r.take(10).enumerate() {
25 assert_eq!(ri, i + 2);
26 assert!(ri >= 2 && ri < 12);
29 assert_eq!(count, 10);
35 let _ = RangeTo { end: 42 };
39 fn test_full_range() {
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);
51 r = RangeInclusive::new(127i8, 127);
52 assert_eq!(r.next(), Some(127));
53 assert_eq!(r.next(), None);
55 r = RangeInclusive::new(-128i8, -128);
56 assert_eq!(r.next_back(), Some(-128));
57 assert_eq!(r.next_back(), None);
60 r = RangeInclusive::new(1, -1);
61 assert_eq!(r.size_hint(), (0, Some(0)));
62 assert_eq!(r.next(), None);
66 fn test_range_to_inclusive() {
68 let _ = RangeToInclusive { end: 42 };
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());
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());
82 assert!(!(0.0..=10.0).is_empty());
83 assert!(!(-0.0..=0.0).is_empty());
84 assert!((10.0..=0.0).is_empty());
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());
93 fn test_bound_cloned_unbounded() {
94 assert_eq!(Bound::<&u32>::Unbounded.cloned(), Bound::Unbounded);
98 fn test_bound_cloned_included() {
99 assert_eq!(Bound::Included(&3).cloned(), Bound::Included(3));
103 fn test_bound_cloned_excluded() {
104 assert_eq!(Bound::Excluded(&3).cloned(), Bound::Excluded(3));
108 #[allow(unused_comparisons)]
110 fn test_range_syntax() {
112 for i in 0_usize..10 {
113 assert!(i >= 0 && i < 10);
116 assert_eq!(count, 45);
119 let mut range = 0_usize..10;
121 assert!(i >= 0 && i < 10);
124 assert_eq!(count, 45);
127 let mut rf = 3_usize..;
128 for i in rf.take(10) {
129 assert!(i >= 3 && i < 13);
132 assert_eq!(count, 75);
134 let _ = 0_usize..4 + 4 - 3;
141 let _ = { &42..&100 }; // references to literals are OK
144 // Test we can use two different types with a common supertype.
154 fn test_range_syntax_in_return_statement() {
155 fn return_range_to() -> RangeTo<i32> {
158 fn return_full_range() -> RangeFull {
165 fn range_structural_match() {
166 // test that all range types can be structurally matched upon
168 const RANGE: Range<usize> = 0..1000;
174 const RANGE_FROM: RangeFrom<usize> = 0..;
180 const RANGE_FULL: RangeFull = ..;
185 const RANGE_INCLUSIVE: RangeInclusive<usize> = 0..=999;
186 match RANGE_INCLUSIVE {
187 RANGE_INCLUSIVE => {}
191 const RANGE_TO: RangeTo<usize> = ..1000;
197 const RANGE_TO_INCLUSIVE: RangeToInclusive<usize> = ..=999;
198 match RANGE_TO_INCLUSIVE {
199 RANGE_TO_INCLUSIVE => {}
204 // Test Deref implementations
207 fn deref_mut_on_ref() {
208 // Test that `&mut T` implements `DerefMut<T>`
210 fn inc<T: Deref<Target = isize> + DerefMut>(mut t: T) {
214 let mut x: isize = 5;
221 // Test that `&T` and `&mut T` implement `Deref<T>`
223 fn deref<U: Copy, T: Deref<Target = U>>(t: T) -> U {
231 let mut x: isize = 4;
232 let y = deref(&mut x);
237 #[allow(unreachable_code)]
238 fn test_not_never() {