tests: Move run-pass tests without naming conflicts to ui

9 files changed, 270 insertions, 0 deletions

diff --git a/src/test/ui/iterators/into-iterator-type-inference-shift.rs b/src/test/ui/iterators/into-iterator-type-inference-shift.rs
new file mode 100644
index 00000000000..9151172fd15
--- /dev/null
+++ b/src/test/ui/iterators/into-iterator-type-inference-shift.rs
@@ -0,0 +1,36 @@
+// run-pass
+#![allow(unused_must_use)]
+#![allow(dead_code)]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+// Regression test for type inference failure around shifting. In this
+// case, the iteration yields an isize, but we hadn't run the full type
+// propagation yet, and so we just saw a type variable, yielding an
+// error.
+
+// pretty-expanded FIXME #23616
+
+trait IntoIterator {
+    type Iter: Iterator;
+
+    fn into_iter(self) -> Self::Iter;
+}
+
+impl<I> IntoIterator for I where I: Iterator {
+    type Iter = I;
+
+    fn into_iter(self) -> I {
+        self
+    }
+}
+
+fn desugared_for_loop_bad(byte: u8) -> u8 {
+    let mut result = 0;
+    let mut x = IntoIterator::into_iter(0..8);
+    let mut y = Iterator::next(&mut x);
+    let mut z = y.unwrap();
+    byte >> z;
+    1
+}
+
+fn main() {}
diff --git a/src/test/ui/iterators/iter-cloned-type-inference.rs b/src/test/ui/iterators/iter-cloned-type-inference.rs
new file mode 100644
index 00000000000..898e3371971
--- /dev/null
+++ b/src/test/ui/iterators/iter-cloned-type-inference.rs
@@ -0,0 +1,16 @@
+// run-pass
+#![allow(stable_features)]
+
+// Test to see that the element type of .cloned() can be inferred
+// properly. Previously this would fail to deduce the type of `sum`.
+
+#![feature(iter_arith)]
+
+fn square_sum(v: &[i64]) -> i64 {
+    let sum: i64 = v.iter().cloned().sum();
+    sum * sum
+}
+
+fn main() {
+    assert_eq!(36, square_sum(&[1,2,3]));
+}
diff --git a/src/test/ui/iterators/iter-range.rs b/src/test/ui/iterators/iter-range.rs
new file mode 100644
index 00000000000..993d93790e0
--- /dev/null
+++ b/src/test/ui/iterators/iter-range.rs
@@ -0,0 +1,14 @@
+// run-pass
+
+
+fn range_<F>(a: isize, b: isize, mut it: F) where F: FnMut(isize) {
+    assert!((a < b));
+    let mut i: isize = a;
+    while i < b { it(i); i += 1; }
+}
+
+pub fn main() {
+    let mut sum: isize = 0;
+    range_(0, 100, |x| sum += x );
+    println!("{}", sum);
+}
diff --git a/src/test/ui/iterators/iter-step-overflow-debug.rs b/src/test/ui/iterators/iter-step-overflow-debug.rs
new file mode 100644
index 00000000000..5d67c7cbb42
--- /dev/null
+++ b/src/test/ui/iterators/iter-step-overflow-debug.rs
@@ -0,0 +1,21 @@
+// run-pass
+// ignore-wasm32-bare compiled with panic=abort by default
+// compile-flags: -C debug_assertions=yes
+
+use std::panic;
+
+fn main() {
+    let r = panic::catch_unwind(|| {
+        let mut it = u8::max_value()..;
+        it.next().unwrap(); // 255
+        it.next().unwrap();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        let mut it = i8::max_value()..;
+        it.next().unwrap(); // 127
+        it.next().unwrap();
+    });
+    assert!(r.is_err());
+}
diff --git a/src/test/ui/iterators/iter-step-overflow-ndebug.rs b/src/test/ui/iterators/iter-step-overflow-ndebug.rs
new file mode 100644
index 00000000000..a0ad92071b6
--- /dev/null
+++ b/src/test/ui/iterators/iter-step-overflow-ndebug.rs
@@ -0,0 +1,12 @@
+// run-pass
+// compile-flags: -C debug_assertions=no
+
+fn main() {
+    let mut it = u8::max_value()..;
+    assert_eq!(it.next().unwrap(), 255);
+    assert_eq!(it.next().unwrap(), u8::min_value());
+
+    let mut it = i8::max_value()..;
+    assert_eq!(it.next().unwrap(), 127);
+    assert_eq!(it.next().unwrap(), i8::min_value());
+}
diff --git a/src/test/ui/iterators/iter-sum-overflow-debug.rs b/src/test/ui/iterators/iter-sum-overflow-debug.rs
new file mode 100644
index 00000000000..ee4ab4d24c6
--- /dev/null
+++ b/src/test/ui/iterators/iter-sum-overflow-debug.rs
@@ -0,0 +1,27 @@
+// run-pass
+// ignore-wasm32-bare compiled with panic=abort by default
+// compile-flags: -C debug_assertions=yes
+
+use std::panic;
+
+fn main() {
+    let r = panic::catch_unwind(|| {
+        [1, i32::max_value()].iter().sum::<i32>();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        [2, i32::max_value()].iter().product::<i32>();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        [1, i32::max_value()].iter().cloned().sum::<i32>();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        [2, i32::max_value()].iter().cloned().product::<i32>();
+    });
+    assert!(r.is_err());
+}
diff --git a/src/test/ui/iterators/iter-sum-overflow-ndebug.rs b/src/test/ui/iterators/iter-sum-overflow-ndebug.rs
new file mode 100644
index 00000000000..61d63d41fb8
--- /dev/null
+++ b/src/test/ui/iterators/iter-sum-overflow-ndebug.rs
@@ -0,0 +1,14 @@
+// run-pass
+// compile-flags: -C debug_assertions=no
+
+fn main() {
+    assert_eq!([1i32, i32::max_value()].iter().sum::<i32>(),
+               1i32.wrapping_add(i32::max_value()));
+    assert_eq!([2i32, i32::max_value()].iter().product::<i32>(),
+               2i32.wrapping_mul(i32::max_value()));
+
+    assert_eq!([1i32, i32::max_value()].iter().cloned().sum::<i32>(),
+               1i32.wrapping_add(i32::max_value()));
+    assert_eq!([2i32, i32::max_value()].iter().cloned().product::<i32>(),
+               2i32.wrapping_mul(i32::max_value()));
+}
diff --git a/src/test/ui/iterators/iter-sum-overflow-overflow-checks.rs b/src/test/ui/iterators/iter-sum-overflow-overflow-checks.rs
new file mode 100644
index 00000000000..429f8e0bc96
--- /dev/null
+++ b/src/test/ui/iterators/iter-sum-overflow-overflow-checks.rs
@@ -0,0 +1,27 @@
+// run-pass
+// ignore-wasm32-bare compiled with panic=abort by default
+// compile-flags: -C overflow-checks
+
+use std::panic;
+
+fn main() {
+    let r = panic::catch_unwind(|| {
+        [1, i32::max_value()].iter().sum::<i32>();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        [2, i32::max_value()].iter().product::<i32>();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        [1, i32::max_value()].iter().cloned().sum::<i32>();
+    });
+    assert!(r.is_err());
+
+    let r = panic::catch_unwind(|| {
+        [2, i32::max_value()].iter().cloned().product::<i32>();
+    });
+    assert!(r.is_err());
+}
diff --git a/src/test/ui/iterators/iter-zip.rs b/src/test/ui/iterators/iter-zip.rs
new file mode 100644
index 00000000000..a76fa2408bb
--- /dev/null
+++ b/src/test/ui/iterators/iter-zip.rs
@@ -0,0 +1,103 @@
+// run-pass
+// Test that .zip() specialization preserves side effects
+// in sideeffectful iterator adaptors.
+
+use std::cell::Cell;
+
+#[derive(Debug)]
+struct CountClone(Cell<i32>);
+
+fn count_clone() -> CountClone { CountClone(Cell::new(0)) }
+
+impl PartialEq<i32> for CountClone {
+    fn eq(&self, rhs: &i32) -> bool {
+        self.0.get() == *rhs
+    }
+}
+
+impl Clone for CountClone {
+    fn clone(&self) -> Self {
+        let ret = CountClone(self.0.clone());
+        let n = self.0.get();
+        self.0.set(n + 1);
+        ret
+    }
+}
+
+fn test_zip_cloned_sideffectful() {
+    let xs = [count_clone(), count_clone(), count_clone(), count_clone()];
+    let ys = [count_clone(), count_clone()];
+
+    for _ in xs.iter().cloned().zip(ys.iter().cloned()) { }
+
+    assert_eq!(&xs, &[1, 1, 1, 0][..]);
+    assert_eq!(&ys, &[1, 1][..]);
+
+    let xs = [count_clone(), count_clone()];
+    let ys = [count_clone(), count_clone(), count_clone(), count_clone()];
+
+    for _ in xs.iter().cloned().zip(ys.iter().cloned()) { }
+
+    assert_eq!(&xs, &[1, 1][..]);
+    assert_eq!(&ys, &[1, 1, 0, 0][..]);
+}
+
+fn test_zip_map_sideffectful() {
+    let mut xs = [0; 6];
+    let mut ys = [0; 4];
+
+    for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) { }
+
+    assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
+    assert_eq!(&ys, &[1, 1, 1, 1]);
+
+    let mut xs = [0; 4];
+    let mut ys = [0; 6];
+
+    for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) { }
+
+    assert_eq!(&xs, &[1, 1, 1, 1]);
+    assert_eq!(&ys, &[1, 1, 1, 1, 0, 0]);
+}
+
+fn test_zip_map_rev_sideffectful() {
+    let mut xs = [0; 6];
+    let mut ys = [0; 4];
+
+    {
+        let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
+        it.next_back();
+    }
+    assert_eq!(&xs, &[0, 0, 0, 1, 1, 1]);
+    assert_eq!(&ys, &[0, 0, 0, 1]);
+
+    let mut xs = [0; 6];
+    let mut ys = [0; 4];
+
+    {
+        let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
+        (&mut it).take(5).count();
+        it.next_back();
+    }
+    assert_eq!(&xs, &[1, 1, 1, 1, 1, 1]);
+    assert_eq!(&ys, &[1, 1, 1, 1]);
+}
+
+fn test_zip_nested_sideffectful() {
+    let mut xs = [0; 6];
+    let ys = [0; 4];
+
+    {
+        // test that it has the side effect nested inside enumerate
+        let it = xs.iter_mut().map(|x| *x = 1).enumerate().zip(&ys);
+        it.count();
+    }
+    assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
+}
+
+fn main() {
+    test_zip_cloned_sideffectful();
+    test_zip_map_sideffectful();
+    test_zip_map_rev_sideffectful();
+    test_zip_nested_sideffectful();
+}