| mod control_flow; |
| |
| use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive}; |
| use core::ops::{Deref, DerefMut}; |
| |
| // Test the Range structs and syntax. |
| |
| #[test] |
| fn test_range() { |
| let r = Range { start: 2, end: 10 }; |
| let mut count = 0; |
| for (i, ri) in r.enumerate() { |
| assert_eq!(ri, i + 2); |
| assert!(ri >= 2 && ri < 10); |
| count += 1; |
| } |
| assert_eq!(count, 8); |
| } |
| |
| #[test] |
| fn test_range_from() { |
| let r = RangeFrom { start: 2 }; |
| let mut count = 0; |
| for (i, ri) in r.take(10).enumerate() { |
| assert_eq!(ri, i + 2); |
| assert!(ri >= 2 && ri < 12); |
| count += 1; |
| } |
| assert_eq!(count, 10); |
| } |
| |
| #[test] |
| fn test_range_to() { |
| // Not much to test. |
| let _ = RangeTo { end: 42 }; |
| } |
| |
| #[test] |
| fn test_full_range() { |
| // Not much to test. |
| let _ = RangeFull; |
| } |
| |
| #[test] |
| fn test_range_inclusive() { |
| let mut r = RangeInclusive::new(1i8, 2); |
| assert_eq!(r.next(), Some(1)); |
| assert_eq!(r.next(), Some(2)); |
| assert_eq!(r.next(), None); |
| |
| r = RangeInclusive::new(127i8, 127); |
| assert_eq!(r.next(), Some(127)); |
| assert_eq!(r.next(), None); |
| |
| r = RangeInclusive::new(-128i8, -128); |
| assert_eq!(r.next_back(), Some(-128)); |
| assert_eq!(r.next_back(), None); |
| |
| // degenerate |
| r = RangeInclusive::new(1, -1); |
| assert_eq!(r.size_hint(), (0, Some(0))); |
| assert_eq!(r.next(), None); |
| } |
| |
| #[test] |
| fn test_range_to_inclusive() { |
| // Not much to test. |
| let _ = RangeToInclusive { end: 42 }; |
| } |
| |
| #[test] |
| fn test_range_is_empty() { |
| assert!(!(0.0..10.0).is_empty()); |
| assert!((-0.0..0.0).is_empty()); |
| assert!((10.0..0.0).is_empty()); |
| |
| assert!(!(f32::NEG_INFINITY..f32::INFINITY).is_empty()); |
| assert!((f32::EPSILON..f32::NAN).is_empty()); |
| assert!((f32::NAN..f32::EPSILON).is_empty()); |
| assert!((f32::NAN..f32::NAN).is_empty()); |
| |
| assert!(!(0.0..=10.0).is_empty()); |
| assert!(!(-0.0..=0.0).is_empty()); |
| assert!((10.0..=0.0).is_empty()); |
| |
| assert!(!(f32::NEG_INFINITY..=f32::INFINITY).is_empty()); |
| assert!((f32::EPSILON..=f32::NAN).is_empty()); |
| assert!((f32::NAN..=f32::EPSILON).is_empty()); |
| assert!((f32::NAN..=f32::NAN).is_empty()); |
| } |
| |
| #[test] |
| fn test_bound_cloned_unbounded() { |
| assert_eq!(Bound::<&u32>::Unbounded.cloned(), Bound::Unbounded); |
| } |
| |
| #[test] |
| fn test_bound_cloned_included() { |
| assert_eq!(Bound::Included(&3).cloned(), Bound::Included(3)); |
| } |
| |
| #[test] |
| fn test_bound_cloned_excluded() { |
| assert_eq!(Bound::Excluded(&3).cloned(), Bound::Excluded(3)); |
| } |
| |
| #[test] |
| #[allow(unused_comparisons)] |
| #[allow(unused_mut)] |
| fn test_range_syntax() { |
| let mut count = 0; |
| for i in 0_usize..10 { |
| assert!(i >= 0 && i < 10); |
| count += i; |
| } |
| assert_eq!(count, 45); |
| |
| let mut count = 0; |
| let mut range = 0_usize..10; |
| for i in range { |
| assert!(i >= 0 && i < 10); |
| count += i; |
| } |
| assert_eq!(count, 45); |
| |
| let mut count = 0; |
| let mut rf = 3_usize..; |
| for i in rf.take(10) { |
| assert!(i >= 3 && i < 13); |
| count += i; |
| } |
| assert_eq!(count, 75); |
| |
| let _ = 0_usize..4 + 4 - 3; |
| |
| fn foo() -> isize { |
| 42 |
| } |
| let _ = 0..foo(); |
| |
| let _ = { &42..&100 }; // references to literals are OK |
| let _ = ..42_usize; |
| |
| // Test we can use two different types with a common supertype. |
| let x = &42; |
| { |
| let y = 42; |
| let _ = x..&y; |
| } |
| } |
| |
| #[test] |
| #[allow(dead_code)] |
| fn test_range_syntax_in_return_statement() { |
| fn return_range_to() -> RangeTo<i32> { |
| return ..1; |
| } |
| fn return_full_range() -> RangeFull { |
| return ..; |
| } |
| // Not much to test. |
| } |
| |
| #[test] |
| fn range_structural_match() { |
| // test that all range types can be structurally matched upon |
| |
| const RANGE: Range<usize> = 0..1000; |
| match RANGE { |
| RANGE => {} |
| _ => unreachable!(), |
| } |
| |
| const RANGE_FROM: RangeFrom<usize> = 0..; |
| match RANGE_FROM { |
| RANGE_FROM => {} |
| _ => unreachable!(), |
| } |
| |
| const RANGE_FULL: RangeFull = ..; |
| match RANGE_FULL { |
| RANGE_FULL => {} |
| } |
| |
| const RANGE_INCLUSIVE: RangeInclusive<usize> = 0..=999; |
| match RANGE_INCLUSIVE { |
| RANGE_INCLUSIVE => {} |
| _ => unreachable!(), |
| } |
| |
| const RANGE_TO: RangeTo<usize> = ..1000; |
| match RANGE_TO { |
| RANGE_TO => {} |
| _ => unreachable!(), |
| } |
| |
| const RANGE_TO_INCLUSIVE: RangeToInclusive<usize> = ..=999; |
| match RANGE_TO_INCLUSIVE { |
| RANGE_TO_INCLUSIVE => {} |
| _ => unreachable!(), |
| } |
| } |
| |
| // Test Deref implementations |
| |
| #[test] |
| fn deref_mut_on_ref() { |
| // Test that `&mut T` implements `DerefMut<T>` |
| |
| fn inc<T: Deref<Target = isize> + DerefMut>(mut t: T) { |
| *t += 1; |
| } |
| |
| let mut x: isize = 5; |
| inc(&mut x); |
| assert_eq!(x, 6); |
| } |
| |
| #[test] |
| fn deref_on_ref() { |
| // Test that `&T` and `&mut T` implement `Deref<T>` |
| |
| fn deref<U: Copy, T: Deref<Target = U>>(t: T) -> U { |
| *t |
| } |
| |
| let x: isize = 3; |
| let y = deref(&x); |
| assert_eq!(y, 3); |
| |
| let mut x: isize = 4; |
| let y = deref(&mut x); |
| assert_eq!(y, 4); |
| } |
| |
| #[test] |
| #[allow(unreachable_code)] |
| fn test_not_never() { |
| if !return () {} |
| } |