---

yaml
---
r: 97967
b: refs/heads/master
c: 01f42ee
h: refs/heads/master
i:
  97965: 2d6b844
  97963: 4f993ee
  97959: d508ffe
  97951: 1d7408a
v: v3

Author: nrc

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1b0f5b23fc08ff22dc513c5f333569b7e8b9313d
+refs/heads/master: 01f42eed803e7e01bb27be17461d0cc8f0643a70
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/doc/guide-testing.md

@@ -48,7 +48,8 @@ value. To run the tests in a crate, it must be compiled with the
 the resulting executable will run all the tests in the crate. A test
 is considered successful if its function returns; if the task running
 the test fails, through a call to `fail!`, a failed `check` or
-`assert`, or some other (`assert_eq`, ...) means, then the test fails.
+`assert`, or some other (`assert_eq`, `assert_approx_eq`, ...) means,
+then the test fails.
 
 When compiling a crate with the '--test' flag '--cfg test' is also
 implied, so that tests can be conditionally compiled.

trunk/src/etc/vim/syntax/rust.vim

@@ -71,7 +71,7 @@ syn keyword rustTrait Bool
 syn keyword rustTrait ToCStr
 syn keyword rustTrait Char
 syn keyword rustTrait Clone DeepClone
-syn keyword rustTrait Eq Ord TotalEq TotalOrd Ordering Equiv
+syn keyword rustTrait Eq ApproxEq Ord TotalEq TotalOrd Ordering Equiv
 syn keyword rustEnumVariant Less Equal Greater
 syn keyword rustTrait Container Mutable Map MutableMap Set MutableSet
 syn keyword rustTrait Default

trunk/src/libextra/ebml.rs

@@ -935,6 +935,7 @@ mod tests {
     use serialize::Encodable;
     use serialize;
 
+    use std::io::Decorator;
     use std::io::mem::MemWriter;
     use std::option::{None, Option, Some};
 
@@ -947,7 +948,7 @@ mod tests {
                 let mut ebml_w = writer::Encoder(&mut wr);
                 v.encode(&mut ebml_w);
             }
-            let ebml_doc = reader::Doc(wr.get_ref());
+            let ebml_doc = reader::Doc(*wr.inner_ref());
             let mut deser = reader::Decoder(ebml_doc);
             let v1 = serialize::Decodable::decode(&mut deser);
             debug!("v1 == {:?}", v1);

trunk/src/libextra/json.rs

@@ -21,6 +21,7 @@ use std::cast::transmute;
 use std::f64;
 use std::hashmap::HashMap;
 use std::io;
+use std::io::Decorator;
 use std::io::mem::MemWriter;
 use std::num;
 use std::str;
@@ -463,7 +464,7 @@ impl Json{
     pub fn to_pretty_str(&self) -> ~str {
         let mut s = MemWriter::new();
         self.to_pretty_writer(&mut s as &mut io::Writer);
-        str::from_utf8_owned(s.unwrap())
+        str::from_utf8_owned(s.inner())
     }
 }
 
@@ -1320,7 +1321,7 @@ impl to_str::ToStr for Json {
     fn to_str(&self) -> ~str {
         let mut s = MemWriter::new();
         self.to_writer(&mut s as &mut io::Writer);
-        str::from_utf8_owned(s.unwrap())
+        str::from_utf8_owned(s.inner())
     }
 }
 
@@ -1507,11 +1508,12 @@ mod tests {
 
     fn with_str_writer(f: |&mut io::Writer|) -> ~str {
         use std::io::mem::MemWriter;
+        use std::io::Decorator;
         use std::str;
 
         let mut m = MemWriter::new();
         f(&mut m as &mut io::Writer);
-        str::from_utf8_owned(m.unwrap())
+        str::from_utf8_owned(m.inner())
     }
 
     #[test]

trunk/src/libextra/num/complex.rs

@@ -11,6 +11,7 @@
 
 //! Complex numbers.
 
+
 use std::num::{Zero,One,ToStrRadix};
 
 // FIXME #1284: handle complex NaN & infinity etc. This
@@ -77,15 +78,15 @@ impl<T: Clone + Num> Cmplx<T> {
     }
 }
 
-impl<T: Clone + Real> Cmplx<T> {
+impl<T: Clone + Algebraic + Num> Cmplx<T> {
     /// Calculate |self|
     #[inline]
     pub fn norm(&self) -> T {
         self.re.hypot(&self.im)
     }
 }
 
-impl<T: Clone + Real> Cmplx<T> {
+impl<T: Clone + Trigonometric + Algebraic + Num> Cmplx<T> {
     /// Calculate the principal Arg of self.
     #[inline]
     pub fn arg(&self) -> T {
@@ -267,7 +268,7 @@ mod test {
     #[test]
     fn test_arg() {
         fn test(c: Complex64, arg: f64) {
-            assert!((c.arg() - arg).abs() < 1.0e-6)
+            assert!(c.arg().approx_eq(&arg))
         }
         test(_1_0i, 0.0);
         test(_1_1i, 0.25 * Real::pi());

trunk/src/libextra/num/rational.rs

@@ -105,12 +105,6 @@ impl<T: Clone + Integer + Ord>
         ret.reduce();
         ret
     }
-
-    /// Return the reciprocal
-    #[inline]
-    pub fn recip(&self) -> Ratio<T> {
-        Ratio::new_raw(self.denom.clone(), self.numer.clone())
-    }
 }
 
 impl Ratio<BigInt> {
@@ -294,6 +288,13 @@ impl<T: Clone + Integer + Ord>
     }
 }
 
+impl<T: Clone + Integer + Ord> Fractional for Ratio<T> {
+    #[inline]
+    fn recip(&self) -> Ratio<T> {
+        Ratio::new_raw(self.denom.clone(), self.numer.clone())
+    }
+}
+
 /* String conversions */
 impl<T: ToStr> ToStr for Ratio<T> {
     /// Renders as `numer/denom`.

trunk/src/libextra/stats.rs

@@ -439,14 +439,6 @@ mod tests {
     use std::io;
     use std::str;
 
-    macro_rules! assert_approx_eq(
-        ($a:expr, $b:expr) => ({
-            let (a, b) = (&$a, &$b);
-            assert!((*a - *b).abs() < 1.0e-6,
-                    "{} is not approximately equal to {}", *a, *b);
-        })
-    )
-
     fn check(samples: &[f64], summ: &Summary) {
 
         let summ2 = Summary::new(samples);
@@ -999,9 +991,10 @@ mod tests {
     fn test_boxplot_nonpositive() {
         fn t(s: &Summary, expected: ~str) {
             use std::io::mem::MemWriter;
+            use std::io::Decorator;
             let mut m = MemWriter::new();
             write_boxplot(&mut m as &mut io::Writer, s, 30);
-            let out = str::from_utf8_owned(m.unwrap());
+            let out = str::from_utf8_owned(m.inner());
             assert_eq!(out, expected);
         }
 

trunk/src/libextra/term.rs

@@ -13,6 +13,8 @@
 #[allow(missing_doc)];
 
 
+use std::io::{Decorator, Writer};
+
 use std::os;
 use terminfo::*;
 use terminfo::searcher::open;
@@ -232,12 +234,20 @@ impl<T: Writer> Terminal<T> {
             color-8
         } else { color }
     }
+}
 
-    pub fn unwrap(self) -> T { self.out }
+impl<T: Writer> Decorator<T> for Terminal<T> {
+    fn inner(self) -> T {
+        self.out
+    }
 
-    pub fn get_ref<'a>(&'a self) -> &'a T { &self.out }
+    fn inner_ref<'a>(&'a self) -> &'a T {
+        &self.out
+    }
 
-    pub fn get_mut<'a>(&'a mut self) -> &'a mut T { &mut self.out }
+    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut T {
+        &mut self.out
+    }
 }
 
 impl<T: Writer> Writer for Terminal<T> {

trunk/src/libextra/test.rs

@@ -673,6 +673,7 @@ pub fn run_tests_console(opts: &TestOpts,
 
 #[test]
 fn should_sort_failures_before_printing_them() {
+    use std::io::Decorator;
     use std::io::mem::MemWriter;
     use std::str;
 
@@ -704,7 +705,7 @@ fn should_sort_failures_before_printing_them() {
 
     st.write_failures();
     let s = match st.out {
-        Raw(ref m) => str::from_utf8(m.get_ref()),
+        Raw(ref m) => str::from_utf8(*m.inner_ref()),
         Pretty(_) => unreachable!()
     };
 

trunk/src/libextra/uuid.rs

@@ -522,6 +522,7 @@ mod test {
     use std::str;
     use std::rand;
     use std::num::Zero;
+    use std::io::Decorator;
     use std::io::mem::MemWriter;
 
     #[test]
@@ -797,7 +798,7 @@ mod test {
         let u = Uuid::new_v4();
         let mut wr = MemWriter::new();
         u.encode(&mut ebml::writer::Encoder(&mut wr));
-        let doc = ebml::reader::Doc(wr.get_ref());
+        let doc = ebml::reader::Doc(wr.inner_ref().as_slice());
         let u2 = Decodable::decode(&mut ebml::reader::Decoder(doc));
         assert_eq!(u, u2);
     }

trunk/src/libextra/workcache.rs

@@ -17,7 +17,7 @@ use arc::{Arc,RWArc};
 use treemap::TreeMap;
 use std::str;
 use std::io;
-use std::io::File;
+use std::io::{File, Decorator};
 use std::io::mem::MemWriter;
 
 /**
@@ -261,7 +261,7 @@ fn json_encode<'a, T:Encodable<json::Encoder<'a>>>(t: &T) -> ~str {
     let mut writer = MemWriter::new();
     let mut encoder = json::Encoder::new(&mut writer as &mut io::Writer);
     t.encode(&mut encoder);
-    str::from_utf8_owned(writer.unwrap())
+    str::from_utf8_owned(writer.inner())
 }
 
 // FIXME(#5121)

trunk/src/librustc/metadata/encoder.rs

@@ -25,6 +25,7 @@ use std::cast;
 use std::cell::{Cell, RefCell};
 use std::hashmap::{HashMap, HashSet};
 use std::io::mem::MemWriter;
+use std::io::{Writer, Seek, Decorator};
 use std::str;
 use std::vec;
 
@@ -1806,7 +1807,7 @@ pub static metadata_encoding_version : &'static [u8] =
 pub fn encode_metadata(parms: EncodeParams, crate: &Crate) -> ~[u8] {
     let mut wr = MemWriter::new();
     encode_metadata_inner(&mut wr, parms, crate);
-    wr.unwrap()
+    wr.inner()
 }
 
 fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate) {
@@ -1899,7 +1900,7 @@ fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate)
     ecx.stats.total_bytes.set(ebml_w.writer.tell());
 
     if (tcx.sess.meta_stats()) {
-        for e in ebml_w.writer.get_ref().iter() {
+        for e in ebml_w.writer.inner_ref().iter() {
             if *e == 0 {
                 ecx.stats.zero_bytes.set(ecx.stats.zero_bytes.get() + 1);
             }
@@ -1929,5 +1930,5 @@ pub fn encoded_ty(tcx: ty::ctxt, t: ty::t) -> ~str {
         abbrevs: tyencode::ac_no_abbrevs};
     let mut wr = MemWriter::new();
     tyencode::enc_ty(&mut wr, cx, t);
-    str::from_utf8_owned(wr.get_ref().to_owned())
+    str::from_utf8_owned(wr.inner_ref().to_owned())
 }

trunk/src/librustc/metadata/tyencode.rs

@@ -13,6 +13,7 @@
 use std::cell::RefCell;
 use std::hashmap::HashMap;
 use std::io;
+use std::io::{Decorator, Writer, Seek};
 use std::io::mem::MemWriter;
 use std::str;
 use std::fmt;
@@ -72,7 +73,7 @@ pub fn enc_ty(w: &mut MemWriter, cx: @ctxt, t: ty::t) {
             None => {
                 let wr = &mut MemWriter::new();
                 enc_sty(wr, cx, &ty::get(t).sty);
-                let s = str::from_utf8(wr.get_ref()).to_managed();
+                let s = str::from_utf8(*wr.inner_ref()).to_managed();
                 let mut short_names_cache = cx.tcx
                                               .short_names_cache
                                               .borrow_mut();

trunk/src/librustc/middle/astencode.rs

@@ -1465,6 +1465,7 @@ fn mk_ctxt() -> @fake_ext_ctxt {
 
 #[cfg(test)]
 fn roundtrip(in_item: Option<@ast::item>) {
+    use std::io::Decorator;
     use std::io::mem::MemWriter;
 
     let in_item = in_item.unwrap();
@@ -1473,7 +1474,7 @@ fn roundtrip(in_item: Option<@ast::item>) {
         let mut ebml_w = writer::Encoder(&mut wr);
         encode_item_ast(&mut ebml_w, in_item);
     }
-    let ebml_doc = reader::Doc(wr.get_ref());
+    let ebml_doc = reader::Doc(wr.inner_ref().as_slice());
     let out_item = decode_item_ast(ebml_doc);
 
     assert_eq!(in_item, out_item);