]>
Commit | Line | Data |
---|---|---|
54a0048b SL |
1 | // Copyright 2016 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | // Test inclusive range syntax. | |
12 | ||
13 | #![feature(inclusive_range_syntax, inclusive_range, step_by)] | |
14 | ||
15 | use std::ops::{RangeInclusive, RangeToInclusive}; | |
16 | ||
17 | fn foo() -> isize { 42 } | |
18 | ||
19 | // Test that range syntax works in return statements | |
20 | fn return_range_to() -> RangeToInclusive<i32> { return ...1; } | |
21 | ||
22 | pub fn main() { | |
23 | let mut count = 0; | |
24 | for i in 0_usize...10 { | |
25 | assert!(i >= 0 && i <= 10); | |
26 | count += i; | |
27 | } | |
28 | assert_eq!(count, 55); | |
29 | ||
30 | let mut count = 0; | |
31 | let mut range = 0_usize...10; | |
32 | for i in range { | |
33 | assert!(i >= 0 && i <= 10); | |
34 | count += i; | |
35 | } | |
36 | assert_eq!(count, 55); | |
37 | ||
38 | let mut count = 0; | |
39 | for i in (0_usize...10).step_by(2) { | |
40 | assert!(i >= 0 && i <= 10 && i % 2 == 0); | |
41 | count += i; | |
42 | } | |
43 | assert_eq!(count, 30); | |
44 | ||
45 | let _ = 0_usize...4+4-3; | |
46 | let _ = 0...foo(); | |
47 | ||
48 | let _ = { &42...&100 }; // references to literals are OK | |
49 | let _ = ...42_usize; | |
50 | ||
51 | // Test we can use two different types with a common supertype. | |
52 | let x = &42; | |
53 | { | |
54 | let y = 42; | |
55 | let _ = x...&y; | |
56 | } | |
57 | ||
58 | // test collection indexing | |
59 | let vec = (0...10).collect::<Vec<_>>(); | |
60 | let slice: &[_] = &*vec; | |
61 | let string = String::from("hello world"); | |
62 | let stir = "hello world"; | |
63 | ||
64 | assert_eq!(&vec[3...6], &[3, 4, 5, 6]); | |
65 | assert_eq!(&vec[ ...6], &[0, 1, 2, 3, 4, 5, 6]); | |
66 | ||
67 | assert_eq!(&slice[3...6], &[3, 4, 5, 6]); | |
68 | assert_eq!(&slice[ ...6], &[0, 1, 2, 3, 4, 5, 6]); | |
69 | ||
70 | assert_eq!(&string[3...6], "lo w"); | |
71 | assert_eq!(&string[ ...6], "hello w"); | |
72 | ||
73 | assert_eq!(&stir[3...6], "lo w"); | |
74 | assert_eq!(&stir[ ...6], "hello w"); | |
75 | ||
76 | // test the size hints and emptying | |
77 | let mut long = 0...255u8; | |
c30ab7b3 | 78 | let mut short = 42...42u8; |
54a0048b SL |
79 | assert_eq!(long.size_hint(), (256, Some(256))); |
80 | assert_eq!(short.size_hint(), (1, Some(1))); | |
81 | long.next(); | |
82 | short.next(); | |
83 | assert_eq!(long.size_hint(), (255, Some(255))); | |
84 | assert_eq!(short.size_hint(), (0, Some(0))); | |
85 | assert_eq!(short, RangeInclusive::Empty { at: 42 }); | |
86 | ||
87 | assert_eq!(long.len(), 255); | |
88 | assert_eq!(short.len(), 0); | |
89 | ||
90 | // test iterating backwards | |
91 | assert_eq!(long.next_back(), Some(255)); | |
92 | assert_eq!(long.next_back(), Some(254)); | |
93 | assert_eq!(long.next_back(), Some(253)); | |
94 | assert_eq!(long.next(), Some(1)); | |
95 | assert_eq!(long.next(), Some(2)); | |
96 | assert_eq!(long.next_back(), Some(252)); | |
97 | for i in 3...251 { | |
98 | assert_eq!(long.next(), Some(i)); | |
99 | } | |
100 | assert_eq!(long, RangeInclusive::Empty { at: 251 }); | |
101 | ||
102 | // check underflow | |
103 | let mut narrow = 1...0; | |
104 | assert_eq!(narrow.next_back(), None); | |
105 | assert_eq!(narrow, RangeInclusive::Empty { at: 0 }); | |
106 | let mut zero = 0u8...0; | |
107 | assert_eq!(zero.next_back(), Some(0)); | |
108 | assert_eq!(zero.next_back(), None); | |
109 | assert_eq!(zero, RangeInclusive::Empty { at: 0 }); | |
110 | let mut high = 255u8...255; | |
111 | assert_eq!(high.next_back(), Some(255)); | |
112 | assert_eq!(high.next_back(), None); | |
113 | assert_eq!(high, RangeInclusive::Empty { at: 255 }); | |
114 | ||
115 | // what happens if you have a nonsense range? | |
116 | let mut nonsense = 10...5; | |
117 | assert_eq!(nonsense.next(), None); | |
118 | assert_eq!(nonsense, RangeInclusive::Empty { at: 10 }); | |
119 | ||
54a0048b SL |
120 | // output |
121 | assert_eq!(format!("{:?}", 0...10), "0...10"); | |
122 | assert_eq!(format!("{:?}", ...10), "...10"); | |
123 | assert_eq!(format!("{:?}", long), "[empty range @ 251]"); | |
124 | } |