Wrench Reftests

webrender_traits/src/channel_mpsc.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use serde::{Deserialize, Serialize};
-use std::io::Error;
+use std::io::{Error, ErrorKind};
 
 use serde::{Deserializer, Serializer};
 
@@ -29,7 +29,9 @@ pub struct MsgReceiver<T> {
 
 impl<T> MsgReceiver<T> {
     pub fn recv(&self) -> Result<T, Error> {
-        Ok(self.rx.recv().unwrap())
+        use std::io;
+        use std::error::Error;
+        self.rx.recv().map_err(|e| io::Error::new(ErrorKind::Other, e.description()))
     }
 }
 
@@ -40,7 +42,7 @@ pub struct MsgSender<T> {
 
 impl<T> MsgSender<T> {
     pub fn send(&self, data: T) -> Result<(), Error> {
-        Ok(self.tx.send(data).unwrap())
+        self.tx.send(data).map_err(|_| Error::new(ErrorKind::Other, "cannot send on closed channel"))
     }
 }
 

wrench/reftests/green.yaml

@@ -0,0 +1,7 @@
+---
+root:
+  items:
+        - 
+          bounds: [0, 0, 95, 88]
+          type: rect
+          color: green

wrench/reftests/mask-ref.yaml

@@ -0,0 +1,11 @@
+---
+root:
+  items:
+    - 
+      bounds: [0, 0, 95, 88]
+      items:
+        - 
+          bounds: [9, 9, 10, 10]
+          type: rect
+          color: blue
+      type: stacking_context

wrench/reftests/mask.yaml

@@ -0,0 +1,17 @@
+---
+root:
+  items:
+    - 
+      bounds: [0, 0, 95, 88]
+      clip:
+        image_mask:
+          image: "mask.png"
+          rect: [0, 0, 35, 35]
+          repeat: false
+        rect: [0, 0, 95, 88]
+      items:
+        - 
+          bounds: [0, 0, 95, 88]
+          type: rect
+          color: blue
+      type: stacking_context

wrench/reftests/reftest.list

@@ -0,0 +1,2 @@
+== mask.yaml mask-ref.yaml
+!= mask.yaml green.yaml

wrench/run_tests.py

@@ -62,4 +62,5 @@ def set_osmesa_env(bin_path):
 
 set_osmesa_env('../target/release/')
 subprocess.check_call(['../target/release/wrench', '-t', '1', '-h', 'show', sys.argv[1]])
+subprocess.check_call(['../target/release/wrench', '-h', 'reftest'])
 print('md5 = ' + hashlib.md5(open('screenshot.png', 'rb').read()).hexdigest())

wrench/src/args.yaml

@@ -89,3 +89,5 @@ subcommands:
               help: The input binary file or directory
               required: true
               index: 1
+    - reftest:
+        about: run reftests

wrench/src/main.rs

@@ -55,6 +55,9 @@ use yaml_frame_reader::YamlFrameReader;
 mod yaml_frame_writer;
 mod json_frame_writer;
 
+mod reftest;
+use reftest::run_reftests;
+
 mod binary_frame_reader;
 use binary_frame_reader::BinaryFrameReader;
 
@@ -300,6 +303,9 @@ fn main() {
             Box::new(YamlFrameReader::new_from_args(subargs)) as Box<WrenchThing>
         } else if let Some(subargs) = args.subcommand_matches("replay") {
             Box::new(BinaryFrameReader::new_from_args(subargs)) as Box<WrenchThing>
+        } else if let Some(_) = args.subcommand_matches("reftest") {
+            run_reftests(&mut wrench, &mut window, "reftests/reftest.list");
+            return;
         } else {
             panic!("Should never have gotten here");
         };

wrench/src/reftest.rs

@@ -0,0 +1,106 @@
+use std::io::BufReader;
+use std::io::BufRead;
+use std::fs::File;
+use wrench::{Wrench, WrenchThing};
+use std::path::Path;
+use gleam::gl;
+use std::sync::mpsc::{channel, Sender, Receiver};
+
+use yaml_frame_reader::YamlFrameReader;
+use webrender_traits::*;
+
+use WindowWrapper;
+
+pub enum ReftestOp {
+    Equal,
+    NotEqual,
+}
+
+pub struct Reftest<'a> {
+    op: ReftestOp,
+    test: &'a Path,
+    reference: &'a Path,
+}
+
+pub fn parse_reftests<F>(filename: &str, mut runner: F)
+    where F: FnMut(Reftest)
+{
+    let manifest = Path::new(filename);
+    let dir = manifest.parent().unwrap();
+    let f = File::open(manifest).unwrap();
+    let file = BufReader::new(&f);
+    for line in file.lines() {
+        let l = line.unwrap();
+
+        // strip the comments
+        let s = &l[0..l.find("#").unwrap_or(l.len())];
+        let s = s.trim();
+        if s.len() == 0 {
+            continue;
+        }
+
+        let mut items = s.split_whitespace();
+        let kind = match items.next() {
+            Some("==") => ReftestOp::Equal,
+            Some("!=") => ReftestOp::NotEqual,
+            _ => panic!(),
+        };
+        let test = dir.join(items.next().unwrap());
+        let reference = dir.join(items.next().unwrap());
+        runner(Reftest {
+            op: kind,
+            test: test.as_path(),
+            reference: reference.as_path(),
+        });
+    }
+
+}
+
+
+fn render_yaml(wrench: &mut Wrench,
+               window: &mut WindowWrapper,
+               filename: &Path,
+               rx: &Receiver<()>)
+               -> Vec<u8> {
+    let mut reader = YamlFrameReader::new(filename);
+    reader.do_frame(wrench);
+    // wait for the frame
+    rx.recv().unwrap();
+    wrench.render();
+
+    let size = window.get_inner_size();
+    let pixels = gl::read_pixels(0,
+                                 0,
+                                 size.0 as gl::GLsizei,
+                                 size.1 as gl::GLsizei,
+                                 gl::RGBA,
+                                 gl::UNSIGNED_BYTE);
+    window.swap_buffers();
+    pixels
+}
+
+pub fn run_reftests(wrench: &mut Wrench, window: &mut WindowWrapper, filename: &str) {
+    // setup a notifier so we can wait for frames to be finished
+    struct Notifier {
+        tx: Sender<()>,
+    };
+    impl RenderNotifier for Notifier {
+        fn new_frame_ready(&mut self) {
+            self.tx.send(()).unwrap();
+        }
+        fn new_scroll_frame_ready(&mut self, _composite_needed: bool) {}
+        fn pipeline_size_changed(&mut self, _: PipelineId, _: Option<LayoutSize>) {}
+    }
+    let (tx, rx) = channel();
+    wrench.renderer.set_render_notifier(Box::new(Notifier { tx: tx }));
+
+    parse_reftests(filename, |t: Reftest| {
+        println!("{} {}", t.test.display(), t.reference.display());
+        let test = render_yaml(wrench, window, t.test, &rx);
+        let reference = render_yaml(wrench, window, t.reference, &rx);
+        match t.op {
+            ReftestOp::Equal => assert!(test == reference),
+            ReftestOp::NotEqual => assert!(test != reference),
+        }
+    });
+}