---

yaml
---
r: 143087
b: refs/heads/try2
c: 3509f9d
h: refs/heads/master
i:
  143085: 02d4b4f
  143083: b857b3c
  143079: 7e165e2
  143071: 13e20d3
v: v3

Author: blake2-ppc

[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: e336cbf8f9e26758a2ef98ec6b7715e083fdcced
+refs/heads/try2: 3509f9d5ae927781f190dda5e623d30ce34e87e0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/snap.mk

@@ -12,8 +12,13 @@ define DEF_SNAP_FOR_STAGE_H
 # $(1) stage
 # $(2) triple
 
+ifdef CFG_INSTALL_SNAP
+snap-stage$(1)-H-$(2): $$(HSREQ$(1)_H_$(2))
+	$(CFG_PYTHON) $(S)src/etc/make-snapshot.py stage$(1) $(2) install
+else
 snap-stage$(1)-H-$(2): $$(HSREQ$(1)_H_$(2))
 	$(CFG_PYTHON) $(S)src/etc/make-snapshot.py stage$(1) $(2)
+endif
 
 endef
 

branches/try2/src/etc/make-snapshot.py

@@ -3,4 +3,7 @@
 
 import snapshot, sys
 
-print(snapshot.make_snapshot(sys.argv[1], sys.argv[2]))
+if len(sys.argv) == 3:
+    print(snapshot.make_snapshot(sys.argv[1], sys.argv[2], ""))
+else:
+    print(snapshot.make_snapshot(sys.argv[1], sys.argv[2], sys.argv[3]))

branches/try2/src/etc/snapshot.py

@@ -156,7 +156,7 @@ def hash_file(x):
     return scrub(h.hexdigest())
 
 
-def make_snapshot(stage, triple):
+def make_snapshot(stage, triple, flag):
     kernel = get_kernel(triple)
     platform = get_platform(triple)
     rev = local_rev_short_sha()
@@ -190,4 +190,33 @@ def in_tar_name(fn):
 
     shutil.move(file0, file1)
 
+    if flag == "install":
+      # FIXME (#2664): this is an ugly quick hack; pls make it better
+      path  = file1
+      comps = path.split("-")
+      parts = { 'year': comps[2], \
+                'month': comps[3], \
+                'date': comps[4], \
+                'check': comps[5], \
+                'plat': comps[6], \
+                'arch': comps[7], \
+                'sha': comps[8].split(".")[0] }
+
+      shutil.move(path, "dl/" + path)
+      shutil.move('src/snapshots.txt', 'src/snapshots-old.txt')
+
+      newf = open('src/snapshots.txt', 'w')
+      newf.write("T %(year)s-%(month)s-%(date)s %(check)s\n" % parts)
+      newf.write("  %(plat)s-%(arch)s %(sha)s\n\n" % parts)
+
+      oldf = open('src/snapshots-old.txt', 'r')
+      for line in oldf:
+        newf.write(line)
+      oldf.close()
+
+      newf.close()
+
+      os.remove('src/snapshots-old.txt')
+
+
     return file1

branches/try2/src/libextra/base64.rs

@@ -284,109 +284,81 @@ impl<'self> FromBase64 for &'self str {
     }
 }
 
-#[cfg(test)]
-mod test {
-    use test::BenchHarness;
-    use base64::*;
-
-    #[test]
-    fn test_to_base64_basic() {
-        assert_eq!("".to_base64(STANDARD), ~"");
-        assert_eq!("f".to_base64(STANDARD), ~"Zg==");
-        assert_eq!("fo".to_base64(STANDARD), ~"Zm8=");
-        assert_eq!("foo".to_base64(STANDARD), ~"Zm9v");
-        assert_eq!("foob".to_base64(STANDARD), ~"Zm9vYg==");
-        assert_eq!("fooba".to_base64(STANDARD), ~"Zm9vYmE=");
-        assert_eq!("foobar".to_base64(STANDARD), ~"Zm9vYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_line_break() {
-        assert!(![0u8, 1000].to_base64(Config {line_length: None, ..STANDARD})
-                .contains("\r\n"));
-        assert_eq!("foobar".to_base64(Config {line_length: Some(4), ..STANDARD}),
-                   ~"Zm9v\r\nYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_padding() {
-        assert_eq!("f".to_base64(Config {pad: false, ..STANDARD}), ~"Zg");
-        assert_eq!("fo".to_base64(Config {pad: false, ..STANDARD}), ~"Zm8");
-    }
+#[test]
+fn test_to_base64_basic() {
+    assert_eq!("".to_base64(STANDARD), ~"");
+    assert_eq!("f".to_base64(STANDARD), ~"Zg==");
+    assert_eq!("fo".to_base64(STANDARD), ~"Zm8=");
+    assert_eq!("foo".to_base64(STANDARD), ~"Zm9v");
+    assert_eq!("foob".to_base64(STANDARD), ~"Zm9vYg==");
+    assert_eq!("fooba".to_base64(STANDARD), ~"Zm9vYmE=");
+    assert_eq!("foobar".to_base64(STANDARD), ~"Zm9vYmFy");
+}
 
-    #[test]
-    fn test_to_base64_url_safe() {
-        assert_eq!([251, 255].to_base64(URL_SAFE), ~"-_8");
-        assert_eq!([251, 255].to_base64(STANDARD), ~"+/8=");
-    }
+#[test]
+fn test_to_base64_line_break() {
+    assert!(![0u8, 1000].to_base64(Config {line_length: None, ..STANDARD})
+        .contains("\r\n"));
+    assert_eq!("foobar".to_base64(Config {line_length: Some(4), ..STANDARD}),
+        ~"Zm9v\r\nYmFy");
+}
 
-    #[test]
-    fn test_from_base64_basic() {
-        assert_eq!("".from_base64().get(), "".as_bytes().to_owned());
-        assert_eq!("Zg==".from_base64().get(), "f".as_bytes().to_owned());
-        assert_eq!("Zm8=".from_base64().get(), "fo".as_bytes().to_owned());
-        assert_eq!("Zm9v".from_base64().get(), "foo".as_bytes().to_owned());
-        assert_eq!("Zm9vYg==".from_base64().get(), "foob".as_bytes().to_owned());
-        assert_eq!("Zm9vYmE=".from_base64().get(), "fooba".as_bytes().to_owned());
-        assert_eq!("Zm9vYmFy".from_base64().get(), "foobar".as_bytes().to_owned());
-    }
+#[test]
+fn test_to_base64_padding() {
+    assert_eq!("f".to_base64(Config {pad: false, ..STANDARD}), ~"Zg");
+    assert_eq!("fo".to_base64(Config {pad: false, ..STANDARD}), ~"Zm8");
+}
 
-    #[test]
-    fn test_from_base64_newlines() {
-        assert_eq!("Zm9v\r\nYmFy".from_base64().get(),
-                   "foobar".as_bytes().to_owned());
-    }
+#[test]
+fn test_to_base64_url_safe() {
+    assert_eq!([251, 255].to_base64(URL_SAFE), ~"-_8");
+    assert_eq!([251, 255].to_base64(STANDARD), ~"+/8=");
+}
 
-    #[test]
-    fn test_from_base64_urlsafe() {
-        assert_eq!("-_8".from_base64().get(), "+/8=".from_base64().get());
-    }
+#[test]
+fn test_from_base64_basic() {
+    assert_eq!("".from_base64().get(), "".as_bytes().to_owned());
+    assert_eq!("Zg==".from_base64().get(), "f".as_bytes().to_owned());
+    assert_eq!("Zm8=".from_base64().get(), "fo".as_bytes().to_owned());
+    assert_eq!("Zm9v".from_base64().get(), "foo".as_bytes().to_owned());
+    assert_eq!("Zm9vYg==".from_base64().get(), "foob".as_bytes().to_owned());
+    assert_eq!("Zm9vYmE=".from_base64().get(), "fooba".as_bytes().to_owned());
+    assert_eq!("Zm9vYmFy".from_base64().get(), "foobar".as_bytes().to_owned());
+}
 
-    #[test]
-    fn test_from_base64_invalid_char() {
-        assert!("Zm$=".from_base64().is_err())
-            assert!("Zg==$".from_base64().is_err());
-    }
+#[test]
+fn test_from_base64_newlines() {
+    assert_eq!("Zm9v\r\nYmFy".from_base64().get(),
+        "foobar".as_bytes().to_owned());
+}
 
-    #[test]
-    fn test_from_base64_invalid_padding() {
-        assert!("Z===".from_base64().is_err());
-    }
+#[test]
+fn test_from_base64_urlsafe() {
+    assert_eq!("-_8".from_base64().get(), "+/8=".from_base64().get());
+}
 
-    #[test]
-    fn test_base64_random() {
-        use std::rand::{task_rng, random, RngUtil};
-        use std::vec;
+#[test]
+fn test_from_base64_invalid_char() {
+    assert!("Zm$=".from_base64().is_err())
+    assert!("Zg==$".from_base64().is_err());
+}
 
-        for 1000.times {
-            let v: ~[u8] = do vec::build |push| {
-                for task_rng().gen_uint_range(1, 100).times {
-                    push(random());
-                }
-            };
-            assert_eq!(v.to_base64(STANDARD).from_base64().get(), v);
-        }
-    }
+#[test]
+fn test_from_base64_invalid_padding() {
+    assert!("Z===".from_base64().is_err());
+}
 
-    #[bench]
-    pub fn to_base64(bh: & mut BenchHarness) {
-        let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-                 ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-        do bh.iter {
-            s.to_base64(STANDARD);
-        }
-        bh.bytes = s.len() as u64;
-    }
+#[test]
+fn test_base64_random() {
+    use std::rand::{task_rng, random, RngUtil};
+    use std::vec;
 
-    #[bench]
-    pub fn from_base64(bh: & mut BenchHarness) {
-        let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-                 ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-        let b = s.to_base64(STANDARD);
-        do bh.iter {
-            b.from_base64();
-        }
-        bh.bytes = b.len() as u64;
+    for 1000.times {
+        let v: ~[u8] = do vec::build |push| {
+            for task_rng().gen_uint_range(1, 100).times {
+                push(random());
+            }
+        };
+        assert_eq!(v.to_base64(STANDARD).from_base64().get(), v);
     }
-
-}
+}

branches/try2/src/libextra/container.rs

@@ -38,86 +38,3 @@ pub trait Deque<T> : Mutable {
     /// Remove the first element and return it, or None if the sequence is empty
     fn pop_front(&mut self) -> Option<T>;
 }
-
-#[cfg(test)]
-mod bench {
-
-    use std::container::MutableMap;
-    use std::{vec,rand,uint};
-    use std::rand::RngUtil;
-    use test::BenchHarness;
-
-    pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
-                                                  map: &mut M,
-                                                  bh: &mut BenchHarness) {
-        // setup
-        let mut rng = rand::XorShiftRng::new();
-
-        map.clear();
-        for uint::range(0,n) |_i| {
-            map.insert(rng.gen::<uint>() % n, 1);
-        }
-
-        // measure
-        do bh.iter {
-            let k = rng.gen::<uint>() % n;
-            map.insert(k, 1);
-            map.remove(&k);
-        }
-    }
-
-    pub fn insert_seq_n<M:MutableMap<uint,uint>>(n: uint,
-                                                 map: &mut M,
-                                                 bh: &mut BenchHarness) {
-        // setup
-        map.clear();
-        for uint::range(0, n) |i| {
-            map.insert(i*2, 1);
-        }
-
-        // measure
-        let mut i = 1;
-        do bh.iter {
-            map.insert(i, 1);
-            map.remove(&i);
-            i = (i + 2) % n;
-        }
-    }
-
-    pub fn find_rand_n<M:MutableMap<uint,uint>>(n: uint,
-                                                map: &mut M,
-                                                bh: &mut BenchHarness) {
-        // setup
-        let mut rng = rand::XorShiftRng::new();
-        let mut keys = vec::from_fn(n, |_| rng.gen::<uint>() % n);
-
-        for keys.iter().advance() |k| {
-            map.insert(*k, 1);
-        }
-
-        rng.shuffle_mut(keys);
-
-        // measure
-        let mut i = 0;
-        do bh.iter {
-            map.find(&(keys[i]));
-            i = (i + 1) % n;
-        }
-    }
-
-    pub fn find_seq_n<M:MutableMap<uint,uint>>(n: uint,
-                                               map: &mut M,
-                                               bh: &mut BenchHarness) {
-        // setup
-        for uint::range(0, n) |i| {
-            map.insert(i, 1);
-        }
-
-        // measure
-        let mut i = 0;
-        do bh.iter {
-            map.find(&i);
-            i = (i + 1) % n;
-        }
-     }
-}

branches/try2/src/libextra/crypto/sha1.rs

@@ -367,41 +367,3 @@ mod tests {
         }
     }
 }
-
-#[cfg(test)]
-mod bench {
-
-    use sha1::Sha1;
-    use test::BenchHarness;
-
-    #[bench]
-    pub fn sha1_10(bh: & mut BenchHarness) {
-        let mut sh = Sha1::new();
-        let bytes = [1u8, ..10];
-        do bh.iter {
-            sh.input(bytes);
-        }
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha1_1k(bh: & mut BenchHarness) {
-        let mut sh = Sha1::new();
-        let bytes = [1u8, ..1024];
-        do bh.iter {
-            sh.input(bytes);
-        }
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn sha1_64k(bh: & mut BenchHarness) {
-        let mut sh = Sha1::new();
-        let bytes = [1u8, ..65536];
-        do bh.iter {
-            sh.input(bytes);
-        }
-        bh.bytes = bytes.len() as u64;
-    }
-
-}