You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucy.apache.org by nw...@apache.org on 2013/06/03 17:36:45 UTC

[lucy-commits] [22/25] Rework Clownfish test harness

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Clownfish/TestHarness/TestRunner.cfh
----------------------------------------------------------------------
diff --git a/core/Clownfish/TestHarness/TestRunner.cfh b/core/Clownfish/TestHarness/TestRunner.cfh
deleted file mode 100644
index 8bebac0..0000000
--- a/core/Clownfish/TestHarness/TestRunner.cfh
+++ /dev/null
@@ -1,77 +0,0 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-parcel Clownfish;
-
-/**
- * Run multiple test batches and collect statistics.
- */
-class Clownfish::TestHarness::TestRunner inherits Clownfish::Obj {
-    TestFormatter *formatter;
-    uint32_t       num_tests;
-    uint32_t       num_tests_failed;
-    uint32_t       num_batches;
-    uint32_t       num_batches_failed;
-
-    inert incremented TestRunner*
-    new(TestFormatter *formatter);
-
-    /**
-     * @param formatter The test formatter to format the test output.
-     */
-    inert TestRunner*
-    init(TestRunner *self, TestFormatter *formatter);
-
-    public void
-    Destroy(TestRunner *self);
-
-    /** Run a test batch and collect statistics.
-     *
-     * @param batch The test batch.
-     * @return true if the test batch passed.
-     */
-    bool
-    Run_Batch(TestRunner *self, TestBatch *batch);
-
-    /** Print a summary after running all test batches.
-     *
-     * @return true if any tests were run and all test batches passed.
-     */
-    bool
-    Finish(TestRunner *self);
-
-    /** Return the number of tests run.
-     */
-    uint32_t
-    Get_Num_Tests(TestRunner *self);
-
-    /** Return the number of failed tests.
-     */
-    uint32_t
-    Get_Num_Tests_Failed(TestRunner *self);
-
-    /** Return the number of test batches run.
-     */
-    uint32_t
-    Get_Num_Batches(TestRunner *self);
-
-    /** Return the number of failed test batches.
-     */
-    uint32_t
-    Get_Num_Batches_Failed(TestRunner *self);
-}
-
-

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Clownfish/TestHarness/TestSuite.c
----------------------------------------------------------------------
diff --git a/core/Clownfish/TestHarness/TestSuite.c b/core/Clownfish/TestHarness/TestSuite.c
new file mode 100644
index 0000000..8ef8eb4
--- /dev/null
+++ b/core/Clownfish/TestHarness/TestSuite.c
@@ -0,0 +1,109 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+
+#define C_CFISH_TESTSUITE
+#define CHY_USE_SHORT_NAMES
+#define CFISH_USE_SHORT_NAMES
+#define TESTCFISH_USE_SHORT_NAMES
+
+#include "Clownfish/TestHarness/TestSuite.h"
+
+#include "Clownfish/CharBuf.h"
+#include "Clownfish/Err.h"
+#include "Clownfish/TestHarness/TestBatch.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
+#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestSuiteRunner.h"
+#include "Clownfish/VArray.h"
+#include "Clownfish/VTable.h"
+
+static void
+S_unbuffer_stdout();
+
+TestSuite*
+TestSuite_new() {
+    TestSuite *self = (TestSuite*)VTable_Make_Obj(TESTSUITE);
+    return TestSuite_init(self);
+}
+
+TestSuite*
+TestSuite_init(TestSuite *self) {
+    self->batches = VA_new(0);
+    return self;
+}
+
+void
+TestSuite_destroy(TestSuite *self) {
+    DECREF(self->batches);
+    SUPER_DESTROY(self, TESTSUITE);
+}
+
+void
+TestSuite_add_batch(TestSuite *self, TestBatch *batch) {
+    VA_Push(self->batches, (Obj*)batch);
+}
+
+bool
+TestSuite_run_batch(TestSuite *self, CharBuf *class_name,
+                    TestFormatter *formatter) {
+    S_unbuffer_stdout();
+
+    uint32_t size = VA_Get_Size(self->batches);
+
+    for (uint32_t i = 0; i < size; ++i) {
+        TestBatch *batch = (TestBatch*)VA_Fetch(self->batches, i);
+
+        if (CB_Equals(TestBatch_Get_Class_Name(batch), (Obj*)class_name)) {
+            TestBatchRunner *runner = TestBatchRunner_new(formatter);
+            bool result = TestBatchRunner_Run_Batch(runner, batch);
+            DECREF(runner);
+            return result;
+        }
+    }
+
+    THROW(ERR, "Couldn't find test class '%o'", class_name);
+    UNREACHABLE_RETURN(bool);
+}
+
+bool
+TestSuite_run_all_batches(TestSuite *self, TestFormatter *formatter) {
+    S_unbuffer_stdout();
+
+    TestSuiteRunner *runner = TestSuiteRunner_new(formatter);
+    uint32_t size = VA_Get_Size(self->batches);
+
+    for (uint32_t i = 0; i < size; ++i) {
+        TestBatch *batch = (TestBatch*)VA_Fetch(self->batches, i);
+        TestSuiteRunner_Run_Batch(runner, batch);
+    }
+
+    bool result = TestSuiteRunner_Finish(runner);
+
+    DECREF(runner);
+    return result;
+}
+
+static void
+S_unbuffer_stdout() {
+    int check_val = setvbuf(stdout, NULL, _IONBF, 0);
+    if (check_val != 0) {
+        fprintf(stderr, "Failed when trying to unbuffer stdout\n");
+    }
+}
+
+

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Clownfish/TestHarness/TestSuite.cfh
----------------------------------------------------------------------
diff --git a/core/Clownfish/TestHarness/TestSuite.cfh b/core/Clownfish/TestHarness/TestSuite.cfh
new file mode 100644
index 0000000..4f1327a
--- /dev/null
+++ b/core/Clownfish/TestHarness/TestSuite.cfh
@@ -0,0 +1,43 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+parcel Clownfish;
+
+/** Manage a collection of test batches.
+ */
+class Clownfish::TestHarness::TestSuite inherits Clownfish::Obj {
+    VArray *batches;
+
+    inert incremented TestSuite*
+    new();
+
+    inert TestSuite*
+    init(TestSuite *self);
+
+    public void
+    Destroy(TestSuite *self);
+
+    void
+    Add_Batch(TestSuite *self, decremented TestBatch *batch);
+
+    bool
+    Run_Batch(TestSuite *self, CharBuf *class_name, TestFormatter *formatter);
+
+    bool
+    Run_All_Batches(TestSuite *self, TestFormatter *formatter);
+}
+
+

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Clownfish/TestHarness/TestSuiteRunner.c
----------------------------------------------------------------------
diff --git a/core/Clownfish/TestHarness/TestSuiteRunner.c b/core/Clownfish/TestHarness/TestSuiteRunner.c
new file mode 100644
index 0000000..c2a9e72
--- /dev/null
+++ b/core/Clownfish/TestHarness/TestSuiteRunner.c
@@ -0,0 +1,97 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define C_CFISH_TESTSUITERUNNER
+#define CFISH_USE_SHORT_NAMES
+#define LUCY_USE_SHORT_NAMES
+#define CHY_USE_SHORT_NAMES
+
+#include "Clownfish/TestHarness/TestSuiteRunner.h"
+
+#include "Clownfish/Err.h"
+#include "Clownfish/TestHarness/TestBatch.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
+#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/VTable.h"
+
+TestSuiteRunner*
+TestSuiteRunner_new(TestFormatter *formatter) {
+    TestSuiteRunner *self = (TestSuiteRunner*)VTable_Make_Obj(TESTSUITERUNNER);
+    return TestSuiteRunner_init(self, formatter);
+}
+
+TestSuiteRunner*
+TestSuiteRunner_init(TestSuiteRunner *self, TestFormatter *formatter) {
+    self->formatter          = (TestFormatter*)INCREF(formatter);
+    self->num_tests          = 0;
+    self->num_tests_failed   = 0;
+    self->num_batches        = 0;
+    self->num_batches_failed = 0;
+
+    return self;
+}
+
+void
+TestSuiteRunner_destroy(TestSuiteRunner *self) {
+    DECREF(self->formatter);
+    SUPER_DESTROY(self, TESTSUITERUNNER);
+}
+
+bool
+TestSuiteRunner_run_batch(TestSuiteRunner *self, TestBatch *batch) {
+    TestBatchRunner *batch_runner = TestBatchRunner_new(self->formatter);
+    bool success = TestBatchRunner_Run_Batch(batch_runner, batch);
+
+    self->num_tests        += TestBatchRunner_Get_Num_Tests(batch_runner);
+    self->num_tests_failed += TestBatchRunner_Get_Num_Failed(batch_runner);
+    self->num_batches      += 1;
+
+    if (!success) {
+        self->num_batches_failed += 1;
+    }
+
+    DECREF(batch_runner);
+    return success;
+}
+
+bool
+TestSuiteRunner_finish(TestSuiteRunner *self) {
+    TestFormatter_Summary(self->formatter, self);
+
+    return self->num_batches != 0 && self->num_batches_failed == 0;
+}
+
+uint32_t
+TestSuiteRunner_get_num_tests(TestSuiteRunner *self) {
+    return self->num_tests;
+}
+
+uint32_t
+TestSuiteRunner_get_num_tests_failed(TestSuiteRunner *self) {
+    return self->num_tests_failed;
+}
+
+uint32_t
+TestSuiteRunner_get_num_batches(TestSuiteRunner *self) {
+    return self->num_batches;
+}
+
+uint32_t
+TestSuiteRunner_get_num_batches_failed(TestSuiteRunner *self) {
+    return self->num_batches_failed;
+}
+
+

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Clownfish/TestHarness/TestSuiteRunner.cfh
----------------------------------------------------------------------
diff --git a/core/Clownfish/TestHarness/TestSuiteRunner.cfh b/core/Clownfish/TestHarness/TestSuiteRunner.cfh
new file mode 100644
index 0000000..e9202f1
--- /dev/null
+++ b/core/Clownfish/TestHarness/TestSuiteRunner.cfh
@@ -0,0 +1,76 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+parcel Clownfish;
+
+/** Run multiple test batches and collect statistics.
+ */
+class Clownfish::TestHarness::TestSuiteRunner inherits Clownfish::Obj {
+    TestFormatter *formatter;
+    uint32_t       num_tests;
+    uint32_t       num_tests_failed;
+    uint32_t       num_batches;
+    uint32_t       num_batches_failed;
+
+    inert incremented TestSuiteRunner*
+    new(TestFormatter *formatter);
+
+    /**
+     * @param formatter The test formatter to format the test output.
+     */
+    inert TestSuiteRunner*
+    init(TestSuiteRunner *self, TestFormatter *formatter);
+
+    public void
+    Destroy(TestSuiteRunner *self);
+
+    /** Run a test batch and collect statistics.
+     *
+     * @param batch The test batch.
+     * @return true if the test batch passed.
+     */
+    bool
+    Run_Batch(TestSuiteRunner *self, TestBatch *batch);
+
+    /** Print a summary after running all test batches.
+     *
+     * @return true if any tests were run and all test batches passed.
+     */
+    bool
+    Finish(TestSuiteRunner *self);
+
+    /** Return the number of tests run.
+     */
+    uint32_t
+    Get_Num_Tests(TestSuiteRunner *self);
+
+    /** Return the number of failed tests.
+     */
+    uint32_t
+    Get_Num_Tests_Failed(TestSuiteRunner *self);
+
+    /** Return the number of test batches run.
+     */
+    uint32_t
+    Get_Num_Batches(TestSuiteRunner *self);
+
+    /** Return the number of failed test batches.
+     */
+    uint32_t
+    Get_Num_Batches_Failed(TestSuiteRunner *self);
+}
+
+

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test.c b/core/Lucy/Test.c
index c131931..5923e98 100644
--- a/core/Lucy/Test.c
+++ b/core/Lucy/Test.c
@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-#include <stdio.h>
-
+#define CFISH_USE_SHORT_NAMES
 #define TESTLUCY_USE_SHORT_NAMES
-#include "Lucy/Util/ToolSet.h"
 
 #include "Lucy/Test.h"
+
 #include "Clownfish/TestHarness/TestBatch.h"
-#include "Clownfish/TestHarness/TestFormatter.h"
-#include "Clownfish/TestHarness/TestRunner.h"
+#include "Clownfish/TestHarness/TestSuite.h"
+
 #include "Lucy/Test/Analysis/TestAnalyzer.h"
 #include "Lucy/Test/Analysis/TestCaseFolder.h"
 #include "Lucy/Test/Analysis/TestNormalizer.h"
@@ -82,124 +81,71 @@
 #include "Lucy/Test/Util/TestMemoryPool.h"
 #include "Lucy/Test/Util/TestPriorityQueue.h"
 
-static void
-S_unbuffer_stdout();
-
-static VArray*
-S_all_test_batches(TestFormatter *formatter) {
-    VArray *batches = VA_new(0);
-
-    VA_Push(batches, (Obj*)TestPriQ_new(formatter));
-    VA_Push(batches, (Obj*)TestBitVector_new(formatter));
-    VA_Push(batches, (Obj*)TestMemPool_new(formatter));
-    VA_Push(batches, (Obj*)TestIxFileNames_new(formatter));
-    VA_Push(batches, (Obj*)TestJson_new(formatter));
-    VA_Push(batches, (Obj*)TestI32Arr_new(formatter));
-    VA_Push(batches, (Obj*)TestRAMFH_new(formatter));
-    VA_Push(batches, (Obj*)TestFSFH_new(formatter));
-    VA_Push(batches, (Obj*)TestInStream_new(formatter));
-    VA_Push(batches, (Obj*)TestFH_new(formatter));
-    VA_Push(batches, (Obj*)TestIOPrimitives_new(formatter));
-    VA_Push(batches, (Obj*)TestIOChunks_new(formatter));
-    VA_Push(batches, (Obj*)TestRAMDH_new(formatter));
-    VA_Push(batches, (Obj*)TestFSDH_new(formatter));
-    VA_Push(batches, (Obj*)TestFSFolder_new(formatter));
-    VA_Push(batches, (Obj*)TestRAMFolder_new(formatter));
-    VA_Push(batches, (Obj*)TestFolder_new(formatter));
-    VA_Push(batches, (Obj*)TestIxManager_new(formatter));
-    VA_Push(batches, (Obj*)TestCFWriter_new(formatter));
-    VA_Push(batches, (Obj*)TestCFReader_new(formatter));
-    VA_Push(batches, (Obj*)TestAnalyzer_new(formatter));
-    VA_Push(batches, (Obj*)TestPolyAnalyzer_new(formatter));
-    VA_Push(batches, (Obj*)TestCaseFolder_new(formatter));
-    VA_Push(batches, (Obj*)TestRegexTokenizer_new(formatter));
-    VA_Push(batches, (Obj*)TestSnowStop_new(formatter));
-    VA_Push(batches, (Obj*)TestSnowStemmer_new(formatter));
-    VA_Push(batches, (Obj*)TestNormalizer_new(formatter));
-    VA_Push(batches, (Obj*)TestStandardTokenizer_new(formatter));
-    VA_Push(batches, (Obj*)TestSnapshot_new(formatter));
-    VA_Push(batches, (Obj*)TestTermInfo_new(formatter));
-    VA_Push(batches, (Obj*)TestFieldMisc_new(formatter));
-    VA_Push(batches, (Obj*)TestBatchSchema_new(formatter));
-    VA_Push(batches, (Obj*)TestDocWriter_new(formatter));
-    VA_Push(batches, (Obj*)TestHLWriter_new(formatter));
-    VA_Push(batches, (Obj*)TestPListWriter_new(formatter));
-    VA_Push(batches, (Obj*)TestSegWriter_new(formatter));
-    VA_Push(batches, (Obj*)TestPolyReader_new(formatter));
-    VA_Push(batches, (Obj*)TestFullTextType_new(formatter));
-    VA_Push(batches, (Obj*)TestBlobType_new(formatter));
-    VA_Push(batches, (Obj*)TestNumericType_new(formatter));
-    VA_Push(batches, (Obj*)TestFType_new(formatter));
-    VA_Push(batches, (Obj*)TestSeg_new(formatter));
-    VA_Push(batches, (Obj*)TestHighlighter_new(formatter));
-    VA_Push(batches, (Obj*)TestSpan_new(formatter));
-    VA_Push(batches, (Obj*)TestHeatMap_new(formatter));
-    VA_Push(batches, (Obj*)TestTermQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestPhraseQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestSortSpec_new(formatter));
-    VA_Push(batches, (Obj*)TestRangeQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestANDQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestMatchAllQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestNOTQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestReqOptQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestLeafQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestNoMatchQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestSeriesMatcher_new(formatter));
-    VA_Push(batches, (Obj*)TestORQuery_new(formatter));
-    VA_Push(batches, (Obj*)TestQPLogic_new(formatter));
-    VA_Push(batches, (Obj*)TestQPSyntax_new(formatter));
-
-    return batches;
-}
-
-bool
-Test_run_batch(CharBuf *class_name, TestFormatter *formatter) {
-    S_unbuffer_stdout();
-
-    VArray   *batches = S_all_test_batches(formatter);
-    uint32_t  size    = VA_Get_Size(batches);
-
-    for (uint32_t i = 0; i < size; ++i) {
-        TestBatch *batch = (TestBatch*)VA_Fetch(batches, i);
-
-        if (CB_Equals(TestBatch_Get_Class_Name(batch), (Obj*)class_name)) {
-            bool result = TestBatch_Run(batch);
-            DECREF(batches);
-            return result;
-        }
-    }
-
-    DECREF(batches);
-    THROW(ERR, "Couldn't find test class '%o'", class_name);
-    UNREACHABLE_RETURN(bool);
-}
-
-bool
-Test_run_all_batches(TestFormatter *formatter) {
-    S_unbuffer_stdout();
-
-    TestRunner *runner  = TestRunner_new(formatter);
-    VArray     *batches = S_all_test_batches(formatter);
-    uint32_t    size    = VA_Get_Size(batches);
-
-    for (uint32_t i = 0; i < size; ++i) {
-        TestBatch *batch = (TestBatch*)VA_Fetch(batches, i);
-        TestRunner_Run_Batch(runner, batch);
-    }
-
-    bool result = TestRunner_Finish(runner);
-
-    DECREF(runner);
-    DECREF(batches);
-    return result;
-}
-
-static void
-S_unbuffer_stdout() {
-    int check_val = setvbuf(stdout, NULL, _IONBF, 0);
-    if (check_val != 0) {
-        fprintf(stderr, "Failed when trying to unbuffer stdout\n");
-    }
+TestSuite*
+Test_create_test_suite() {
+    TestSuite *suite = TestSuite_new();
+
+    TestSuite_Add_Batch(suite, (TestBatch*)TestPriQ_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestBitVector_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestMemPool_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestIxFileNames_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestJson_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestI32Arr_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestRAMFH_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFSFH_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestInStream_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFH_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestIOPrimitives_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestIOChunks_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestRAMDH_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFSDH_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFSFolder_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestRAMFolder_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFolder_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestIxManager_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestCFWriter_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestCFReader_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestAnalyzer_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestPolyAnalyzer_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestCaseFolder_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestRegexTokenizer_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSnowStop_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSnowStemmer_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestNormalizer_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestStandardTokenizer_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSnapshot_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestTermInfo_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFieldMisc_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestBatchSchema_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestDocWriter_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestHLWriter_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestPListWriter_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSegWriter_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestPolyReader_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFullTextType_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestBlobType_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestNumericType_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestFType_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSeg_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestHighlighter_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSpan_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestHeatMap_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestTermQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestPhraseQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSortSpec_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestRangeQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestANDQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestMatchAllQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestNOTQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestReqOptQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestLeafQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestNoMatchQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestSeriesMatcher_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestORQuery_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestQPLogic_new());
+    TestSuite_Add_Batch(suite, (TestBatch*)TestQPSyntax_new());
+
+    return suite;
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test.cfh b/core/Lucy/Test.cfh
index 4c215bb..3b39130 100644
--- a/core/Lucy/Test.cfh
+++ b/core/Lucy/Test.cfh
@@ -16,27 +16,11 @@
 
 parcel TestLucy;
 
-/** Testing framework.
+/** Lucy test suite.
  */
 inert class Lucy::Test {
-    inert bool
-    run_batch(CharBuf *class_name, TestFormatter *formatter);
-
-    inert bool
-    run_all_batches(TestFormatter *formatter);
+    inert incremented TestSuite*
+    create_test_suite();
 }
 
-__C__
-#ifdef LUCY_USE_SHORT_NAMES
-  #define TEST_TRUE                    cfish_TestBatch_test_true
-  #define TEST_FALSE                   cfish_TestBatch_test_false
-  #define TEST_INT_EQ                  cfish_TestBatch_test_int_equals
-  #define TEST_FLOAT_EQ                cfish_TestBatch_test_float_equals
-  #define TEST_STR_EQ                  cfish_TestBatch_test_string_equals
-  #define PASS                         cfish_TestBatch_pass
-  #define FAIL                         cfish_TestBatch_fail
-  #define SKIP                         cfish_TestBatch_skip
-#endif
-__END_C__
-
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestAnalyzer.c b/core/Lucy/Test/Analysis/TestAnalyzer.c
index 04e6fc7..f7dba1c 100644
--- a/core/Lucy/Test/Analysis/TestAnalyzer.c
+++ b/core/Lucy/Test/Analysis/TestAnalyzer.c
@@ -17,7 +17,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/TestUtils.h"
 #include "Lucy/Test/Analysis/TestAnalyzer.h"
@@ -25,14 +25,8 @@
 #include "Lucy/Analysis/Inversion.h"
 
 TestAnalyzer*
-TestAnalyzer_new(TestFormatter *formatter) {
-    TestAnalyzer *self = (TestAnalyzer*)VTable_Make_Obj(TESTANALYZER);
-    return TestAnalyzer_init(self, formatter);
-}
-
-TestAnalyzer*
-TestAnalyzer_init(TestAnalyzer *self, TestFormatter *formatter) {
-    return (TestAnalyzer*)TestBatch_init((TestBatch*)self, 3, formatter);
+TestAnalyzer_new() {
+    return (TestAnalyzer*)VTable_Make_Obj(TESTANALYZER);
 }
 
 DummyAnalyzer*
@@ -53,12 +47,12 @@ DummyAnalyzer_transform(DummyAnalyzer *self, Inversion *inversion) {
 }
 
 static void
-test_analysis(TestBatch *batch) {
+test_analysis(TestBatchRunner *runner) {
     DummyAnalyzer *analyzer = DummyAnalyzer_new();
     CharBuf *source = CB_newf("foo bar baz");
     VArray *wanted = VA_new(1);
     VA_Push(wanted, (Obj*)CB_newf("foo bar baz"));
-    TestUtils_test_analyzer(batch, (Analyzer*)analyzer, source, wanted,
+    TestUtils_test_analyzer(runner, (Analyzer*)analyzer, source, wanted,
                             "test basic analysis");
     DECREF(wanted);
     DECREF(source);
@@ -66,9 +60,9 @@ test_analysis(TestBatch *batch) {
 }
 
 void
-TestAnalyzer_run_tests(TestAnalyzer *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_analysis(batch);
+TestAnalyzer_run(TestAnalyzer *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 3);
+    test_analysis(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestAnalyzer.cfh b/core/Lucy/Test/Analysis/TestAnalyzer.cfh
index e9d67ea..661e391 100644
--- a/core/Lucy/Test/Analysis/TestAnalyzer.cfh
+++ b/core/Lucy/Test/Analysis/TestAnalyzer.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestAnalyzer
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestAnalyzer*
-    new(TestFormatter *formatter);
-
-    inert TestAnalyzer*
-    init(TestAnalyzer *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestAnalyzer *self);
+    Run(TestAnalyzer *self, TestBatchRunner *runner);
 }
 
 class Lucy::Test::Analysis::DummyAnalyzer inherits Lucy::Analysis::Analyzer {

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestCaseFolder.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestCaseFolder.c b/core/Lucy/Test/Analysis/TestCaseFolder.c
index 1c8670b..9ee90fe 100644
--- a/core/Lucy/Test/Analysis/TestCaseFolder.c
+++ b/core/Lucy/Test/Analysis/TestCaseFolder.c
@@ -18,34 +18,28 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/TestUtils.h"
 #include "Lucy/Test/Analysis/TestCaseFolder.h"
 #include "Lucy/Analysis/CaseFolder.h"
 
 TestCaseFolder*
-TestCaseFolder_new(TestFormatter *formatter) {
-    TestCaseFolder *self = (TestCaseFolder*)VTable_Make_Obj(TESTCASEFOLDER);
-    return TestCaseFolder_init(self, formatter);
-}
-
-TestCaseFolder*
-TestCaseFolder_init(TestCaseFolder *self, TestFormatter *formatter) {
-    return (TestCaseFolder*)TestBatch_init((TestBatch*)self, 6, formatter);
+TestCaseFolder_new() {
+    return (TestCaseFolder*)VTable_Make_Obj(TESTCASEFOLDER);
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     CaseFolder *case_folder = CaseFolder_new();
     CaseFolder *other       = CaseFolder_new();
     Obj        *dump        = (Obj*)CaseFolder_Dump(case_folder);
     CaseFolder *clone       = (CaseFolder*)CaseFolder_Load(other, dump);
 
-    TEST_TRUE(batch, CaseFolder_Equals(case_folder, (Obj*)other), "Equals");
-    TEST_FALSE(batch, CaseFolder_Equals(case_folder, (Obj*)CFISH_TRUE),
+    TEST_TRUE(runner, CaseFolder_Equals(case_folder, (Obj*)other), "Equals");
+    TEST_FALSE(runner, CaseFolder_Equals(case_folder, (Obj*)CFISH_TRUE),
                "Not Equals");
-    TEST_TRUE(batch, CaseFolder_Equals(case_folder, (Obj*)clone),
+    TEST_TRUE(runner, CaseFolder_Equals(case_folder, (Obj*)clone),
               "Dump => Load round trip");
 
     DECREF(case_folder);
@@ -55,12 +49,12 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 static void
-test_analysis(TestBatch *batch) {
+test_analysis(TestBatchRunner *runner) {
     CaseFolder *case_folder = CaseFolder_new();
     CharBuf *source = CB_newf("caPiTal ofFensE");
     VArray *wanted = VA_new(1);
     VA_Push(wanted, (Obj*)CB_newf("capital offense"));
-    TestUtils_test_analyzer(batch, (Analyzer*)case_folder, source, wanted,
+    TestUtils_test_analyzer(runner, (Analyzer*)case_folder, source, wanted,
                             "lowercase plain text");
     DECREF(wanted);
     DECREF(source);
@@ -68,10 +62,10 @@ test_analysis(TestBatch *batch) {
 }
 
 void
-TestCaseFolder_run_tests(TestCaseFolder *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
-    test_analysis(batch);
+TestCaseFolder_run(TestCaseFolder *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 6);
+    test_Dump_Load_and_Equals(runner);
+    test_analysis(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestCaseFolder.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestCaseFolder.cfh b/core/Lucy/Test/Analysis/TestCaseFolder.cfh
index 2ff9067..6138139 100644
--- a/core/Lucy/Test/Analysis/TestCaseFolder.cfh
+++ b/core/Lucy/Test/Analysis/TestCaseFolder.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestCaseFolder
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestCaseFolder*
-    new(TestFormatter *formatter);
-
-    inert TestCaseFolder*
-    init(TestCaseFolder *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestCaseFolder *self);
+    Run(TestCaseFolder *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestNormalizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestNormalizer.c b/core/Lucy/Test/Analysis/TestNormalizer.c
index 40d26e3..8824b01 100644
--- a/core/Lucy/Test/Analysis/TestNormalizer.c
+++ b/core/Lucy/Test/Analysis/TestNormalizer.c
@@ -19,7 +19,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Analysis/TestNormalizer.h"
 #include "Lucy/Analysis/Normalizer.h"
@@ -27,18 +27,12 @@
 #include "Lucy/Util/Json.h"
 
 TestNormalizer*
-TestNormalizer_new(TestFormatter *formatter) {
-    TestNormalizer *self = (TestNormalizer*)VTable_Make_Obj(TESTNORMALIZER);
-    return TestNormalizer_init(self, formatter);
-}
-
-TestNormalizer*
-TestNormalizer_init(TestNormalizer *self, TestFormatter *formatter) {
-    return (TestNormalizer*)TestBatch_init((TestBatch*)self, 20, formatter);
+TestNormalizer_new() {
+    return (TestNormalizer*)VTable_Make_Obj(TESTNORMALIZER);
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     Normalizer *normalizer[4];
 
     CharBuf *NFC  = (CharBuf*)ZCB_WRAP_STR("NFC",  3);
@@ -49,13 +43,13 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
     normalizer[2] = Normalizer_new(NFKC, false, false);
     normalizer[3] = Normalizer_new(NFKC, true,  true);
 
-    TEST_FALSE(batch,
+    TEST_FALSE(runner,
                Normalizer_Equals(normalizer[0], (Obj*)normalizer[1]),
                "Equals() false with different normalization form");
-    TEST_FALSE(batch,
+    TEST_FALSE(runner,
                Normalizer_Equals(normalizer[0], (Obj*)normalizer[2]),
                "Equals() false with different case_fold flag");
-    TEST_FALSE(batch,
+    TEST_FALSE(runner,
                Normalizer_Equals(normalizer[0], (Obj*)normalizer[3]),
                "Equals() false with different strip_accents flag");
 
@@ -63,7 +57,7 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
         Obj *dump = (Obj*)Normalizer_Dump(normalizer[i]);
         Normalizer *clone = (Normalizer*)Normalizer_Load(normalizer[i], dump);
 
-        TEST_TRUE(batch,
+        TEST_TRUE(runner,
                   Normalizer_Equals(normalizer[i], (Obj*)clone),
                   "Dump => Load round trip");
 
@@ -74,7 +68,7 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 static void
-test_normalization(TestBatch *batch) {
+test_normalization(TestBatchRunner *runner) {
     CharBuf  *path           = CB_newf("modules");
     FSFolder *modules_folder = FSFolder_new(path);
     if (!FSFolder_Check(modules_folder)) {
@@ -104,7 +98,7 @@ test_normalization(TestBatch *batch) {
             CharBuf *word = (CharBuf*)VA_Fetch(words, j);
             VArray  *got  = Normalizer_Split(normalizer, word);
             CharBuf *norm = (CharBuf*)VA_Fetch(got, 0);
-            TEST_TRUE(batch,
+            TEST_TRUE(runner,
                       norm
                       && CB_Is_A(norm, CHARBUF)
                       && CB_Equals(norm, VA_Fetch(norms, j)),
@@ -122,10 +116,10 @@ test_normalization(TestBatch *batch) {
 }
 
 void
-TestNormalizer_run_tests(TestNormalizer *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
-    test_normalization(batch);
+TestNormalizer_run(TestNormalizer *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 20);
+    test_Dump_Load_and_Equals(runner);
+    test_normalization(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestNormalizer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestNormalizer.cfh b/core/Lucy/Test/Analysis/TestNormalizer.cfh
index ac5567f..0200838 100644
--- a/core/Lucy/Test/Analysis/TestNormalizer.cfh
+++ b/core/Lucy/Test/Analysis/TestNormalizer.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestNormalizer
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestNormalizer*
-    new(TestFormatter *formatter);
-
-    inert TestNormalizer*
-    init(TestNormalizer *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestNormalizer *self);
+    Run(TestNormalizer *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestPolyAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestPolyAnalyzer.c b/core/Lucy/Test/Analysis/TestPolyAnalyzer.c
index cee8df1..dc88aa1 100644
--- a/core/Lucy/Test/Analysis/TestPolyAnalyzer.c
+++ b/core/Lucy/Test/Analysis/TestPolyAnalyzer.c
@@ -18,7 +18,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/TestUtils.h"
 #include "Lucy/Test/Analysis/TestPolyAnalyzer.h"
@@ -30,23 +30,16 @@
 #include "Lucy/Analysis/StandardTokenizer.h"
 
 TestPolyAnalyzer*
-TestPolyAnalyzer_new(TestFormatter *formatter) {
-    TestPolyAnalyzer *self
-        = (TestPolyAnalyzer*)VTable_Make_Obj(TESTPOLYANALYZER);
-    return TestPolyAnalyzer_init(self, formatter);
-}
-
-TestPolyAnalyzer*
-TestPolyAnalyzer_init(TestPolyAnalyzer *self, TestFormatter *formatter) {
-    return (TestPolyAnalyzer*)TestBatch_init((TestBatch*)self, 19, formatter);
+TestPolyAnalyzer_new() {
+    return (TestPolyAnalyzer*)VTable_Make_Obj(TESTPOLYANALYZER);
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     if (!RegexTokenizer_is_available()) {
-        SKIP(batch, "RegexTokenizer not available");
-        SKIP(batch, "RegexTokenizer not available");
-        SKIP(batch, "RegexTokenizer not available");
+        SKIP(runner, "RegexTokenizer not available");
+        SKIP(runner, "RegexTokenizer not available");
+        SKIP(runner, "RegexTokenizer not available");
         return;
     }
 
@@ -60,11 +53,11 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
     PolyAnalyzer *other_clone
         = (PolyAnalyzer*)PolyAnalyzer_Load(other, other_dump);
 
-    TEST_FALSE(batch, PolyAnalyzer_Equals(analyzer, (Obj*)other),
+    TEST_FALSE(runner, PolyAnalyzer_Equals(analyzer, (Obj*)other),
                "Equals() false with different language");
-    TEST_TRUE(batch, PolyAnalyzer_Equals(analyzer, (Obj*)clone),
+    TEST_TRUE(runner, PolyAnalyzer_Equals(analyzer, (Obj*)clone),
               "Dump => Load round trip");
-    TEST_TRUE(batch, PolyAnalyzer_Equals(other, (Obj*)other_clone),
+    TEST_TRUE(runner, PolyAnalyzer_Equals(other, (Obj*)other_clone),
               "Dump => Load round trip");
 
     DECREF(analyzer);
@@ -76,7 +69,7 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 static void
-test_analysis(TestBatch *batch) {
+test_analysis(TestBatchRunner *runner) {
     CharBuf            *EN          = (CharBuf*)ZCB_WRAP_STR("en", 2);
     CharBuf            *source_text = CB_newf("Eats, shoots and leaves.");
     Normalizer         *normalizer  = Normalizer_new(NULL, true, false);
@@ -89,7 +82,7 @@ test_analysis(TestBatch *batch) {
         PolyAnalyzer *polyanalyzer = PolyAnalyzer_new(NULL, analyzers);
         VArray       *expected     = VA_new(1);
         VA_Push(expected, INCREF(source_text));
-        TestUtils_test_analyzer(batch, (Analyzer*)polyanalyzer, source_text,
+        TestUtils_test_analyzer(runner, (Analyzer*)polyanalyzer, source_text,
                                 expected, "No sub analyzers");
         DECREF(expected);
         DECREF(polyanalyzer);
@@ -102,7 +95,7 @@ test_analysis(TestBatch *batch) {
         PolyAnalyzer *polyanalyzer = PolyAnalyzer_new(NULL, analyzers);
         VArray       *expected     = VA_new(1);
         VA_Push(expected, (Obj*)CB_newf("eats, shoots and leaves."));
-        TestUtils_test_analyzer(batch, (Analyzer*)polyanalyzer, source_text,
+        TestUtils_test_analyzer(runner, (Analyzer*)polyanalyzer, source_text,
                                 expected, "With Normalizer");
         DECREF(expected);
         DECREF(polyanalyzer);
@@ -119,7 +112,7 @@ test_analysis(TestBatch *batch) {
         VA_Push(expected, (Obj*)CB_newf("shoots"));
         VA_Push(expected, (Obj*)CB_newf("and"));
         VA_Push(expected, (Obj*)CB_newf("leaves"));
-        TestUtils_test_analyzer(batch, (Analyzer*)polyanalyzer, source_text,
+        TestUtils_test_analyzer(runner, (Analyzer*)polyanalyzer, source_text,
                                 expected, "With StandardTokenizer");
         DECREF(expected);
         DECREF(polyanalyzer);
@@ -136,7 +129,7 @@ test_analysis(TestBatch *batch) {
         VA_Push(expected, (Obj*)CB_newf("eats"));
         VA_Push(expected, (Obj*)CB_newf("shoots"));
         VA_Push(expected, (Obj*)CB_newf("leaves"));
-        TestUtils_test_analyzer(batch, (Analyzer*)polyanalyzer, source_text,
+        TestUtils_test_analyzer(runner, (Analyzer*)polyanalyzer, source_text,
                                 expected, "With SnowballStopFilter");
         DECREF(expected);
         DECREF(polyanalyzer);
@@ -154,7 +147,7 @@ test_analysis(TestBatch *batch) {
         VA_Push(expected, (Obj*)CB_newf("eat"));
         VA_Push(expected, (Obj*)CB_newf("shoot"));
         VA_Push(expected, (Obj*)CB_newf("leav"));
-        TestUtils_test_analyzer(batch, (Analyzer*)polyanalyzer, source_text,
+        TestUtils_test_analyzer(runner, (Analyzer*)polyanalyzer, source_text,
                                 expected, "With SnowballStemmer");
         DECREF(expected);
         DECREF(polyanalyzer);
@@ -169,20 +162,20 @@ test_analysis(TestBatch *batch) {
 }
 
 static void
-test_Get_Analyzers(TestBatch *batch) {
+test_Get_Analyzers(TestBatchRunner *runner) {
     VArray *analyzers = VA_new(0);
     PolyAnalyzer *analyzer = PolyAnalyzer_new(NULL, analyzers);
-    TEST_TRUE(batch, PolyAnalyzer_Get_Analyzers(analyzer) == analyzers,
+    TEST_TRUE(runner, PolyAnalyzer_Get_Analyzers(analyzer) == analyzers,
               "Get_Analyzers()");
     DECREF(analyzer);
     DECREF(analyzers);
 }
 
 void
-TestPolyAnalyzer_run_tests(TestPolyAnalyzer *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
-    test_analysis(batch);
-    test_Get_Analyzers(batch);
+TestPolyAnalyzer_run(TestPolyAnalyzer *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 19);
+    test_Dump_Load_and_Equals(runner);
+    test_analysis(runner);
+    test_Get_Analyzers(runner);
 }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestPolyAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestPolyAnalyzer.cfh b/core/Lucy/Test/Analysis/TestPolyAnalyzer.cfh
index 7d4d2fc..cd50a76 100644
--- a/core/Lucy/Test/Analysis/TestPolyAnalyzer.cfh
+++ b/core/Lucy/Test/Analysis/TestPolyAnalyzer.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestPolyAnalyzer
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestPolyAnalyzer*
-    new(TestFormatter *formatter);
-
-    inert TestPolyAnalyzer*
-    init(TestPolyAnalyzer *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestPolyAnalyzer *self);
+    Run(TestPolyAnalyzer *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestRegexTokenizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestRegexTokenizer.c b/core/Lucy/Test/Analysis/TestRegexTokenizer.c
index cf9bb72..054068a 100644
--- a/core/Lucy/Test/Analysis/TestRegexTokenizer.c
+++ b/core/Lucy/Test/Analysis/TestRegexTokenizer.c
@@ -18,30 +18,23 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Analysis/TestRegexTokenizer.h"
 #include "Lucy/Analysis/RegexTokenizer.h"
 
 
 TestRegexTokenizer*
-TestRegexTokenizer_new(TestFormatter *formatter) {
-    TestRegexTokenizer *self
-        = (TestRegexTokenizer*)VTable_Make_Obj(TESTREGEXTOKENIZER);
-    return TestRegexTokenizer_init(self, formatter);
-}
-
-TestRegexTokenizer*
-TestRegexTokenizer_init(TestRegexTokenizer *self, TestFormatter *formatter) {
-    return (TestRegexTokenizer*)TestBatch_init((TestBatch*)self, 3, formatter);
+TestRegexTokenizer_new() {
+    return (TestRegexTokenizer*)VTable_Make_Obj(TESTREGEXTOKENIZER);
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     if (!RegexTokenizer_is_available()) {
-        SKIP(batch, "RegexTokenizer not available");
-        SKIP(batch, "RegexTokenizer not available");
-        SKIP(batch, "RegexTokenizer not available");
+        SKIP(runner, "RegexTokenizer not available");
+        SKIP(runner, "RegexTokenizer not available");
+        SKIP(runner, "RegexTokenizer not available");
         return;
     }
 
@@ -58,13 +51,13 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
     RegexTokenizer *whitespace_clone
         = RegexTokenizer_Load(whitespace_tokenizer, whitespace_dump);
 
-    TEST_FALSE(batch,
+    TEST_FALSE(runner,
                RegexTokenizer_Equals(word_char_tokenizer, (Obj*)whitespace_tokenizer),
                "Equals() false with different pattern");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               RegexTokenizer_Equals(word_char_tokenizer, (Obj*)word_char_clone),
               "Dump => Load round trip");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               RegexTokenizer_Equals(whitespace_tokenizer, (Obj*)whitespace_clone),
               "Dump => Load round trip");
 
@@ -77,9 +70,9 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 void
-TestRegexTokenizer_run_tests(TestRegexTokenizer *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
+TestRegexTokenizer_run(TestRegexTokenizer *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 3);
+    test_Dump_Load_and_Equals(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestRegexTokenizer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestRegexTokenizer.cfh b/core/Lucy/Test/Analysis/TestRegexTokenizer.cfh
index bb0f352..00e3a60 100644
--- a/core/Lucy/Test/Analysis/TestRegexTokenizer.cfh
+++ b/core/Lucy/Test/Analysis/TestRegexTokenizer.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestRegexTokenizer
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestRegexTokenizer*
-    new(TestFormatter *formatter);
-
-    inert TestRegexTokenizer*
-    init(TestRegexTokenizer *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestRegexTokenizer *self);
+    Run(TestRegexTokenizer *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestSnowballStemmer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestSnowballStemmer.c b/core/Lucy/Test/Analysis/TestSnowballStemmer.c
index 36a1879..914f453 100644
--- a/core/Lucy/Test/Analysis/TestSnowballStemmer.c
+++ b/core/Lucy/Test/Analysis/TestSnowballStemmer.c
@@ -18,7 +18,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Analysis/TestSnowballStemmer.h"
 #include "Lucy/Analysis/SnowballStemmer.h"
@@ -26,18 +26,12 @@
 #include "Lucy/Util/Json.h"
 
 TestSnowballStemmer*
-TestSnowStemmer_new(TestFormatter *formatter) {
-    TestSnowballStemmer *self = (TestSnowballStemmer*)VTable_Make_Obj(TESTSNOWBALLSTEMMER);
-    return TestSnowStemmer_init(self, formatter);
-}
-
-TestSnowballStemmer*
-TestSnowStemmer_init(TestSnowballStemmer *self, TestFormatter *formatter) {
-    return (TestSnowballStemmer*)TestBatch_init((TestBatch*)self, 153, formatter);
+TestSnowStemmer_new() {
+    return (TestSnowballStemmer*)VTable_Make_Obj(TESTSNOWBALLSTEMMER);
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     CharBuf *EN = (CharBuf*)ZCB_WRAP_STR("en", 2);
     CharBuf *ES = (CharBuf*)ZCB_WRAP_STR("es", 2);
     SnowballStemmer *stemmer = SnowStemmer_new(EN);
@@ -47,13 +41,13 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
     SnowballStemmer *clone       = (SnowballStemmer*)SnowStemmer_Load(other, dump);
     SnowballStemmer *other_clone = (SnowballStemmer*)SnowStemmer_Load(other, other_dump);
 
-    TEST_FALSE(batch,
+    TEST_FALSE(runner,
                SnowStemmer_Equals(stemmer, (Obj*)other),
                "Equals() false with different language");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               SnowStemmer_Equals(stemmer, (Obj*)clone),
               "Dump => Load round trip");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               SnowStemmer_Equals(other, (Obj*)other_clone),
               "Dump => Load round trip");
 
@@ -66,7 +60,7 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 static void
-test_stemming(TestBatch *batch) {
+test_stemming(TestBatchRunner *runner) {
     CharBuf  *path           = CB_newf("modules");
     FSFolder *modules_folder = FSFolder_new(path);
     if (!FSFolder_Check(modules_folder)) {
@@ -92,7 +86,7 @@ test_stemming(TestBatch *batch) {
             CharBuf *word  = (CharBuf*)VA_Fetch(words, i);
             VArray  *got   = SnowStemmer_Split(stemmer, word);
             CharBuf *stem  = (CharBuf*)VA_Fetch(got, 0);
-            TEST_TRUE(batch,
+            TEST_TRUE(runner,
                       stem
                       && CB_Is_A(stem, CHARBUF)
                       && CB_Equals(stem, VA_Fetch(stems, i)),
@@ -109,10 +103,10 @@ test_stemming(TestBatch *batch) {
 }
 
 void
-TestSnowStemmer_run_tests(TestSnowballStemmer *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
-    test_stemming(batch);
+TestSnowStemmer_run(TestSnowballStemmer *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 153);
+    test_Dump_Load_and_Equals(runner);
+    test_stemming(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestSnowballStemmer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestSnowballStemmer.cfh b/core/Lucy/Test/Analysis/TestSnowballStemmer.cfh
index 8a651ee..6260b13 100644
--- a/core/Lucy/Test/Analysis/TestSnowballStemmer.cfh
+++ b/core/Lucy/Test/Analysis/TestSnowballStemmer.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestSnowballStemmer cnick TestSnowStemmer
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestSnowballStemmer*
-    new(TestFormatter *formatter);
-
-    inert TestSnowballStemmer*
-    init(TestSnowballStemmer *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestSnowballStemmer *self);
+    Run(TestSnowballStemmer *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestSnowballStopFilter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestSnowballStopFilter.c b/core/Lucy/Test/Analysis/TestSnowballStopFilter.c
index 217464a..5a3bd9e 100644
--- a/core/Lucy/Test/Analysis/TestSnowballStopFilter.c
+++ b/core/Lucy/Test/Analysis/TestSnowballStopFilter.c
@@ -18,20 +18,14 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Analysis/TestSnowballStopFilter.h"
 #include "Lucy/Analysis/SnowballStopFilter.h"
 
 TestSnowballStopFilter*
-TestSnowStop_new(TestFormatter *formatter) {
-    TestSnowballStopFilter *self = (TestSnowballStopFilter*)VTable_Make_Obj(TESTSNOWBALLSTOPFILTER);
-    return TestSnowStop_init(self, formatter);
-}
-
-TestSnowballStopFilter*
-TestSnowStop_init(TestSnowballStopFilter *self, TestFormatter *formatter) {
-    return (TestSnowballStopFilter*)TestBatch_init((TestBatch*)self, 3, formatter);
+TestSnowStop_new() {
+    return (TestSnowballStopFilter*)VTable_Make_Obj(TESTSNOWBALLSTOPFILTER);
 }
 
 static SnowballStopFilter*
@@ -54,7 +48,7 @@ S_make_stopfilter(void *unused, ...) {
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     SnowballStopFilter *stopfilter =
         S_make_stopfilter(NULL, "foo", "bar", "baz", NULL);
     SnowballStopFilter *other =
@@ -64,13 +58,13 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
     SnowballStopFilter *clone       = (SnowballStopFilter*)SnowStop_Load(other, dump);
     SnowballStopFilter *other_clone = (SnowballStopFilter*)SnowStop_Load(other, other_dump);
 
-    TEST_FALSE(batch,
+    TEST_FALSE(runner,
                SnowStop_Equals(stopfilter, (Obj*)other),
                "Equals() false with different stoplist");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               SnowStop_Equals(stopfilter, (Obj*)clone),
               "Dump => Load round trip");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               SnowStop_Equals(other, (Obj*)other_clone),
               "Dump => Load round trip");
 
@@ -83,9 +77,9 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 void
-TestSnowStop_run_tests(TestSnowballStopFilter *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
+TestSnowStop_run(TestSnowballStopFilter *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 3);
+    test_Dump_Load_and_Equals(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestSnowballStopFilter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestSnowballStopFilter.cfh b/core/Lucy/Test/Analysis/TestSnowballStopFilter.cfh
index 33140a5..63494f2 100644
--- a/core/Lucy/Test/Analysis/TestSnowballStopFilter.cfh
+++ b/core/Lucy/Test/Analysis/TestSnowballStopFilter.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestSnowballStopFilter cnick TestSnowStop
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestSnowballStopFilter*
-    new(TestFormatter *formatter);
-
-    inert TestSnowballStopFilter*
-    init(TestSnowballStopFilter *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestSnowballStopFilter *self);
+    Run(TestSnowballStopFilter *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestStandardTokenizer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestStandardTokenizer.c b/core/Lucy/Test/Analysis/TestStandardTokenizer.c
index 063e17c..2400368 100644
--- a/core/Lucy/Test/Analysis/TestStandardTokenizer.c
+++ b/core/Lucy/Test/Analysis/TestStandardTokenizer.c
@@ -18,7 +18,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Analysis/TestStandardTokenizer.h"
 #include "Lucy/Analysis/StandardTokenizer.h"
@@ -26,27 +26,18 @@
 #include "Lucy/Util/Json.h"
 
 TestStandardTokenizer*
-TestStandardTokenizer_new(TestFormatter *formatter) {
-    TestStandardTokenizer *self
-        = (TestStandardTokenizer*)VTable_Make_Obj(TESTSTANDARDTOKENIZER);
-    return TestStandardTokenizer_init(self, formatter);
-}
-
-TestStandardTokenizer*
-TestStandardTokenizer_init(TestStandardTokenizer *self,
-                           TestFormatter *formatter) {
-    TestBatch_init((TestBatch*)self, 1084, formatter);
-    return self;
+TestStandardTokenizer_new() {
+    return (TestStandardTokenizer*)VTable_Make_Obj(TESTSTANDARDTOKENIZER);
 }
 
 static void
-test_Dump_Load_and_Equals(TestBatch *batch) {
+test_Dump_Load_and_Equals(TestBatchRunner *runner) {
     StandardTokenizer *tokenizer = StandardTokenizer_new();
     Obj *dump  = StandardTokenizer_Dump(tokenizer);
     StandardTokenizer *clone
         = (StandardTokenizer*)StandardTokenizer_Load(tokenizer, dump);
 
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               StandardTokenizer_Equals(tokenizer, (Obj*)clone),
               "Dump => Load round trip");
 
@@ -56,7 +47,7 @@ test_Dump_Load_and_Equals(TestBatch *batch) {
 }
 
 static void
-test_tokenizer(TestBatch *batch) {
+test_tokenizer(TestBatchRunner *runner) {
     StandardTokenizer *tokenizer = StandardTokenizer_new();
 
     ZombieCharBuf *word = ZCB_WRAP_STR(
@@ -71,31 +62,31 @@ test_tokenizer(TestBatch *batch) {
                               35);
     VArray *got = StandardTokenizer_Split(tokenizer, (CharBuf*)word);
     CharBuf *token = (CharBuf*)VA_Fetch(got, 0);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               token
               && CB_Is_A(token, CHARBUF)
               && CB_Equals_Str(token, "tha\xcc\x82t's", 8),
               "Token: %s", CB_Get_Ptr8(token));
     token = (CharBuf*)VA_Fetch(got, 1);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               token
               && CB_Is_A(token, CHARBUF)
               && CB_Equals_Str(token, "1,02\xC2\xADZ4.38", 11),
               "Token: %s", CB_Get_Ptr8(token));
     token = (CharBuf*)VA_Fetch(got, 2);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               token
               && CB_Is_A(token, CHARBUF)
               && CB_Equals_Str(token, "\xE0\xB8\x81\xC2\xAD\xC2\xAD", 7),
               "Token: %s", CB_Get_Ptr8(token));
     token = (CharBuf*)VA_Fetch(got, 3);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               token
               && CB_Is_A(token, CHARBUF)
               && CB_Equals_Str(token, "\xF0\xA0\x80\x80", 4),
               "Token: %s", CB_Get_Ptr8(token));
     token = (CharBuf*)VA_Fetch(got, 4);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               token
               && CB_Is_A(token, CHARBUF)
               && CB_Equals_Str(token, "a", 1),
@@ -121,7 +112,7 @@ test_tokenizer(TestBatch *batch) {
         CharBuf *text = (CharBuf*)Hash_Fetch_Str(test, "text", 4);
         VArray *wanted = (VArray*)Hash_Fetch_Str(test, "words", 5);
         VArray *got = StandardTokenizer_Split(tokenizer, text);
-        TEST_TRUE(batch, VA_Equals(wanted, (Obj*)got), "UCD test #%d", i + 1);
+        TEST_TRUE(runner, VA_Equals(wanted, (Obj*)got), "UCD test #%d", i + 1);
         DECREF(got);
     }
 
@@ -133,10 +124,10 @@ test_tokenizer(TestBatch *batch) {
 }
 
 void
-TestStandardTokenizer_run_tests(TestStandardTokenizer *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_Dump_Load_and_Equals(batch);
-    test_tokenizer(batch);
+TestStandardTokenizer_run(TestStandardTokenizer *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 1084);
+    test_Dump_Load_and_Equals(runner);
+    test_tokenizer(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Analysis/TestStandardTokenizer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Analysis/TestStandardTokenizer.cfh b/core/Lucy/Test/Analysis/TestStandardTokenizer.cfh
index 257879d..8e3d942 100644
--- a/core/Lucy/Test/Analysis/TestStandardTokenizer.cfh
+++ b/core/Lucy/Test/Analysis/TestStandardTokenizer.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Analysis::TestStandardTokenizer
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestStandardTokenizer*
-    new(TestFormatter *formatter);
-
-    inert TestStandardTokenizer*
-    init(TestStandardTokenizer *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestStandardTokenizer *self);
+    Run(TestStandardTokenizer *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Highlight/TestHeatMap.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Highlight/TestHeatMap.c b/core/Lucy/Test/Highlight/TestHeatMap.c
index 2f2da84..67b6397 100644
--- a/core/Lucy/Test/Highlight/TestHeatMap.c
+++ b/core/Lucy/Test/Highlight/TestHeatMap.c
@@ -17,7 +17,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Highlight/TestHeatMap.h"
 #include "Lucy/Highlight/HeatMap.h"
@@ -25,18 +25,12 @@
 #include "Lucy/Search/Span.h"
 
 TestHeatMap*
-TestHeatMap_new(TestFormatter *formatter) {
-    TestHeatMap *self = (TestHeatMap*)VTable_Make_Obj(TESTHEATMAP);
-    return TestHeatMap_init(self, formatter);
-}
-
-TestHeatMap*
-TestHeatMap_init(TestHeatMap *self, TestFormatter *formatter) {
-    return (TestHeatMap*)TestBatch_init((TestBatch*)self, 13, formatter);
+TestHeatMap_new() {
+    return (TestHeatMap*)VTable_Make_Obj(TESTHEATMAP);
 }
 
 static void
-test_calc_proximity_boost(TestBatch *batch) {
+test_calc_proximity_boost(TestBatchRunner *runner) {
     VArray  *spans    = VA_new(0);
     HeatMap *heat_map = HeatMap_new(spans, 133);
     Span    *span1    = Span_new(  0, 10, 1.0f);
@@ -50,10 +44,10 @@ test_calc_proximity_boost(TestBatch *batch) {
     float smaller_boost = HeatMap_Calc_Proximity_Boost(heat_map, span1, span4);
     float zero_boost    = HeatMap_Calc_Proximity_Boost(heat_map, span1, span5);
 
-    TEST_TRUE(batch, big_boost == eq_big_boost,
+    TEST_TRUE(runner, big_boost == eq_big_boost,
               "overlapping and abutting produce the same proximity boost");
-    TEST_TRUE(batch, big_boost > smaller_boost, "closer is better");
-    TEST_TRUE(batch, zero_boost == 0.0,
+    TEST_TRUE(runner, big_boost > smaller_boost, "closer is better");
+    TEST_TRUE(runner, zero_boost == 0.0,
               "distance outside of window yields no prox boost");
 
     DECREF(span1);
@@ -66,7 +60,7 @@ test_calc_proximity_boost(TestBatch *batch) {
 }
 
 static void
-test_flatten_spans(TestBatch *batch) {
+test_flatten_spans(TestBatchRunner *runner) {
     VArray  *spans    = VA_new(8);
     VArray  *wanted   = VA_new(8);
     HeatMap *heat_map = HeatMap_new(spans, 133);
@@ -79,12 +73,12 @@ test_flatten_spans(TestBatch *batch) {
     VA_Push(wanted, (Obj*)Span_new(10,  6, 1.0f));
     VA_Push(wanted, (Obj*)Span_new(16,  4, 3.0f));
     VA_Push(wanted, (Obj*)Span_new(20, 10, 2.0f));
-    TEST_TRUE(batch, VA_Equals(flattened, (Obj*)wanted),
+    TEST_TRUE(runner, VA_Equals(flattened, (Obj*)wanted),
               "flatten two overlapping spans");
     VA_Clear(wanted);
     boosts = HeatMap_Generate_Proximity_Boosts(heat_map, spans);
     VA_Push(wanted, (Obj*)Span_new(10, 20, 3.0f));
-    TEST_TRUE(batch, VA_Equals(boosts, (Obj*)wanted),
+    TEST_TRUE(runner, VA_Equals(boosts, (Obj*)wanted),
               "prox boosts for overlap");
     VA_Clear(wanted);
     VA_Clear(spans);
@@ -99,11 +93,11 @@ test_flatten_spans(TestBatch *batch) {
     VA_Push(wanted, (Obj*)Span_new(16,  4, 3.0f));
     VA_Push(wanted, (Obj*)Span_new(20, 10, 2.0f));
     VA_Push(wanted, (Obj*)Span_new(50,  1, 1.0f));
-    TEST_TRUE(batch, VA_Equals(flattened, (Obj*)wanted),
+    TEST_TRUE(runner, VA_Equals(flattened, (Obj*)wanted),
               "flatten two overlapping spans, leave hole, then third span");
     VA_Clear(wanted);
     boosts = HeatMap_Generate_Proximity_Boosts(heat_map, spans);
-    TEST_TRUE(batch, VA_Get_Size(boosts) == 2 + 1,
+    TEST_TRUE(runner, VA_Get_Size(boosts) == 2 + 1,
               "boosts generated for each unique pair, since all were in range");
     VA_Clear(spans);
     DECREF(boosts);
@@ -118,11 +112,11 @@ test_flatten_spans(TestBatch *batch) {
     VA_Push(wanted, (Obj*)Span_new(16,  2, 7.0f));
     VA_Push(wanted, (Obj*)Span_new(18,  2, 3.0f));
     VA_Push(wanted, (Obj*)Span_new(20, 10, 2.0f));
-    TEST_TRUE(batch, VA_Equals(flattened, (Obj*)wanted),
+    TEST_TRUE(runner, VA_Equals(flattened, (Obj*)wanted),
               "flatten three overlapping spans");
     VA_Clear(wanted);
     boosts = HeatMap_Generate_Proximity_Boosts(heat_map, spans);
-    TEST_TRUE(batch, VA_Get_Size(boosts) == 2 + 1,
+    TEST_TRUE(runner, VA_Get_Size(boosts) == 2 + 1,
               "boosts generated for each unique pair, since all were in range");
     VA_Clear(spans);
     DECREF(boosts);
@@ -137,11 +131,11 @@ test_flatten_spans(TestBatch *batch) {
     VA_Push(wanted, (Obj*)Span_new(16,  4,  7.0f));
     VA_Push(wanted, (Obj*)Span_new(20, 10,  6.0f));
     VA_Push(wanted, (Obj*)Span_new(30, 10, 10.0f));
-    TEST_TRUE(batch, VA_Equals(flattened, (Obj*)wanted),
+    TEST_TRUE(runner, VA_Equals(flattened, (Obj*)wanted),
               "flatten 4 spans, middle two have identical range");
     VA_Clear(wanted);
     boosts = HeatMap_Generate_Proximity_Boosts(heat_map, spans);
-    TEST_TRUE(batch, VA_Get_Size(boosts) == 3 + 2 + 1,
+    TEST_TRUE(runner, VA_Get_Size(boosts) == 3 + 2 + 1,
               "boosts generated for each unique pair, since all were in range");
     VA_Clear(spans);
     DECREF(boosts);
@@ -156,11 +150,11 @@ test_flatten_spans(TestBatch *batch) {
     VA_Push(wanted, (Obj*)Span_new( 16,  4,  7.0f));
     VA_Push(wanted, (Obj*)Span_new( 20, 10,  2.0f));
     VA_Push(wanted, (Obj*)Span_new(230, 10, 10.0f));
-    TEST_TRUE(batch, VA_Equals(flattened, (Obj*)wanted),
+    TEST_TRUE(runner, VA_Equals(flattened, (Obj*)wanted),
               "flatten 4 spans, middle two have identical starts but different ends");
     VA_Clear(wanted);
     boosts = HeatMap_Generate_Proximity_Boosts(heat_map, spans);
-    TEST_TRUE(batch, VA_Get_Size(boosts) == 2 + 1,
+    TEST_TRUE(runner, VA_Get_Size(boosts) == 2 + 1,
               "boosts not generated for out of range span");
     VA_Clear(spans);
     DECREF(boosts);
@@ -172,10 +166,10 @@ test_flatten_spans(TestBatch *batch) {
 }
 
 void
-TestHeatMap_run_tests(TestHeatMap *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_calc_proximity_boost(batch);
-    test_flatten_spans(batch);
+TestHeatMap_run(TestHeatMap *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 13);
+    test_calc_proximity_boost(runner);
+    test_flatten_spans(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Highlight/TestHeatMap.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Highlight/TestHeatMap.cfh b/core/Lucy/Test/Highlight/TestHeatMap.cfh
index 2a4ed5a..d7ec574 100644
--- a/core/Lucy/Test/Highlight/TestHeatMap.cfh
+++ b/core/Lucy/Test/Highlight/TestHeatMap.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Highlight::TestHeatMap
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestHeatMap*
-    new(TestFormatter *formatter);
-
-    inert TestHeatMap*
-    init(TestHeatMap *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestHeatMap *self);
+    Run(TestHeatMap *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Highlight/TestHighlighter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Highlight/TestHighlighter.c b/core/Lucy/Test/Highlight/TestHighlighter.c
index 808267b..fea4e62 100644
--- a/core/Lucy/Test/Highlight/TestHighlighter.c
+++ b/core/Lucy/Test/Highlight/TestHighlighter.c
@@ -18,7 +18,7 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Highlight/TestHighlighter.h"
 #include "Lucy/Highlight/Highlighter.h"
@@ -53,18 +53,12 @@
 #define TEST_STRING_LEN 425
 
 TestHighlighter*
-TestHighlighter_new(TestFormatter *formatter) {
-    TestHighlighter *self = (TestHighlighter*)VTable_Make_Obj(TESTHIGHLIGHTER);
-    return TestHighlighter_init(self, formatter);
-}
-
-TestHighlighter*
-TestHighlighter_init(TestHighlighter *self, TestFormatter *formatter) {
-    return (TestHighlighter*)TestBatch_init((TestBatch*)self, 35, formatter);
+TestHighlighter_new() {
+    return (TestHighlighter*)VTable_Make_Obj(TESTHIGHLIGHTER);
 }
 
 static void
-test_Find_Best_Fragment(TestBatch *batch, Searcher *searcher, Obj *query) {
+test_Find_Best_Fragment(TestBatchRunner *runner, Searcher *searcher, Obj *query) {
     CharBuf *content = (CharBuf*)ZCB_WRAP_STR("content", 7);
     Highlighter *highlighter = Highlighter_new(searcher, query, content, 3);
     ViewCharBuf *target = (ViewCharBuf*)ZCB_BLANK();
@@ -76,19 +70,19 @@ test_Find_Best_Fragment(TestBatch *batch, Searcher *searcher, Obj *query) {
     CharBuf *field_val = (CharBuf *)ZCB_WRAP_STR("a " PHI " " PHI " b c", 11);
     int32_t top = Highlighter_Find_Best_Fragment(highlighter, field_val,
                                                  target, heat_map);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str((CharBuf *)target, PHI " " PHI " b", 7),
               "Find_Best_Fragment");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 2,
               "correct offset returned by Find_Best_Fragment");
     field_val = (CharBuf *)ZCB_WRAP_STR("aa" PHI, 4);
     top = Highlighter_Find_Best_Fragment(highlighter, field_val,
                                          target, heat_map);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str((CharBuf *)target, "aa" PHI, 4),
               "Find_Best_Fragment returns whole field when field is short");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 0,
               "correct offset");
     DECREF(heat_map);
@@ -100,10 +94,10 @@ test_Find_Best_Fragment(TestBatch *batch, Searcher *searcher, Obj *query) {
     field_val = (CharBuf *)ZCB_WRAP_STR("aaaab" PHI PHI, 9);
     top = Highlighter_Find_Best_Fragment(highlighter, field_val,
                                          target, heat_map);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str((CharBuf *)target, "b" PHI PHI, 5),
               "Find_Best_Fragment shifts left to deal with overrun");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 4,
               "correct offset");
     DECREF(heat_map);
@@ -115,10 +109,10 @@ test_Find_Best_Fragment(TestBatch *batch, Searcher *searcher, Obj *query) {
     field_val = (CharBuf *)ZCB_WRAP_STR("a" PHI "bcde", 7);
     top = Highlighter_Find_Best_Fragment(highlighter, field_val,
                                          target, heat_map);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str((CharBuf *)target, "a" PHI "bcd", 6),
               "Find_Best_Fragment start at field beginning");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 0,
               "correct offset");
     DECREF(heat_map);
@@ -127,7 +121,7 @@ test_Find_Best_Fragment(TestBatch *batch, Searcher *searcher, Obj *query) {
 }
 
 static void
-test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
+test_Raw_Excerpt(TestBatchRunner *runner, Searcher *searcher, Obj *query) {
     CharBuf *content = (CharBuf*)ZCB_WRAP_STR("content", 7);
     Highlighter *highlighter = Highlighter_new(searcher, query, content, 6);
 
@@ -143,10 +137,10 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     VA_Push(sentences, (Obj*)Span_new(6, 4, 0.0f));
     int32_t top = Highlighter_Raw_Excerpt(highlighter, field_val, fragment,
                                           raw_excerpt, 0, heat_map, sentences);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(raw_excerpt, "Ook.", 4),
               "Raw_Excerpt at top");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 0,
               "top still 0");
     DECREF(sentences);
@@ -159,10 +153,10 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     VA_Push(sentences, (Obj*)Span_new(12, 4, 0.0f));
     top = Highlighter_Raw_Excerpt(highlighter, field_val, fragment,
                                   raw_excerpt, 3, heat_map, sentences);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(raw_excerpt, "Urk.", 4),
               "Raw_Excerpt in middle, with 2 bounds");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 6,
               "top in the middle modified by Raw_Excerpt");
     DECREF(sentences);
@@ -180,10 +174,10 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     VA_Push(sentences, (Obj*)Span_new(0, 14, 0.0f));
     top = Highlighter_Raw_Excerpt(highlighter, field_val, fragment,
                                   raw_excerpt, 8, heat_map, sentences);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(raw_excerpt, ELLIPSIS " i.", 6),
               "Ellipsis at top");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 10,
               "top correct when leading ellipsis inserted");
     DECREF(sentences);
@@ -201,10 +195,10 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     VA_Push(sentences, (Obj*)Span_new(6, 11, 0.0f));
     top = Highlighter_Raw_Excerpt(highlighter, field_val, fragment,
                                   raw_excerpt, 4, heat_map, sentences);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(raw_excerpt, "Iz no" ELLIPSIS, 8),
               "Ellipsis at end");
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               top == 6,
               "top trimmed");
     DECREF(sentences);
@@ -224,7 +218,7 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     DECREF(spans);
     top = Highlighter_Raw_Excerpt(highlighter, field_val, field_val,
                                   raw_excerpt, 0, heat_map, sentences);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(raw_excerpt, "abc/d" ELLIPSIS, 8),
               "Long word");
     DECREF(heat_map);
@@ -237,7 +231,7 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     DECREF(spans);
     top = Highlighter_Raw_Excerpt(highlighter, field_val, field_val,
                                   raw_excerpt, 0, heat_map, sentences);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(raw_excerpt, ELLIPSIS " c/d" ELLIPSIS, 10),
               "Long word");
     DECREF(heat_map);
@@ -249,7 +243,7 @@ test_Raw_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
 }
 
 static void
-test_Highlight_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
+test_Highlight_Excerpt(TestBatchRunner *runner, Searcher *searcher, Obj *query) {
     CharBuf *content = (CharBuf*)ZCB_WRAP_STR("content", 7);
     Highlighter *highlighter = Highlighter_new(searcher, query, content, 3);
 
@@ -259,7 +253,7 @@ test_Highlight_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     CharBuf *highlighted = CB_new(0);
     Highlighter_Highlight_Excerpt(highlighter, spans, raw_excerpt,
                                   highlighted, 0);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(highlighted, "a <strong>b</strong> c", 22),
               "basic Highlight_Excerpt");
     DECREF(highlighted);
@@ -272,7 +266,7 @@ test_Highlight_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     highlighted = CB_new(0);
     Highlighter_Highlight_Excerpt(highlighter, spans, raw_excerpt,
                                   highlighted, 0);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(highlighted, "<strong>&#934;</strong>", 23),
               "don't surround spans off end of raw excerpt.");
     DECREF(highlighted);
@@ -284,7 +278,7 @@ test_Highlight_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     highlighted = CB_new(0);
     Highlighter_Highlight_Excerpt(highlighter, spans, raw_excerpt,
                                   highlighted, 1);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(highlighted,
                             "&#934; <strong>&#934;</strong> &#934;", 37),
               "Highlight_Excerpt pays attention to offset");
@@ -300,7 +294,7 @@ test_Highlight_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
     highlighted = CB_new(0);
     Highlighter_Highlight_Excerpt(highlighter, spans, raw_excerpt,
                                   highlighted, 0);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Equals_Str(highlighted,
                             "&#934; <strong>Oook. Urk. Ick.</strong> &#934;",
                             46),
@@ -312,14 +306,14 @@ test_Highlight_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query) {
 }
 
 static void
-test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
+test_Create_Excerpt(TestBatchRunner *runner, Searcher *searcher, Obj *query,
                     Hits *hits) {
     CharBuf *content = (CharBuf*)ZCB_WRAP_STR("content", 7);
     Highlighter *highlighter = Highlighter_new(searcher, query, content, 200);
 
     HitDoc *hit = Hits_Next(hits);
     CharBuf *excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt,
                           "<strong>&#934;</strong> a b c d <strong>x y z</strong>",
                           54) >= 0,
@@ -331,7 +325,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
     CharBuf *post_tag = (CharBuf*)ZCB_WRAP_STR("\x1B[0m", 4);
     Highlighter_Set_Post_Tag(highlighter, post_tag);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt,
                           "\x1B[1m&#934;\x1B[0m a b c d \x1B[1mx y z\x1B[0m",
                           36) >= 0,
@@ -341,7 +335,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
 
     hit = Hits_Next(hits);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt, "x", 1) >= 0,
               "excerpt field with partial hit doesn't cause highlighter freakout");
     DECREF(excerpt);
@@ -353,7 +347,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
     highlighter = Highlighter_new(searcher, query, content, 200);
     hit = Hits_Next(hits);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt,
                           "<strong>b</strong> c d <strong>x y z</strong>",
                           45) >= 0,
@@ -368,7 +362,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
     highlighter = Highlighter_new(searcher, query, content, 200);
     hit = Hits_Next(hits);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt, "&quot;", 6) >= 0,
               "HTML entity encoded properly");
     DECREF(excerpt);
@@ -381,7 +375,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
     highlighter = Highlighter_new(searcher, query, content, 200);
     hit = Hits_Next(hits);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt, "&#934;", 6) == -1,
               "no ellipsis for short excerpt");
     DECREF(excerpt);
@@ -395,7 +389,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
     hit = Hits_Next(hits);
     highlighter = Highlighter_new(searcher, query, content, 200);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt, "strong", 5) >= 0,
               "specify field highlights correct field...");
     DECREF(excerpt);
@@ -403,7 +397,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
     CharBuf *alt = (CharBuf*)ZCB_WRAP_STR("alt", 3);
     highlighter = Highlighter_new(searcher, query, alt, 200);
     excerpt = Highlighter_Create_Excerpt(highlighter, hit);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               CB_Find_Str(excerpt, "strong", 5) == -1,
               "... but not another field");
     DECREF(excerpt);
@@ -414,7 +408,7 @@ test_Create_Excerpt(TestBatch *batch, Searcher *searcher, Obj *query,
 }
 
 static void
-test_Find_Sentences(TestBatch *batch, Searcher *searcher, Obj *query) {
+test_Find_Sentences(TestBatchRunner *runner, Searcher *searcher, Obj *query) {
     CharBuf *content = (CharBuf*)ZCB_WRAP_STR("content", 7);
     Highlighter *highlighter = Highlighter_new(searcher, query, content, 200);
     CharBuf *text = (CharBuf*)ZCB_WRAP_STR(
@@ -429,14 +423,14 @@ test_Find_Sentences(TestBatch *batch, Searcher *searcher, Obj *query) {
     VArray *wanted = VA_new(2);
     VA_Push(wanted, (Obj*)Span_new(120, 19, 0.0f));
     VA_Push(wanted, (Obj*)Span_new(140, 19, 0.0f));
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               VA_Equals(got, (Obj*)wanted),
               "find_sentences with explicit args");
     DECREF(wanted);
     DECREF(got);
 
     got = Highlighter_Find_Sentences(highlighter, text, 101, 4);
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               VA_Get_Size(got) == 0,
               "find_sentences with explicit args, finding nothing");
     DECREF(got);
@@ -446,7 +440,7 @@ test_Find_Sentences(TestBatch *batch, Searcher *searcher, Obj *query) {
     for (int i = 0; i < 15; ++i) {
         VA_Push(wanted, (Obj*)Span_new(i * 20, 19, 0.0f));
     }
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               VA_Equals(got, (Obj*)wanted),
               "find_sentences with default offset and length");
     DECREF(wanted);
@@ -456,7 +450,7 @@ test_Find_Sentences(TestBatch *batch, Searcher *searcher, Obj *query) {
     got = Highlighter_Find_Sentences(highlighter, text, 0, 0);
     wanted = VA_new(1);
     VA_Push(wanted, (Obj*)Span_new(1, 3, 0.0f));
-    TEST_TRUE(batch,
+    TEST_TRUE(runner,
               VA_Equals(got, (Obj*)wanted),
               "Skip leading whitespace but get first sentence");
     DECREF(wanted);
@@ -466,7 +460,7 @@ test_Find_Sentences(TestBatch *batch, Searcher *searcher, Obj *query) {
 }
 
 static void
-test_highlighting(TestBatch *batch) {
+test_highlighting(TestBatchRunner *runner) {
     Schema *schema = Schema_new();
     StandardTokenizer *tokenizer = StandardTokenizer_new();
     FullTextType *plain_type = FullTextType_new((Analyzer*)tokenizer);
@@ -514,11 +508,11 @@ test_highlighting(TestBatch *batch) {
     Obj *query = (Obj*)ZCB_WRAP_STR("\"x y z\" AND " PHI, 14);
     Hits *hits = Searcher_Hits(searcher, query, 0, 10, NULL);
 
-    test_Find_Best_Fragment(batch, searcher, query);
-    test_Raw_Excerpt(batch, searcher, query);
-    test_Highlight_Excerpt(batch, searcher, query);
-    test_Create_Excerpt(batch, searcher, query, hits);
-    test_Find_Sentences(batch, searcher, query);
+    test_Find_Best_Fragment(runner, searcher, query);
+    test_Raw_Excerpt(runner, searcher, query);
+    test_Highlight_Excerpt(runner, searcher, query);
+    test_Create_Excerpt(runner, searcher, query, hits);
+    test_Find_Sentences(runner, searcher, query);
 
     DECREF(hits);
     DECREF(searcher);
@@ -527,7 +521,7 @@ test_highlighting(TestBatch *batch) {
 }
 
 static void
-test_hl_selection(TestBatch *batch) {
+test_hl_selection(TestBatchRunner *runner) {
     Schema *schema = Schema_new();
     StandardTokenizer *tokenizer = StandardTokenizer_new();
     FullTextType *plain_type = FullTextType_new((Analyzer*)tokenizer);
@@ -571,7 +565,7 @@ test_hl_selection(TestBatch *batch) {
     CharBuf *excerpt = Highlighter_Create_Excerpt(highlighter, hit);
     CharBuf *mmm = (CharBuf*)ZCB_WRAP_STR("MMM", 3);
     CharBuf *nnn = (CharBuf*)ZCB_WRAP_STR("NNN", 3);
-    TEST_TRUE(batch, CB_Find(excerpt, mmm) >= 0 || CB_Find(excerpt, nnn) >= 0,
+    TEST_TRUE(runner, CB_Find(excerpt, mmm) >= 0 || CB_Find(excerpt, nnn) >= 0,
               "Sentence boundary algo doesn't chop terms");
 
     DECREF(excerpt);
@@ -584,10 +578,10 @@ test_hl_selection(TestBatch *batch) {
 }
 
 void
-TestHighlighter_run_tests(TestHighlighter *self) {
-    TestBatch *batch = (TestBatch*)self;
-    test_highlighting(batch);
-    test_hl_selection(batch);
+TestHighlighter_run(TestHighlighter *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 35);
+    test_highlighting(runner);
+    test_hl_selection(runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Highlight/TestHighlighter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Highlight/TestHighlighter.cfh b/core/Lucy/Test/Highlight/TestHighlighter.cfh
index 848836d..8cd625a 100644
--- a/core/Lucy/Test/Highlight/TestHighlighter.cfh
+++ b/core/Lucy/Test/Highlight/TestHighlighter.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Highlight::TestHighlighter
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestHighlighter*
-    new(TestFormatter *formatter);
-
-    inert TestHighlighter*
-    init(TestHighlighter *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestHighlighter *self);
+    Run(TestHighlighter *self, TestBatchRunner *runner);
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Index/TestDocWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Index/TestDocWriter.c b/core/Lucy/Test/Index/TestDocWriter.c
index 879d830..64747ec 100644
--- a/core/Lucy/Test/Index/TestDocWriter.c
+++ b/core/Lucy/Test/Index/TestDocWriter.c
@@ -18,26 +18,20 @@
 #define TESTLUCY_USE_SHORT_NAMES
 #include "Lucy/Util/ToolSet.h"
 
-#include "Clownfish/TestHarness/TestFormatter.h"
+#include "Clownfish/TestHarness/TestBatchRunner.h"
 #include "Lucy/Test.h"
 #include "Lucy/Test/Index/TestDocWriter.h"
 #include "Lucy/Index/DocWriter.h"
 
 TestDocWriter*
-TestDocWriter_new(TestFormatter *formatter) {
-    TestDocWriter *self = (TestDocWriter*)VTable_Make_Obj(TESTDOCWRITER);
-    return TestDocWriter_init(self, formatter);
-}
-
-TestDocWriter*
-TestDocWriter_init(TestDocWriter *self, TestFormatter *formatter) {
-    return (TestDocWriter*)TestBatch_init((TestBatch*)self, 1, formatter);
+TestDocWriter_new() {
+    return (TestDocWriter*)VTable_Make_Obj(TESTDOCWRITER);
 }
 
 void
-TestDocWriter_run_tests(TestDocWriter *self) {
-    TestBatch *batch = (TestBatch*)self;
-    PASS(batch, "placeholder");
+TestDocWriter_run(TestDocWriter *self, TestBatchRunner *runner) {
+    TestBatchRunner_Plan(runner, (TestBatch*)self, 1);
+    PASS(runner, "placeholder");
 }
 
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/fe99ba64/core/Lucy/Test/Index/TestDocWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Test/Index/TestDocWriter.cfh b/core/Lucy/Test/Index/TestDocWriter.cfh
index 1426d1c..8d9b2a1 100644
--- a/core/Lucy/Test/Index/TestDocWriter.cfh
+++ b/core/Lucy/Test/Index/TestDocWriter.cfh
@@ -20,13 +20,10 @@ class Lucy::Test::Index::TestDocWriter
     inherits Clownfish::TestHarness::TestBatch {
 
     inert incremented TestDocWriter*
-    new(TestFormatter *formatter);
-
-    inert TestDocWriter*
-    init(TestDocWriter *self, TestFormatter *formatter);
+    new();
 
     void
-    Run_Tests(TestDocWriter *self);
+    Run(TestDocWriter *self, TestBatchRunner *runner);
 }