---

yaml
---
r: 38769
b: refs/heads/incoming
c: 19a59cb
h: refs/heads/master
i:
  38767: 7062199
v: v3

Author: 14427

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
-refs/heads/incoming: fb61f915db842ec06e6531237f5c73112dd1c7a0
+refs/heads/incoming: 19a59cb748b6715cd940eb6fa5ae4e1841dcfcf4
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libstd/sort.rs

@@ -1032,11 +1032,6 @@ mod big_tests {
         tabulate_managed(low, high);
     }
 
-    #[test]
-    fn test_linear() {
-        tabulate_linear();
-    }
-
     fn multiplyVec<T: Copy>(arr: &[const T], num: uint) -> ~[mut T] {
         let size = arr.len();
         let res = do vec::from_fn(num) |i| {
@@ -1125,12 +1120,11 @@ mod big_tests {
     }
 
     fn tabulate_managed(lo: uint, hi: uint) {
-        fn isSorted<T: Ord>(arr: &[const @T], expected_refcount: uint) {
+        fn isSorted<T: Ord>(arr: &[const @T]) {
             for uint::range(0, arr.len()-1) |i| {
                 if arr[i] > arr[i+1] {
                     fail ~"Array not sorted";
                 }
-                assert sys::refcount(arr[i]) == expected_refcount;
             }
         }
 
@@ -1144,22 +1138,22 @@ mod big_tests {
             let arr = vec::to_mut(move arr);
 
             tim_sort(arr); // *sort
-            isSorted(arr, 1);
+            isSorted(arr);
 
             vec::reverse(arr);
             tim_sort(arr); // \sort
-            isSorted(arr, 1);
+            isSorted(arr);
 
             tim_sort(arr); // /sort
-            isSorted(arr, 1);
+            isSorted(arr);
 
             for 3.times {
                 let i1 = rng.gen_uint_range(0, n);
                 let i2 = rng.gen_uint_range(0, n);
                 arr[i1] <-> arr[i2];
             }
             tim_sort(arr); // 3sort
-            isSorted(arr, 1);
+            isSorted(arr);
 
             if n >= 10 {
                 let size = arr.len();
@@ -1170,7 +1164,7 @@ mod big_tests {
                 }
             }
             tim_sort(arr); // +sort
-            isSorted(arr, 1);
+            isSorted(arr);
 
             for (n/100).times {
                 let idx = rng.gen_uint_range(0, n);
@@ -1184,16 +1178,16 @@ mod big_tests {
                 multiplyVec(part, n)
             } else { move arr };
             tim_sort(arr); // ~sort
-            isSorted(arr, n/4+1);
+            isSorted(arr);
 
             let mut arr = vec::from_elem(n, @(-0.5));
             tim_sort(arr); // =sort
-            isSorted(arr, n);
+            isSorted(arr);
 
             let half = n / 2;
             let mut arr = makeRange(half).map(|i| @(*i as float));
             tim_sort(arr); // !sort
-            isSorted(arr, 1);
+            isSorted(arr);
         }
     }
 
@@ -1220,36 +1214,6 @@ mod big_tests {
         pure fn gt(other: &LVal) -> bool { self.val > other.val }
         pure fn ge(other: &LVal) -> bool { self.val >= other.val }
     }
-
-    fn tabulate_linear() {
-        fn key(_x: @uint) { }
-        fn isSorted<T: Ord>(arr: &[const T]) {
-            for uint::range(0, arr.len()-1) |i| {
-                if arr[i] > arr[i+1] {
-                    fail ~"Array not sorted";
-                }
-            }
-        }
-
-        let n = 1000;
-        unsafe {
-            task::local_data::local_data_set(key, @0u);
-        }
-
-        {
-            let mut arr = do vec::from_fn(n) |i| {
-                LVal { val: i, key: key }
-            };
-            tim_sort(arr);
-            isSorted(arr);
-        }
-
-        let @dropped = unsafe {
-            task::local_data::local_data_get(key).get()
-        };
-
-        assert n == dropped;
-    }
 }
 
 // Local Variables: