rust/tests/ui/range/range_inclusive.rs
Jubilee Young d89500843c Move 100 entries from tests/ui into subdirs
- Move super-fast-paren-parsing test into ui/parser
- Move stmt_expr_attrs test into ui/feature-gates
- Move macro tests into ui/macros
- Move global_asm tests into ui/asm
- Move env tests into ui/process
- Move xcrate tests into ui/cross-crate
- Move unop tests into ui/unop
- Move backtrace tests into ui/backtrace
- Move check-static tests into ui/statics
- Move expr tests into ui/expr
- Move optimization fuel tests into ui/fuel
- Move ffi attribute tests into ui/ffi-attrs
- Move suggestion tests into ui/suggestions
- Move main tests into ui/fn-main
- Move lint tests into ui/lint
- Move repr tests into ui/repr
- Move intrinsics tests into ui/intrinsics
- Move tool lint tests into ui/tool-attributes
- Move return tests into ui/return
- Move pattern tests into ui/patttern
- Move range tests into ui/range
- Move foreign-fn tests into ui/foreign
- Move orphan-check tests into ui/coherence
- Move inference tests into ui/inference
- Reduce ROOT_ENTRY_LIMIT
2024-05-20 19:55:59 -07:00

122 lines
3.3 KiB
Rust

//@ run-pass
// Test inclusive range syntax.
#![allow(unused_braces)]
#![allow(unused_comparisons)]
use std::ops::RangeToInclusive;
fn foo() -> isize { 42 }
// Test that range syntax works in return statements
pub fn return_range_to() -> RangeToInclusive<i32> { return ..=1; }
#[derive(Debug)]
struct P(#[allow(dead_code)] u8);
pub fn main() {
let mut count = 0;
for i in 0_usize..=10 {
assert!(i >= 0 && i <= 10);
count += i;
}
assert_eq!(count, 55);
let mut count = 0;
let range = 0_usize..=10;
for i in range {
assert!(i >= 0 && i <= 10);
count += i;
}
assert_eq!(count, 55);
let mut count = 0;
for i in (0_usize..=10).step_by(2) {
assert!(i >= 0 && i <= 10 && i % 2 == 0);
count += i;
}
assert_eq!(count, 30);
let _ = 0_usize..=4+4-3;
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 collection indexing
let vec = (0..=10).collect::<Vec<_>>();
let slice: &[_] = &*vec;
let string = String::from("hello world");
let stir = "hello world";
assert_eq!(&vec[3..=6], &[3, 4, 5, 6]);
assert_eq!(&vec[ ..=6], &[0, 1, 2, 3, 4, 5, 6]);
assert_eq!(&slice[3..=6], &[3, 4, 5, 6]);
assert_eq!(&slice[ ..=6], &[0, 1, 2, 3, 4, 5, 6]);
assert_eq!(&string[3..=6], "lo w");
assert_eq!(&string[ ..=6], "hello w");
assert_eq!(&stir[3..=6], "lo w");
assert_eq!(&stir[ ..=6], "hello w");
// test the size hints and emptying
let mut long = 0..=255u8;
let mut short = 42..=42u8;
assert_eq!(long.size_hint(), (256, Some(256)));
assert_eq!(short.size_hint(), (1, Some(1)));
long.next();
short.next();
assert_eq!(long.size_hint(), (255, Some(255)));
assert_eq!(short.size_hint(), (0, Some(0)));
assert!(short.is_empty());
assert_eq!(long.len(), 255);
assert_eq!(short.len(), 0);
// test iterating backwards
assert_eq!(long.next_back(), Some(255));
assert_eq!(long.next_back(), Some(254));
assert_eq!(long.next_back(), Some(253));
assert_eq!(long.next(), Some(1));
assert_eq!(long.next(), Some(2));
assert_eq!(long.next_back(), Some(252));
for i in 3..=251 {
assert_eq!(long.next(), Some(i));
}
assert!(long.is_empty());
// check underflow
let mut narrow = 1..=0;
assert_eq!(narrow.next_back(), None);
assert!(narrow.is_empty());
let mut zero = 0u8..=0;
assert_eq!(zero.next_back(), Some(0));
assert_eq!(zero.next_back(), None);
assert!(zero.is_empty());
let mut high = 255u8..=255;
assert_eq!(high.next_back(), Some(255));
assert_eq!(high.next_back(), None);
assert!(high.is_empty());
// what happens if you have a nonsense range?
let mut nonsense = 10..=5;
assert_eq!(nonsense.next(), None);
assert!(nonsense.is_empty());
// output
assert_eq!(format!("{:?}", 0..=10), "0..=10");
assert_eq!(format!("{:?}", ..=10), "..=10");
assert_eq!(format!("{:?}", 9..=6), "9..=6");
// ensure that constructing a RangeInclusive does not need PartialOrd bound
assert_eq!(format!("{:?}", P(1)..=P(2)), "P(1)..=P(2)");
}