]>
Commit | Line | Data |
---|---|---|
416331ca | 1 | // run-pass |
54a0048b | 2 | // Test inclusive range syntax. |
8faf50e0 | 3 | #![feature(range_is_empty)] |
ba9703b0 | 4 | #![allow(unused_braces)] |
8faf50e0 XL |
5 | #![allow(unused_comparisons)] |
6 | ||
7 | use std::ops::RangeToInclusive; | |
54a0048b SL |
8 | |
9 | fn foo() -> isize { 42 } | |
10 | ||
11 | // Test that range syntax works in return statements | |
8faf50e0 XL |
12 | pub fn return_range_to() -> RangeToInclusive<i32> { return ..=1; } |
13 | ||
14 | #[derive(Debug)] | |
15 | struct P(u8); | |
54a0048b SL |
16 | |
17 | pub fn main() { | |
18 | let mut count = 0; | |
ea8adc8c | 19 | for i in 0_usize..=10 { |
54a0048b SL |
20 | assert!(i >= 0 && i <= 10); |
21 | count += i; | |
22 | } | |
23 | assert_eq!(count, 55); | |
24 | ||
25 | let mut count = 0; | |
8faf50e0 | 26 | let range = 0_usize..=10; |
54a0048b SL |
27 | for i in range { |
28 | assert!(i >= 0 && i <= 10); | |
29 | count += i; | |
30 | } | |
31 | assert_eq!(count, 55); | |
32 | ||
33 | let mut count = 0; | |
ea8adc8c | 34 | for i in (0_usize..=10).step_by(2) { |
54a0048b SL |
35 | assert!(i >= 0 && i <= 10 && i % 2 == 0); |
36 | count += i; | |
37 | } | |
38 | assert_eq!(count, 30); | |
39 | ||
ea8adc8c XL |
40 | let _ = 0_usize..=4+4-3; |
41 | let _ = 0..=foo(); | |
54a0048b | 42 | |
ea8adc8c XL |
43 | let _ = { &42..=&100 }; // references to literals are OK |
44 | let _ = ..=42_usize; | |
54a0048b SL |
45 | |
46 | // Test we can use two different types with a common supertype. | |
47 | let x = &42; | |
48 | { | |
49 | let y = 42; | |
ea8adc8c | 50 | let _ = x..=&y; |
54a0048b SL |
51 | } |
52 | ||
53 | // test collection indexing | |
ea8adc8c | 54 | let vec = (0..=10).collect::<Vec<_>>(); |
54a0048b SL |
55 | let slice: &[_] = &*vec; |
56 | let string = String::from("hello world"); | |
57 | let stir = "hello world"; | |
58 | ||
ea8adc8c XL |
59 | assert_eq!(&vec[3..=6], &[3, 4, 5, 6]); |
60 | assert_eq!(&vec[ ..=6], &[0, 1, 2, 3, 4, 5, 6]); | |
54a0048b | 61 | |
ea8adc8c XL |
62 | assert_eq!(&slice[3..=6], &[3, 4, 5, 6]); |
63 | assert_eq!(&slice[ ..=6], &[0, 1, 2, 3, 4, 5, 6]); | |
54a0048b | 64 | |
ea8adc8c XL |
65 | assert_eq!(&string[3..=6], "lo w"); |
66 | assert_eq!(&string[ ..=6], "hello w"); | |
54a0048b | 67 | |
ea8adc8c XL |
68 | assert_eq!(&stir[3..=6], "lo w"); |
69 | assert_eq!(&stir[ ..=6], "hello w"); | |
54a0048b SL |
70 | |
71 | // test the size hints and emptying | |
ea8adc8c XL |
72 | let mut long = 0..=255u8; |
73 | let mut short = 42..=42u8; | |
54a0048b SL |
74 | assert_eq!(long.size_hint(), (256, Some(256))); |
75 | assert_eq!(short.size_hint(), (1, Some(1))); | |
76 | long.next(); | |
77 | short.next(); | |
78 | assert_eq!(long.size_hint(), (255, Some(255))); | |
79 | assert_eq!(short.size_hint(), (0, Some(0))); | |
8faf50e0 | 80 | assert!(short.is_empty()); |
54a0048b SL |
81 | |
82 | assert_eq!(long.len(), 255); | |
83 | assert_eq!(short.len(), 0); | |
84 | ||
85 | // test iterating backwards | |
86 | assert_eq!(long.next_back(), Some(255)); | |
87 | assert_eq!(long.next_back(), Some(254)); | |
88 | assert_eq!(long.next_back(), Some(253)); | |
89 | assert_eq!(long.next(), Some(1)); | |
90 | assert_eq!(long.next(), Some(2)); | |
91 | assert_eq!(long.next_back(), Some(252)); | |
ea8adc8c | 92 | for i in 3..=251 { |
54a0048b SL |
93 | assert_eq!(long.next(), Some(i)); |
94 | } | |
8faf50e0 | 95 | assert!(long.is_empty()); |
54a0048b SL |
96 | |
97 | // check underflow | |
ea8adc8c | 98 | let mut narrow = 1..=0; |
54a0048b | 99 | assert_eq!(narrow.next_back(), None); |
8faf50e0 | 100 | assert!(narrow.is_empty()); |
ea8adc8c | 101 | let mut zero = 0u8..=0; |
54a0048b SL |
102 | assert_eq!(zero.next_back(), Some(0)); |
103 | assert_eq!(zero.next_back(), None); | |
8faf50e0 | 104 | assert!(zero.is_empty()); |
ea8adc8c | 105 | let mut high = 255u8..=255; |
54a0048b SL |
106 | assert_eq!(high.next_back(), Some(255)); |
107 | assert_eq!(high.next_back(), None); | |
8faf50e0 | 108 | assert!(high.is_empty()); |
54a0048b SL |
109 | |
110 | // what happens if you have a nonsense range? | |
ea8adc8c | 111 | let mut nonsense = 10..=5; |
54a0048b | 112 | assert_eq!(nonsense.next(), None); |
8faf50e0 | 113 | assert!(nonsense.is_empty()); |
54a0048b | 114 | |
54a0048b | 115 | // output |
ea8adc8c XL |
116 | assert_eq!(format!("{:?}", 0..=10), "0..=10"); |
117 | assert_eq!(format!("{:?}", ..=10), "..=10"); | |
8faf50e0 XL |
118 | assert_eq!(format!("{:?}", 9..=6), "9..=6"); |
119 | ||
120 | // ensure that constructing a RangeInclusive does not need PartialOrd bound | |
121 | assert_eq!(format!("{:?}", P(1)..=P(2)), "P(1)..=P(2)"); | |
54a0048b | 122 | } |