---

yaml
---
r: 148439
b: refs/heads/try2
c: 6f3c202
h: refs/heads/master
i:
  148437: 6882927
  148435: 2b6bf52
  148431: 895d45e
v: v3

Author: huonw

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 068d8288509d5869af24a179209d3927f68e441d
+refs/heads/try2: 6f3c202d3e5d9497fa0130f31bc1c3a3f0986edb
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/guide-testing.md

@@ -33,7 +33,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 # Unit testing in Rust
 
 Rust has built in support for simple unit testing. Functions can be
-marked as unit tests using the `test` attribute.
+marked as unit tests using the 'test' attribute.
 
 ~~~
 #[test]
@@ -44,13 +44,13 @@ fn return_none_if_empty() {
 
 A test function's signature must have no arguments and no return
 value. To run the tests in a crate, it must be compiled with the
-`--test` flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
+'--test' flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
 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.
 
-When compiling a crate with the `--test` flag `--cfg test` is also
+When compiling a crate with the '--test' flag '--cfg test' is also
 implied, so that tests can be conditionally compiled.
 
 ~~~
@@ -64,17 +64,17 @@ mod tests {
 ~~~
 
 Additionally `#[test]` items behave as if they also have the
-`#[cfg(test)]` attribute, and will not be compiled when the `--test` flag
+`#[cfg(test)]` attribute, and will not be compiled when the --test flag
 is not used.
 
-Tests that should not be run can be annotated with the `ignore`
+Tests that should not be run can be annotated with the 'ignore'
 attribute. The existence of these tests will be noted in the test
 runner output, but the test will not be run. Tests can also be ignored
 by configuration so, for example, to ignore a test on windows you can
 write `#[ignore(cfg(target_os = "win32"))]`.
 
 Tests that are intended to fail can be annotated with the
-`should_fail` attribute. The test will be run, and if it causes its
+'should_fail' attribute. The test will be run, and if it causes its
 task to fail then the test will be counted as successful; otherwise it
 will be counted as a failure. For example:
 
@@ -87,11 +87,11 @@ fn test_out_of_bounds_failure() {
 }
 ~~~
 
-A test runner built with the `--test` flag supports a limited set of
+A test runner built with the '--test' flag supports a limited set of
 arguments to control which tests are run: the first free argument
 passed to a test runner specifies a filter used to narrow down the set
-of tests being run; the `--ignored` flag tells the test runner to run
-only tests with the `ignore` attribute.
+of tests being run; the '--ignored' flag tells the test runner to run
+only tests with the 'ignore' attribute.
 
 ## Parallelism
 

branches/try2/doc/tutorial.md

@@ -1020,15 +1020,10 @@ being destroyed along with the owner. Since the `list` variable above is
 immutable, the whole list is immutable. The memory allocation itself is the
 box, while the owner holds onto a pointer to it:
 
-              List box             List box           List box            List box
-            +--------------+    +--------------+    +--------------+    +--------------+
-    list -> | Cons | 1 | ~ | -> | Cons | 2 | ~ | -> | Cons | 3 | ~ | -> | Nil          |
-            +--------------+    +--------------+    +--------------+    +--------------+
-
-> Note: the above diagram shows the logical contents of the enum. The actual
-> memory layout of the enum may vary. For example, for the `List` enum shown
-> above, Rust guarantees that there will be no enum tag field in the actual
-> structure. See the language reference for more details.
+      Cons cell        Cons cell        Cons cell
+    +-----------+    +-----+-----+    +-----+-----+
+    |  1  |  ~  | -> |  2  |  ~  | -> |  3  |  ~  | -> Nil
+    +-----------+    +-----+-----+    +-----+-----+
 
 An owned box is a common example of a type with a destructor. The allocated
 memory is cleaned up when the box is destroyed.

branches/try2/src/compiletest/runtest.rs

@@ -237,15 +237,9 @@ actual:\n\
 
     fn make_typecheck_args(config: &config, props: &TestProps, testfile: &Path) -> ProcArgs {
         let aux_dir = aux_output_dir_name(config, testfile);
-        let target = if props.force_host {
-            config.host.as_slice()
-        } else {
-            config.target.as_slice()
-        };
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = ~[~"-",
                          ~"--no-trans", ~"--lib",
-                         ~"--target=" + target,
                          ~"-L", config.build_base.as_str().unwrap().to_owned(),
                          ~"-L",
                          aux_dir.as_str().unwrap().to_owned()];

branches/try2/src/etc/vim/syntax/rust.vim

@@ -3,7 +3,7 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2014 Jan 4
+" Last Change:  2013 Dec 10
 
 if version < 600
   syntax clear
@@ -147,8 +147,8 @@ syn match     rustMacro       '#\w\(\w\)*' contains=rustAssert,rustFail
 syn match     rustSpecialError display contained /\\./
 syn match     rustSpecial     display contained /\\\([nrt0\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
 syn match     rustStringContinuation display contained /\\\n\s*/
-syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation,@Spell
-syn region    rustString      start='r\z(#*\)"' end='"\z1' contains=@Spell
+syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation
+syn region    rustString      start='r\z(#*\)"' end='"\z1'
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString,rustDeriving
 syn region    rustDeriving    start="deriving(" end=")" contained contains=rustTrait
@@ -179,10 +179,10 @@ syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit
 syn match   rustCharacter   /'\([^'\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial,rustSpecialError
 
 syn cluster rustComment contains=rustCommentLine,rustCommentLineDoc,rustCommentBlock,rustCommentBlockDoc
-syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo,@Spell
-syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo,@Spell
-syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
-syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
+syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo
+syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo
+syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment keepend extend
+syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment keepend extend
 " FIXME: this is a really ugly and not fully correct implementation. Most
 " importantly, a case like ``/* */*`` should have the final ``*`` not being in
 " a comment, but in practice at present it leaves comments open two levels

branches/try2/src/libextra/base64.rs

@@ -237,9 +237,8 @@ impl<'a> FromBase64 for &'a str {
         }
 
         for (idx, byte) in it {
-            match byte as char {
-                '='|'\r'|'\n' => continue,
-                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
+            if (byte as char) != '=' {
+                return Err(InvalidBase64Character(self.char_at(idx), idx));
             }
         }
 
@@ -311,8 +310,6 @@ mod test {
     fn test_from_base64_newlines() {
         assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
                    "foobar".as_bytes().to_owned());
-        assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
-                   "foob".as_bytes().to_owned());
     }
 
     #[test]

branches/try2/src/libextra/bitv.rs

@@ -269,23 +269,14 @@ impl Bitv {
 
 impl Bitv {
     pub fn new(nbits: uint, init: bool) -> Bitv {
-        let rep = if nbits < uint::bits {
-            Small(SmallBitv::new(if init {(1<<nbits)-1} else {0}))
-        } else if nbits == uint::bits {
+        let rep = if nbits <= uint::bits {
             Small(SmallBitv::new(if init {!0} else {0}))
-        } else {
-            let exact = nbits % uint::bits == 0;
-            let nelems = nbits/uint::bits + if exact {0} else {1};
-            let s =
-                if init {
-                    if exact {
-                        vec::from_elem(nelems, !0u)
-                    } else {
-                        let mut v = vec::from_elem(nelems-1, !0u);
-                        v.push((1<<nbits % uint::bits)-1);
-                        v
-                    }
-                } else { vec::from_elem(nelems, 0u)};
+        }
+        else {
+            let nelems = nbits/uint::bits +
+                         if nbits % uint::bits == 0 {0} else {1};
+            let elem = if init {!0u} else {0u};
+            let s = vec::from_elem(nelems, elem);
             Big(BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -1338,20 +1329,6 @@ mod tests {
         assert_eq!(idxs, ~[0, 2, 3]);
     }
 
-    #[test]
-    fn test_bitv_set_frombitv_init() {
-        let bools = [true, false];
-        let lengths = [10, 64, 100];
-        for &b in bools.iter() {
-            for &l in lengths.iter() {
-                let bitset = BitvSet::from_bitv(Bitv::new(l, b));
-                assert_eq!(bitset.contains(&1u), b)
-                assert_eq!(bitset.contains(&(l-1u)), b)
-                assert!(!bitset.contains(&l))
-            }
-        }
-    }
-
     #[test]
     fn test_small_difference() {
         let mut b1 = Bitv::new(3, false);

branches/try2/src/libextra/c_vec.rs

@@ -160,19 +160,21 @@ impl <T> Container for CVec<T> {
 
 #[cfg(test)]
 mod tests {
+
     use super::*;
 
     use std::libc::*;
     use std::libc;
     use std::ptr;
-    use std::rt::global_heap::malloc_raw;
 
     fn malloc(n: uint) -> CVec<u8> {
         unsafe {
-            let mem = malloc_raw(n);
+            let mem = libc::malloc(n as size_t);
+
+            assert!(mem as int != 0);
 
             CVec::new_with_dtor(mem as *mut u8, n,
-                proc() { libc::free(mem as *c_void); })
+                proc() { libc::free(mem); })
         }
     }