Run test in parallel batches

Follow review suggestion to use chunks to run test in parallel.
Set default to 16 which works well even on my limited laptop,
and which should benefit better machine.

To run with a different batch size:
BINDGEN_TEST_BATCH_SIZE=32 cargo test

On my machine:
1 parallel test takes 3'53
2 parallel test takes 2'10
8 parallel test takes 2'08
32 parallel test takes 2'07

Author: jeanphilippeD

tests/tests.rs

@@ -83,25 +83,35 @@ fn run_bindgen_tests() {
             Some(Some("hpp")) => true,
             _ => false,
         }
+    }).collect::<Vec<_>>();
+
+    let batch_size = env::var("BINDGEN_TEST_BATCH_SIZE")
+        .ok()
+        .map(|x| x.parse::<usize>().ok())
+        .unwrap_or(None)
+        .unwrap_or(16);
+
+    // Spawn batch_size (default 16) child to run in parallel
+    // and wait on all of them before processing the next batch
+
+    let children = tests.chunks(batch_size).map(|x| {
+        x.iter().map(|entry| {
+            let child = spawn_run_bindgen(run_bindgen.clone(), bindgen.clone(), entry.path());
+            (entry.path(), child)
+        }).collect::<Vec<_>>()
     });
 
-    // Spawn one child at a time and wait on it as number of process
-    // is the number of test files.
-
-    let children = tests.map(|entry| {
-        let child = spawn_run_bindgen(run_bindgen.clone(), bindgen.clone(), entry.path());
-        (entry.path(), child)
-    });
-
-    let failures: Vec<_> = children
-        .filter_map(|(path, mut child)| {
+    let failures: Vec<_> = children.map(|x| {
+        x.into_iter().filter_map(|(path, mut child)| {
             let passed = child.wait()
                 .expect("Should wait on child process")
                 .success();
 
             if passed { None } else { Some((path, child)) }
         })
-        .collect();
+    })
+    .flat_map(|x| x )
+    .collect();
 
     let num_failures = failures.len();