---

yaml
---
r: 191343
b: refs/heads/try
c: b07a1df
h: refs/heads/master
i:
  191341: 5064bd3
  191339: 876b6c3
  191335: c1916a4
  191327: fb3ef19
v: v3

Author: rprichard

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 809a554fca2d0ebc2ba50077016fe282a4064752
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c64d671671aea2e44ee7fc6eb00ee75fc30ed7b9
-refs/heads/try: e46610966f798a083350724461648c6ffdd151f4
+refs/heads/try: b07a1dfcd12348541e81c809b59af9ff56fc1103
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/dist.mk

@@ -53,7 +53,6 @@ PKG_FILES := \
       driver                                   \
       etc                                      \
       $(foreach crate,$(CRATES),lib$(crate))   \
-      libcollectionstest                       \
       libcoretest                              \
       libbacktrace                             \
       rt                                       \

branches/try/mk/target.mk

@@ -72,6 +72,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): CFG_COMPILER_HOST_TRIPLE = $(2)
 $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 		$$(CRATEFILE_$(4)) \
 		$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4)) \
+		$$(LLVM_CONFIG_$(2)) \
 		$$(TSREQ$(1)_T_$(2)_H_$(3)) \
 		| $$(TLIB$(1)_T_$(2)_H_$(3))/
 	@$$(call E, rustc: $$(@D)/lib$(4))

branches/try/mk/tests.mk

@@ -19,10 +19,7 @@
 DEPS_coretest :=
 $(eval $(call RUST_CRATE,coretest))
 
-DEPS_collectionstest :=
-$(eval $(call RUST_CRATE,collectionstest))
-
-TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) collectionstest coretest
+TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
 TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve rustc_trans rustc_lint,\
                      $(HOST_CRATES))

branches/try/src/compiletest/compiletest.rs

@@ -20,6 +20,7 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(core)]
+#![feature(net)]
 #![feature(path_ext)]
 
 #![deny(warnings)]

branches/try/src/liballoc/heap.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[cfg(stage0)]
 #[cfg(not(test))]
 use core::ptr::PtrExt;
 
@@ -388,6 +387,7 @@ mod imp {
 mod test {
     extern crate test;
     use self::test::Bencher;
+    use core::ptr::PtrExt;
     use boxed::Box;
     use heap;
 

branches/try/src/liballoc/rc.rs

@@ -159,10 +159,7 @@ use core::nonzero::NonZero;
 use core::ops::{Deref, Drop};
 use core::option::Option;
 use core::option::Option::{Some, None};
-#[cfg(stage0)]
 use core::ptr::{self, PtrExt};
-#[cfg(not(stage0))]
-use core::ptr;
 use core::result::Result;
 use core::result::Result::{Ok, Err};
 use core::intrinsics::assume;

branches/try/src/libarena/lib.rs

@@ -46,7 +46,6 @@ use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
 use std::marker;
 use std::mem;
-#[cfg(stage0)]
 use std::num::{Int, UnsignedInt};
 use std::ptr;
 use std::rc::Rc;

branches/try/src/libcollectionstest/bench.rs renamed to branches/try/src/libcollections/bench.rs

@@ -66,11 +66,11 @@ macro_rules! map_find_rand_bench {
     ($name: ident, $n: expr, $map: ident) => (
         #[bench]
         pub fn $name(b: &mut ::test::Bencher) {
+            use std::rand;
             use std::iter::IteratorExt;
             use std::rand::Rng;
-            use std::rand;
-            use std::vec::Vec;
             use test::black_box;
+            use vec::Vec;
 
             let mut map = $map::new();
             let n: usize = $n;

branches/try/src/libcollections/binary_heap.rs

@@ -693,3 +693,218 @@ impl<T: Ord> Extend<T> for BinaryHeap<T> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+
+    use super::BinaryHeap;
+
+    #[test]
+    fn test_iterator() {
+        let data = vec![5, 9, 3];
+        let iterout = [9, 5, 3];
+        let heap = BinaryHeap::from_vec(data);
+        let mut i = 0;
+        for el in &heap {
+            assert_eq!(*el, iterout[i]);
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn test_iterator_reverse() {
+        let data = vec![5, 9, 3];
+        let iterout = vec![3, 5, 9];
+        let pq = BinaryHeap::from_vec(data);
+
+        let v: Vec<_> = pq.iter().rev().cloned().collect();
+        assert_eq!(v, iterout);
+    }
+
+    #[test]
+    fn test_move_iter() {
+        let data = vec![5, 9, 3];
+        let iterout = vec![9, 5, 3];
+        let pq = BinaryHeap::from_vec(data);
+
+        let v: Vec<_> = pq.into_iter().collect();
+        assert_eq!(v, iterout);
+    }
+
+    #[test]
+    fn test_move_iter_size_hint() {
+        let data = vec![5, 9];
+        let pq = BinaryHeap::from_vec(data);
+
+        let mut it = pq.into_iter();
+
+        assert_eq!(it.size_hint(), (2, Some(2)));
+        assert_eq!(it.next(), Some(9));
+
+        assert_eq!(it.size_hint(), (1, Some(1)));
+        assert_eq!(it.next(), Some(5));
+
+        assert_eq!(it.size_hint(), (0, Some(0)));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn test_move_iter_reverse() {
+        let data = vec![5, 9, 3];
+        let iterout = vec![3, 5, 9];
+        let pq = BinaryHeap::from_vec(data);
+
+        let v: Vec<_> = pq.into_iter().rev().collect();
+        assert_eq!(v, iterout);
+    }
+
+    #[test]
+    fn test_peek_and_pop() {
+        let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
+        let mut sorted = data.clone();
+        sorted.sort();
+        let mut heap = BinaryHeap::from_vec(data);
+        while !heap.is_empty() {
+            assert_eq!(heap.peek().unwrap(), sorted.last().unwrap());
+            assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
+        }
+    }
+
+    #[test]
+    fn test_push() {
+        let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
+        assert_eq!(heap.len(), 3);
+        assert!(*heap.peek().unwrap() == 9);
+        heap.push(11);
+        assert_eq!(heap.len(), 4);
+        assert!(*heap.peek().unwrap() == 11);
+        heap.push(5);
+        assert_eq!(heap.len(), 5);
+        assert!(*heap.peek().unwrap() == 11);
+        heap.push(27);
+        assert_eq!(heap.len(), 6);
+        assert!(*heap.peek().unwrap() == 27);
+        heap.push(3);
+        assert_eq!(heap.len(), 7);
+        assert!(*heap.peek().unwrap() == 27);
+        heap.push(103);
+        assert_eq!(heap.len(), 8);
+        assert!(*heap.peek().unwrap() == 103);
+    }
+
+    #[test]
+    fn test_push_unique() {
+        let mut heap = BinaryHeap::<Box<_>>::from_vec(vec![box 2, box 4, box 9]);
+        assert_eq!(heap.len(), 3);
+        assert!(*heap.peek().unwrap() == box 9);
+        heap.push(box 11);
+        assert_eq!(heap.len(), 4);
+        assert!(*heap.peek().unwrap() == box 11);
+        heap.push(box 5);
+        assert_eq!(heap.len(), 5);
+        assert!(*heap.peek().unwrap() == box 11);
+        heap.push(box 27);
+        assert_eq!(heap.len(), 6);
+        assert!(*heap.peek().unwrap() == box 27);
+        heap.push(box 3);
+        assert_eq!(heap.len(), 7);
+        assert!(*heap.peek().unwrap() == box 27);
+        heap.push(box 103);
+        assert_eq!(heap.len(), 8);
+        assert!(*heap.peek().unwrap() == box 103);
+    }
+
+    #[test]
+    fn test_push_pop() {
+        let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.push_pop(6), 6);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.push_pop(0), 5);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.push_pop(4), 5);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.push_pop(1), 4);
+        assert_eq!(heap.len(), 5);
+    }
+
+    #[test]
+    fn test_replace() {
+        let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.replace(6).unwrap(), 5);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.replace(0).unwrap(), 6);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.replace(4).unwrap(), 5);
+        assert_eq!(heap.len(), 5);
+        assert_eq!(heap.replace(1).unwrap(), 4);
+        assert_eq!(heap.len(), 5);
+    }
+
+    fn check_to_vec(mut data: Vec<i32>) {
+        let heap = BinaryHeap::from_vec(data.clone());
+        let mut v = heap.clone().into_vec();
+        v.sort();
+        data.sort();
+
+        assert_eq!(v, data);
+        assert_eq!(heap.into_sorted_vec(), data);
+    }
+
+    #[test]
+    fn test_to_vec() {
+        check_to_vec(vec![]);
+        check_to_vec(vec![5]);
+        check_to_vec(vec![3, 2]);
+        check_to_vec(vec![2, 3]);
+        check_to_vec(vec![5, 1, 2]);
+        check_to_vec(vec![1, 100, 2, 3]);
+        check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
+        check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
+        check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
+        check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
+        check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
+        check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
+    }
+
+    #[test]
+    fn test_empty_pop() {
+        let mut heap = BinaryHeap::<i32>::new();
+        assert!(heap.pop().is_none());
+    }
+
+    #[test]
+    fn test_empty_peek() {
+        let empty = BinaryHeap::<i32>::new();
+        assert!(empty.peek().is_none());
+    }
+
+    #[test]
+    fn test_empty_replace() {
+        let mut heap = BinaryHeap::new();
+        assert!(heap.replace(5).is_none());
+    }
+
+    #[test]
+    fn test_from_iter() {
+        let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
+
+        for &x in &xs {
+            assert_eq!(q.pop().unwrap(), x);
+        }
+    }
+
+    #[test]
+    fn test_drain() {
+        let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+
+        assert_eq!(q.drain().take(5).count(), 5);
+
+        assert!(q.is_empty());
+    }
+}