Fix tests. Add Vec<u8> conversion to StrBuf.

src/test/bench/shootout-chameneos-redux.rs

@@ -32,53 +32,62 @@ struct CreatureInfo {
     color: color
 }
 
-fn show_color(cc: color) -> ~str {
+fn show_color(cc: color) -> &'static str {
     match cc {
-        Red    => {~"red"}
-        Yellow => {~"yellow"}
-        Blue   => {~"blue"}
+        Red    => "red",
+        Yellow => "yellow",
+        Blue   => "blue"
     }
 }
 
-fn show_color_list(set: Vec<color>) -> ~str {
+fn show_color_list(set: Vec<color>) -> StrBuf {
     let mut out = StrBuf::new();
     for col in set.iter() {
         out.push_char(' ');
         out.push_str(show_color(*col));
     }
-    return out.to_owned_str();
+    out
 }
 
-fn show_digit(nn: uint) -> ~str {
+fn show_digit(nn: uint) -> &'static str {
     match nn {
-        0 => {~"zero"}
-        1 => {~"one"}
-        2 => {~"two"}
-        3 => {~"three"}
-        4 => {~"four"}
-        5 => {~"five"}
-        6 => {~"six"}
-        7 => {~"seven"}
-        8 => {~"eight"}
-        9 => {~"nine"}
+        0 => {"zero"}
+        1 => {"one"}
+        2 => {"two"}
+        3 => {"three"}
+        4 => {"four"}
+        5 => {"five"}
+        6 => {"six"}
+        7 => {"seven"}
+        8 => {"eight"}
+        9 => {"nine"}
         _ => {fail!("expected digits from 0 to 9...")}
     }
 }
 
-fn show_number(nn: uint) -> ~str {
-    let mut out = ~"";
+fn show_number(nn: uint) -> StrBuf {
+    let mut out = vec![];
     let mut num = nn;
     let mut dig;
-
-    if num == 0 { out = show_digit(0) };
+    let mut len = 0;
+    if num == 0 { out.push(show_digit(0)) };
 
     while num != 0 {
         dig = num % 10;
         num = num / 10;
-        out = show_digit(dig) + " " + out;
+        out.push(" ");
+        let s = show_digit(dig);
+        out.push(s);
+        len += 1 + s.len();
     }
+    len += 1;
+    out.push(" ");
 
-    return ~" " + out;
+    let mut ret = StrBuf::with_capacity(len);
+    for s in out.iter().rev() {
+        ret.push_str(*s);
+    }
+    ret
 }
 
 fn transform(aa: color, bb: color) -> color {
@@ -125,7 +134,7 @@ fn creature(
             option::None => {
                 // log creatures met and evil clones of self
                 let report = format!("{} {}",
-                                     creatures_met, show_number(evil_clones_met));
+                                     creatures_met, show_number(evil_clones_met).as_slice());
                 to_rendezvous_log.send(report);
                 break;
             }

src/test/bench/shootout-k-nucleotide-pipes.rs

@@ -15,17 +15,11 @@
 
 extern crate collections;
 
-use std::cmp::Ord;
-use std::comm;
 use collections::HashMap;
 use std::mem::replace;
 use std::option;
 use std::os;
-use std::io;
-use std::str;
 use std::strbuf::StrBuf;
-use std::task;
-use std::vec;
 
 fn f64_cmp(x: f64, y: f64) -> Ordering {
     // arbitrarily decide that NaNs are larger than everything.
@@ -66,16 +60,14 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> ~str {
 
    let mut buffer = StrBuf::new();
    for &(ref k, v) in pairs_sorted.iter() {
-       unsafe {
-           buffer.push_str(format!("{} {:0.3f}\n",
-                                   k.as_slice()
-                                    .to_ascii()
-                                    .to_upper()
-                                    .into_str(), v));
-       }
+       buffer.push_str(format!("{} {:0.3f}\n",
+                               k.as_slice()
+                               .to_ascii()
+                               .to_upper()
+                               .into_str(), v));
    }
 
-   return buffer.to_owned_str();
+   return buffer.into_owned();
 }
 
 // given a map, search for the frequency of a pattern

src/test/bench/shootout-k-nucleotide.rs

@@ -11,8 +11,6 @@
 // ignore-android see #10393 #13206
 // ignore-pretty
 
-use std::ascii::OwnedStrAsciiExt;
-use std::str;
 use std::strbuf::StrBuf;
 use std::slice;
 
@@ -50,8 +48,7 @@ impl Code {
         string.bytes().fold(Code(0u64), |a, b| a.push_char(b))
     }
 
-    // FIXME: Inefficient.
-    fn unpack(&self, frame: uint) -> ~str {
+    fn unpack(&self, frame: uint) -> StrBuf {
         let mut key = self.hash();
         let mut result = Vec::new();
         for _ in range(0, frame) {
@@ -60,7 +57,7 @@ impl Code {
         }
 
         result.reverse();
-        str::from_utf8_owned(result.move_iter().collect()).unwrap()
+        StrBuf::from_utf8(result).unwrap()
     }
 }
 
@@ -239,7 +236,7 @@ fn print_frequencies(frequencies: &Table, frame: uint) {
 
     for &(count, key) in vector.iter().rev() {
         println!("{} {:.3f}",
-                 key.unpack(frame),
+                 key.unpack(frame).as_slice(),
                  (count as f32 * 100.0) / (total_count as f32));
     }
     println!("");
@@ -249,14 +246,17 @@ fn print_occurrences(frequencies: &mut Table, occurrence: &'static str) {
     frequencies.lookup(Code::pack(occurrence), PrintCallback(occurrence))
 }
 
-fn get_sequence<R: Buffer>(r: &mut R, key: &str) -> ~[u8] {
-    let mut res = StrBuf::new();
+fn get_sequence<R: Buffer>(r: &mut R, key: &str) -> Vec<u8> {
+    let mut res = Vec::new();
     for l in r.lines().map(|l| l.ok().unwrap())
         .skip_while(|l| key != l.slice_to(key.len())).skip(1)
     {
-        res.push_str(l.trim());
+        res.push_all(l.trim().as_bytes());
     }
-    res.to_owned_str().into_ascii_upper().into_bytes()
+    for b in res.mut_iter() {
+        *b = b.to_ascii().to_upper().to_byte();
+    }
+    res
 }
 
 fn main() {
@@ -268,17 +268,17 @@ fn main() {
     };
 
     let mut frequencies = Table::new();
-    generate_frequencies(&mut frequencies, input, 1);
+    generate_frequencies(&mut frequencies, input.as_slice(), 1);
     print_frequencies(&frequencies, 1);
 
     frequencies = Table::new();
-    generate_frequencies(&mut frequencies, input, 2);
+    generate_frequencies(&mut frequencies, input.as_slice(), 2);
     print_frequencies(&frequencies, 2);
 
     for occurrence in OCCURRENCES.iter() {
         frequencies = Table::new();
         generate_frequencies(&mut frequencies,
-                             input,
+                             input.as_slice(),
                              occurrence.len());
         print_occurrences(&mut frequencies, *occurrence);
     }