glean: Remove support for comparing result databases.

I suspect most people simply use piglit-summary-html.py to compare
results across test runs.  Piglit also supports comparing more than two
test runs.

In some cases, Glean's code did offer more detailed information such as
image comparisons (although not all tests implemented such features).
However, I doubt anyone was using this: driver developers typically
analyze failures by hand, comparing not only image results, but also
shader code and hardware state.

30 files changed, 10 insertions, 1132 deletions

diff --git a/tests/glean/environ.cpp b/tests/glean/environ.cpp
index a05c165dc..d06a9666e 100644
--- a/tests/glean/environ.cpp
+++ b/tests/glean/environ.cpp
@@ -77,14 +77,6 @@ Environment::Environment(Options& opt):
 			else
 				throw DBCantOpen(opt.db1Name);
 		}
-	// If comparing previous runs, make a token attempt to verify
-	// that the two databases exist.
-	} else {
-		struct stat s;
-		if (stat(opt.db1Name.c_str(), &s) || !S_ISDIR(s.st_mode))
-			throw DBCantOpen(opt.db1Name);
-		if (stat(opt.db2Name.c_str(), &s) || !S_ISDIR(s.st_mode))
-			throw DBCantOpen(opt.db2Name);
 	}
 
 #   elif defined(__MS__)
@@ -106,15 +98,6 @@ Environment::Environment(Options& opt):
 			else
 				throw DBCantOpen(opt.db1Name);
 		}
-	// If comparing previous runs, make a token attempt to verify
-	// that the two databases exist.
-	} else {
-		struct _stat s; 
-
-		if (_stat(opt.db1Name.c_str(), &s) || !(s.st_mode & _S_IFDIR))
-			throw DBCantOpen(opt.db1Name);
-		if (_stat(opt.db2Name.c_str(), &s) || !(s.st_mode & _S_IFDIR))
-			throw DBCantOpen(opt.db2Name);
 	}
 
 #   endif
diff --git a/tests/glean/environ.h b/tests/glean/environ.h
index 5cd003292..30b907d3c 100644
--- a/tests/glean/environ.h
+++ b/tests/glean/environ.h
@@ -78,12 +78,6 @@ class Environment {
 	inline string resultFileName(string& testName) {
 		return resultFileName(options.db1Name, testName);
 	}
-	inline string result1FileName(string& testName) {
-		return resultFileName(options.db1Name, testName);
-	}
-	inline string result2FileName(string& testName) {
-		return resultFileName(options.db2Name, testName);
-	}
 
 	string imageFileName(string& dbName, string& testName, int n);
 				// Return name of image file number ``n''
@@ -94,12 +88,6 @@ class Environment {
 	inline string imageFileName(string& testName, int n) {
 		return imageFileName(options.db1Name, testName, n);
 	}
-	inline string image1FileName(string& testName, int n) {
-		return imageFileName(options.db1Name, testName, n);
-	}
-	inline string image2FileName(string& testName, int n) {
-		return imageFileName(options.db2Name, testName, n);
-	}
 
 }; // class Environment
 
diff --git a/tests/glean/main.cpp b/tests/glean/main.cpp
index b29f0aa0e..5b8ce1ae7 100644
--- a/tests/glean/main.cpp
+++ b/tests/glean/main.cpp
@@ -85,13 +85,6 @@ main(int argc, char* argv[]) {
 			o.overwrite = true;
 		} else if (!strcmp(argv[i], "--quick")) {
 			o.quick = true;
-		} else if (!strcmp(argv[i], "-c")
-		    || !strcmp(argv[i], "--compare")) {
-			o.mode = Options::compare;
-			++i;
-			o.db1Name = mandatoryArg(argc, argv, i);
-			++i;
-			o.db2Name = mandatoryArg(argc, argv, i);
 		} else if (!strcmp(argv[i], "--visuals")) {
 			visFilter = true;
 			++i;
@@ -129,7 +122,7 @@ main(int argc, char* argv[]) {
 	}
 
 	// Create the test environment, then invoke each test to generate
-	// results or compare two previous runs.
+	// results.
 	try {
 		Environment e(o);
 		switch (o.mode) {
@@ -141,30 +134,6 @@ main(int argc, char* argv[]) {
                                         t->run(e);
 			break;
 		}
-		case Options::compare:
-		{
-			for (Test* t = Test::testList; t; t = t->nextTest)
-				if (binary_search(o.selectedTests.begin(),
-				    o.selectedTests.end(), t->name))
-					try {
-						t->compare(e);
-					}
-					catch (Test::CantOpenResultsFile e) {
-						// For comparisons, we want to
-						// continue running even if a
-						// test result file can't be
-						// opened.  We report the
-						// problem here, but don't exit
-						// as we would in the catch{}
-						// below.
-						cerr << "Can't open results file for test "
-							<< e.testName
-							<< " in database "
-							<< e.dbName
-							<< '\n';
-					}
-			break;
-		}
 		default:
 			cerr << "Bad run mode in main()\n";
 			break;
@@ -325,7 +294,6 @@ usage(char* command) {
 "\n"
 "mode:\n"
 "       (-r|--run) results-directory\n"
-"   or  (-c|--compare) old-results-dir new-results-dir\n"
 "\n"
 "options:\n"
 "       (-v|--verbose)             # each occurrence increases\n"
diff --git a/tests/glean/options.cpp b/tests/glean/options.cpp
index 051eb3211..a221a91a5 100644
--- a/tests/glean/options.cpp
+++ b/tests/glean/options.cpp
@@ -44,7 +44,6 @@ Options::Options() {
 	mode = notSet;
 	verbosity = 0;
 	db1Name = "results";
-	db2Name = "previous";
 	visFilter = "1";
 	maxVisuals = ~0U;
 	selectedTests.resize(0);
diff --git a/tests/glean/options.h b/tests/glean/options.h
index 60a47ab00..c68dc7153 100644
--- a/tests/glean/options.h
+++ b/tests/glean/options.h
@@ -57,21 +57,17 @@ namespace GLEAN {
 
 class Options {
     public:
-	typedef enum {notSet, run, compare, listtests} RunMode;
+	typedef enum {notSet, run, listtests} RunMode;
 	RunMode mode;		// Indicates whether we're generating
 				// results, or comparing two previous runs.
 
 	int verbosity;		// Verbosity level.  0 == concise; larger
 				// values imply more verbose output.
 
-	string db1Name;		// Name of output database, or one of
-				// the two databases being compared.
+	string db1Name;		// Name of output database.
 				// Typically the pathname of a directory,
 				// provided on the command line.
 
-	string db2Name;		// Name of the second database being
-				// compared.
-
 	string visFilter;	// Filter constraining the set of visuals
 				// (FBConfigs, pixel formats) that will be
 				// available for test.  See
diff --git a/tests/glean/tbase.h b/tests/glean/tbase.h
index 667a2a98c..d4f283fdf 100644
--- a/tests/glean/tbase.h
+++ b/tests/glean/tbase.h
@@ -48,10 +48,9 @@ those variables from and to a stream.
 
 The template class, BaseTest, is parameterized by the result class and
 declares member functions and variables that are common to all
-portable tests.  These include the member functions run() and
-compare() which are invoked for each test by main().  BaseTest also
-provides several variables which you might want to use when
-constructing a test:
+portable tests.  This includes the member function run() which is
+invoked for each test by main().  BaseTest also provides several
+variables which you might want to use when constructing a test:
 
 	A drawing surface filter string.  The test can be run on all
 	the drawing surface configurations that are selected by the
@@ -79,11 +78,10 @@ constructing a test:
 	"prerequisite" tests available.
 
 To use BaseTest, declare a new class derived from BaseTest,
-parameterized by your result class.  Then override the runOne(),
-compareOne(), and logOne() member functions.  runOne() runs a test and
-generates a result.  compareOne() compares one result from a test run
-with the same result from another test run.  logOne() generates a log
-message summarizing the result of the test.
+parameterized by your result class.  Then override the runOne()
+and logOne() member functions.  runOne() runs a test and generates a
+result.  logOne() generates a log message summarizing the result of
+the test.
 
 Your new test will need a few common declarations (such as
 constructors).  To simplify writing them, this file provides a few
@@ -157,7 +155,6 @@ and tbasic.cpp.
 	virtual ~TEST() {}                                                    \
                                                                               \
 	virtual void runOne(RESULT& r, Window& w);                            \
-	virtual void compareOne(RESULT& oldR, RESULT& newR);                  \
 	virtual void logOne(RESULT& r)
 
 // Macro for constructor for Glean test taking width, height
@@ -247,7 +244,6 @@ public:
 	vector<ResultType*> results;     // Test results.
 
 	virtual void runOne(ResultType& r, Window& w) = 0;
-	virtual void compareOne(ResultType& oldR, ResultType& newR) = 0;
 	virtual void logOne(ResultType& r) = 0;
 
 	virtual vector<ResultType*> getResults(istream& s) {
@@ -363,81 +359,6 @@ public:
 		hasRun = true;	// Note that we've completed the run
 	}
 
-	virtual void compare(Environment& environment) {
-		env = &environment; // Save the environment
-		logDescription();
-		// Read results from previous runs:
-		Input1Stream is1(*this);
-		vector<ResultType*> oldR(getResults(is1));
-		Input2Stream is2(*this);
-		vector<ResultType*> newR(getResults(is2));
-
-		// Construct a vector of surface configurations from the
-		// old run.  (Later we'll find the best match in this
-		// vector for each config in the new run.)
-		vector<DrawingSurfaceConfig*> oldConfigs;
-		for (typename vector<ResultType*>::const_iterator p = oldR.begin();
-		     p < oldR.end();
-		     ++p)
-			oldConfigs.push_back((*p)->config);
-
-		// Compare results:
-		for (typename vector<ResultType*>::const_iterator newP = newR.begin();
-		     newP < newR.end();
-		     ++newP) {
-
-			// Find the drawing surface config that most
-			// closely matches the config for this result:
-			int c = (*newP)->config->match(oldConfigs);
-
-			// If there was a match, compare the results:
-			if (c < 0)
-				env->log << name
-					 << ":  NOTE no matching config for "
-					 << (*newP)
-					->config->conciseDescription()
-					 << '\n';
-			else
-				compareOne(*(oldR[c]), **newP);
-		}
-
-		// Get rid of the results; we don't need them for future
-		// comparisons.
-		for (typename vector<ResultType*>::iterator np = newR.begin();
-		     np < newR.end();
-		     ++np)
-			delete *np;
-		for (typename vector<ResultType*>::iterator op = oldR.begin();
-		     op < oldR.end();
-		     ++op)
-			delete *op;
-	}
-
-	// comparePassFail is a helper function for tests that have a
-	// boolean result as all or part of their ResultType
-	virtual void comparePassFail(ResultType& oldR, ResultType& newR) {
-		if (oldR.pass == newR.pass) {
-			if (env->options.verbosity)
-				env->log << name
-					 << ":  SAME "
-					 << newR.config->conciseDescription()
-					 << '\n'
-					 << (oldR.pass
-					     ? "\tBoth PASS\n"
-					     : "\tBoth FAIL\n");
-		} else {
-			env->log << name
-				 << ":  DIFF "
-				 << newR.config->conciseDescription()
-				 << '\n'
-				 << '\t'
-				 << env->options.db1Name
-				 << (oldR.pass? " PASS, ": " FAIL, ")
-				 << env->options.db2Name
-				 << (newR.pass? " PASS\n": " FAIL\n");
-		}
-	}
-
 	virtual void logPassFail(ResultType& r) {
 		env->log << name << (r.pass ? ":  PASS ": ":  FAIL ");
 	}
diff --git a/tests/glean/tbasic.cpp b/tests/glean/tbasic.cpp
index b4fab0233..1e5fe2e55 100644
--- a/tests/glean/tbasic.cpp
+++ b/tests/glean/tbasic.cpp
@@ -50,14 +50,6 @@ BasicTest::logOne(BasicResult& r) {
 } // BasicTest::logOne
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-BasicTest::compareOne(BasicResult& oldR, BasicResult& newR) {
-	comparePassFail(oldR, newR);
-} // BasicTest::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 BasicTest basicTest("basic", "window",
diff --git a/tests/glean/tbinding.cpp b/tests/glean/tbinding.cpp
index c73cfae48..e2b4e44ae 100644
--- a/tests/glean/tbinding.cpp
+++ b/tests/glean/tbinding.cpp
@@ -189,14 +189,6 @@ MakeCurrentTest::logOne(MakeCurrentResult& r) {
 } // MakeCurrentTestTest::logOne
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-MakeCurrentTest::compareOne(MakeCurrentResult& oldR, MakeCurrentResult& newR) {
-	comparePassFail(oldR, newR);
-} // MakeCurrentTest::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 MakeCurrentTest makeCurrentTest("makeCurrent", "window, rgb",
diff --git a/tests/glean/tblend.cpp b/tests/glean/tblend.cpp
index 4d65c887e..661172954 100644
--- a/tests/glean/tblend.cpp
+++ b/tests/glean/tblend.cpp
@@ -938,98 +938,6 @@ BlendFuncTest::printMode(const BlendFuncResult::PartialResult &r) const
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-BlendFuncTest::compareOne(BlendFuncResult& oldR, BlendFuncResult& newR) {
-	BasicStats readbackStats;
-	BasicStats blendStats;
-
-	vector<BlendFuncResult::PartialResult>::const_iterator np;
-	vector<BlendFuncResult::PartialResult>::const_iterator op;
-
-	for (np = newR.results.begin(); np != newR.results.end(); ++np)
-		// Find the matching case, if any, in the old results:
-		for (op = oldR.results.begin(); op != oldR.results.end(); ++op)
-			if (equalMode(*np, *op)) {
-				readbackStats.sample(np->rbErr - op->rbErr);
-				blendStats.sample(np->blErr - op->blErr);
-			}
-
-	if (readbackStats.n() == static_cast<int>(newR.results.size())
-	    && newR.results.size() == oldR.results.size()
-	    && readbackStats.mean() == 0.0 && blendStats.mean() == 0.0) {
-		if (env->options.verbosity)
-			env->log << name << ": SAME "
-				<< newR.config->conciseDescription() << '\n';
-	} else {
-		env->log << name << ": DIFF "
-			<< newR.config->conciseDescription() << '\n';
-
-		if (readbackStats.mean() < 0.0)
-			env->log << '\t' << env->options.db2Name
-				<< " appears to have more accurate readback.\n";
-		else if (readbackStats.mean() > 0.0)
-			env->log << '\t' << env->options.db1Name
-				<< " appears to have more accurate readback.\n";
-		if (blendStats.mean() < 0.0)
-			env->log << '\t' << env->options.db2Name
-				<< " appears to have more accurate blending.\n";
-		else if (blendStats.mean() > 0.0)
-			env->log << '\t' << env->options.db1Name
-				<< " appears to have more accurate blending.\n";
-		if (readbackStats.n() != static_cast<int>(newR.results.size())){
-			env->log << "\tThe following cases in "
-				<< env->options.db2Name
-				<< " have no matching test in "
-				<< env->options.db1Name
-				<< ":\n";
-			for (np = newR.results.begin();
-			    np != newR.results.end(); ++np) {
-				for (op = oldR.results.begin();
-				    op != oldR.results.end(); ++op)
-					if (equalMode(*np, *op))
-						break;
-				if (op == oldR.results.end())
-					printMode(*np);
-			}
-		}
-		if (readbackStats.n() != static_cast<int>(oldR.results.size())){
-			env->log << "\tThe following cases in "
-				<< env->options.db1Name
-				<< " have no matching test in "
-				<< env->options.db2Name
-				<< ":\n";
-			for (op = oldR.results.begin();
-			    op != oldR.results.end(); ++op) {
-				for (np = newR.results.begin();
-				    np != newR.results.end(); ++np)
-					if (equalMode(*op, *np))
-						break;
-				if (np == newR.results.end())
-					printMode(*op);
-			}
-		}
-		if (env->options.verbosity) {
-			env->log << "\tThe following cases appear in both "
-				<< env->options.db1Name
-				<< " and "
-				<< env->options.db2Name
-				<< ":\n";
-			for (np = newR.results.begin();
-			    np != newR.results.end(); ++np){
-				for (op = oldR.results.begin();
-				    op != oldR.results.end(); ++op)
-					if (equalMode(*op, *np))
-						break;
-				if (op != oldR.results.end())
-					printMode(*op);
-			}
-		}
-	}
-} // BlendFuncTest::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // Result I/O functions:
 ///////////////////////////////////////////////////////////////////////////////
 void
diff --git a/tests/glean/tbufferobject.cpp b/tests/glean/tbufferobject.cpp
index 6ab2ea2a2..3ed464b1f 100644
--- a/tests/glean/tbufferobject.cpp
+++ b/tests/glean/tbufferobject.cpp
@@ -284,14 +284,6 @@ BufferObjectTest::logOne(BufferObjectResult &r)
 
 
 void
-BufferObjectTest::compareOne(BufferObjectResult &oldR,
-			     BufferObjectResult &newR)
-{
-   comparePassFail(oldR, newR);
-}
-
-
-void
 BufferObjectResult::putresults(ostream &s) const
 {
    if (pass) {
diff --git a/tests/glean/tclipflat.cpp b/tests/glean/tclipflat.cpp
index cb62ef1c6..843193ee1 100644
--- a/tests/glean/tclipflat.cpp
+++ b/tests/glean/tclipflat.cpp
@@ -565,14 +565,6 @@ ClipFlatTest::logOne(ClipFlatResult &r)
 
 
 void
-ClipFlatTest::compareOne(ClipFlatResult &oldR,
-			     ClipFlatResult &newR)
-{
-   comparePassFail(oldR, newR);
-}
-
-
-void
 ClipFlatResult::putresults(ostream &s) const
 {
    if (pass) {
diff --git a/tests/glean/tdepthstencil.cpp b/tests/glean/tdepthstencil.cpp
index 20cb594d4..7de5d3475 100644
--- a/tests/glean/tdepthstencil.cpp
+++ b/tests/glean/tdepthstencil.cpp
@@ -299,35 +299,6 @@ DepthStencilTest::logOne(DepthStencilResult &r)
 
 
 void
-DepthStencilTest::compareOne(DepthStencilResult &oldR,
-			     DepthStencilResult &newR)
-{
-	comparePassFail(oldR, newR);
-
-	if (newR.pass && oldR.pass == newR.pass) {
-		if (env->options.verbosity) {
-			env->log << "\tReadPixels rate:\n";
-			env->log << "\t\tGL_DEPTH_STENCIL:\n";
-			env->log << "\t\t\told: " << oldR.readDepthStencilRate;
-			env->log << "\t\t\tnew: " << newR.readDepthStencilRate;
-			env->log << "\t\tGL_DEPTH/GL_UNSIGNED_INT:\n";
-			env->log << "\t\t\told: " << oldR.readDepthUintRate;
-			env->log << "\t\t\tnew: " << newR.readDepthUintRate;
-			env->log << "\t\tGL_DEPTH/GL_UNSIGNED_SHORT:\n";
-			env->log << "\t\t\told: " << oldR.readDepthUshortRate;
-			env->log << "\t\t\tnew: " << newR.readDepthUshortRate;
-		}
-	}
-	else {
-		env->log << "\tNew: ";
-		env->log << (newR.pass ? "PASS" : "FAIL");
-		env->log << "\tOld: ";
-		env->log << (oldR.pass ? "PASS" : "FAIL");
-	}
-}
-
-
-void
 DepthStencilResult::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/test.cpp b/tests/glean/test.cpp
index 0d3dbfb6b..f94680ff0 100644
--- a/tests/glean/test.cpp
+++ b/tests/glean/test.cpp
@@ -115,20 +115,4 @@ Test::Input1Stream::operator ifstream& () {
 	return *s;
 } // Test::Input1Stream::operator ::ifstream&
 
-Test::Input2Stream::Input2Stream(Test& t) {
-	s = new ifstream(t.env->resultFileName(
-		t.env->options.db2Name, t.name).c_str());
-	if (!*s)
-		throw Test::CantOpenResultsFile(t.name, t.env->options.db2Name);
-} // Test::Input2Stream::Input2Stream
-
-Test::Input2Stream::~Input2Stream() {
-	s->close();
-	delete s;
-} // Test::Input2Stream::~Input2Stream
-
-Test::Input2Stream::operator ifstream& () {
-	return *s;
-} // Test::Input2Stream::operator ::ifstream&
-
 } // namespace GLEAN
diff --git a/tests/glean/test.h b/tests/glean/test.h
index 55da31769..d0f500b76 100644
--- a/tests/glean/test.h
+++ b/tests/glean/test.h
@@ -98,9 +98,6 @@ class Test {
 
 	virtual void run(Environment& env) = 0;	// Run test, save results.
 
-	virtual void compare(Environment& env) = 0;
-				// Compare two previous runs.
-
 	// Exceptions:
 	struct Error { };	// Base class for all exceptions.
 	struct CantOpenResultsFile: public Error {
@@ -128,13 +125,6 @@ class Test {
 		~Input1Stream();
 		operator ifstream& ();
 	};
-	class Input2Stream {	// Open db #2 input stream for reading results.
-	    public:
-		ifstream* s;
-	    	Input2Stream(Test& t);
-		~Input2Stream();
-		operator ifstream& ();
-	};
 
 
 	static Test* testList;	// List of all test objects.  Built by
diff --git a/tests/glean/tgetstr.cpp b/tests/glean/tgetstr.cpp
index 48d66342c..a32d03082 100644
--- a/tests/glean/tgetstr.cpp
+++ b/tests/glean/tgetstr.cpp
@@ -63,99 +63,6 @@ GetStringTest::logOne(GetStringResult& r) {
 } // GetStringTest::logOne
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-GetStringTest::compareOne(GetStringResult& oldR, GetStringResult& newR) {
-	if (oldR.vendor == newR.vendor && oldR.renderer == newR.renderer
-	 && oldR.version == newR.version && oldR.extensions == newR.extensions){
-		if (env->options.verbosity)
-			env->log << name << ":  SAME " <<
-				newR.config->conciseDescription() << '\n';
-	} else {
-		env->log << name <<  ":  DIFF "
-			<< newR.config->conciseDescription() << '\n';
-		if (oldR.vendor != newR.vendor) {
-			env->log << '\t' << env->options.db1Name
-				<< " vendor: " << oldR.vendor;
-			env->log << '\t' << env->options.db2Name
-				<< " vendor: " << newR.vendor;
-		}
-		if (oldR.renderer != newR.renderer) {
-			env->log << '\t' << env->options.db1Name
-				<< " renderer: " << oldR.renderer;
-			env->log << '\t' << env->options.db2Name
-				<< " renderer: " << newR.renderer;
-		}
-		if (oldR.version != newR.version) {
-			env->log << '\t' << env->options.db1Name
-				<< " version: " << oldR.version;
-			env->log << '\t' << env->options.db2Name
-				<< " version: " << newR.version;
-		}
-		if (oldR.extensions != newR.extensions) {
-			vector<string> oldExts;
-			Lex oldLex(oldR.extensions.c_str());
-			for (;;) {
-				oldLex.next();
-				if (oldLex.token == Lex::ID)
-					oldExts.push_back(oldLex.id);
-				else
-					break;
-			}
-			sort(oldExts.begin(), oldExts.end());
-
-			vector<string> newExts;
-			Lex newLex(newR.extensions.c_str());
-			for (;;) {
-				newLex.next();
-				if (newLex.token == Lex::ID)
-					newExts.push_back(newLex.id);
-				else
-					break;
-			}
-			sort(newExts.begin(), newExts.end());
-
-			vector<string> d(max(oldExts.size(), newExts.size()));
-			vector<string>::iterator dEnd;
-
-			dEnd = set_difference(oldExts.begin(), oldExts.end(),
-				newExts.begin(), newExts.end(), d.begin());
-			if (dEnd != d.begin()) {
-				env->log << "\tExtensions in " <<
-					env->options.db1Name << " but not in "
-					<< env->options.db2Name << ":\n";
-				for (vector<string>::iterator p = d.begin();
-				    p != dEnd; ++p)
-					env->log << "\t\t" << *p << '\n';
-			}
-
-			dEnd = set_difference(newExts.begin(), newExts.end(),
-				oldExts.begin(), oldExts.end(), d.begin());
-			if (dEnd != d.begin()) {
-				env->log << "\tExtensions in " <<
-					env->options.db2Name << " but not in "
-					<< env->options.db1Name << ":\n";
-				for (vector<string>::iterator p = d.begin();
-				    p != dEnd; ++p)
-					env->log << "\t\t" << *p << '\n';
-			}
-
-			dEnd = set_intersection(newExts.begin(), newExts.end(),
-				oldExts.begin(), oldExts.end(), d.begin());
-			if (dEnd != d.begin()) {
-				env->log << "\tExtensions in both " <<
-					env->options.db2Name << " and in "
-					<< env->options.db1Name << ":\n";
-				for (vector<string>::iterator p = d.begin();
-				    p != dEnd; ++p)
-					env->log << "\t\t" << *p << '\n';
-			}
-		}
-	}
-} // GetStringTest::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 GetStringTest getStringTest("getString", "window",
diff --git a/tests/glean/tlogicop.cpp b/tests/glean/tlogicop.cpp
index 507a73b14..66a2045fb 100644
--- a/tests/glean/tlogicop.cpp
+++ b/tests/glean/tlogicop.cpp
@@ -437,105 +437,6 @@ LogicopFuncTest::logOne(LogicopFuncResult& r) {
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-LogicopFuncTest::compareOne(LogicopFuncResult& oldR, LogicopFuncResult& newR) {
-	BasicStats readbackStats;
-	BasicStats logicopStats;
-
-	vector<LogicopFuncResult::PartialResult>::const_iterator np;
-	vector<LogicopFuncResult::PartialResult>::const_iterator op;
-
-	for (np = newR.results.begin(); np != newR.results.end(); ++np) {
-		// Find the matching case, if any, in the old results:
-		for (op = oldR.results.begin(); op != oldR.results.end(); ++op)
-			if (np->logicop == op->logicop) {
-				readbackStats.sample(np->rbErr - op->rbErr);
-				logicopStats.sample(np->opErr - op->opErr);
-			}
-	}
-
-	if (readbackStats.n() == static_cast<int>(newR.results.size())
-	 && newR.results.size() == oldR.results.size()
-	 && readbackStats.mean() == 0.0 && logicopStats.mean() == 0.0) {
-		if (env->options.verbosity)
-			env->log << name << ": SAME "
-				<< newR.config->conciseDescription() << '\n';
-	} else {
-		env->log << name << ": DIFF "
-			<< newR.config->conciseDescription() << '\n';
-
-		if (readbackStats.mean() < 0.0)
-			env->log << '\t' << env->options.db2Name
-				<< " appears to have more accurate readback.\n";
-		else if (readbackStats.mean() > 0.0)
-			env->log << '\t' << env->options.db1Name
-				<< " appears to have more accurate readback.\n";
-		if (logicopStats.mean() < 0.0)
-			env->log << '\t' << env->options.db2Name
-				<< " appears to have more accurate logicoping.\n";
-		else if (logicopStats.mean() > 0.0)
-			env->log << '\t' << env->options.db1Name
-				<< " appears to have more accurate logicoping.\n";
-		if (readbackStats.n() != static_cast<int>(newR.results.size())){
-			env->log << "\tThe following cases in "
-				<< env->options.db2Name
-				<< " have no matching test in "
-				<< env->options.db1Name
-				<< ":\n";
-			for (np = newR.results.begin();
-			    np != newR.results.end(); ++np) {
-				for (op = oldR.results.begin();
-				    op != oldR.results.end(); ++op)
-					if (np->logicop == op->logicop)
-						break;
-				if (op == oldR.results.end())
-					env->log << "\t\t"
-						<< logicopToName(np->logicop)
-						<< '\n';
-			}
-		}
-		if (readbackStats.n() != static_cast<int>(oldR.results.size())){
-			env->log << "\tThe following cases in "
-				<< env->options.db1Name
-				<< " have no matching test in "
-				<< env->options.db2Name
-				<< ":\n";
-			for (op = oldR.results.begin();
-			    op != oldR.results.end(); ++op) {
-				for (np = newR.results.begin();
-				    np != newR.results.end(); ++np)
-					if (op->logicop == np->logicop)
-						break;
-				if (np == newR.results.end())
-					env->log << "\t\t"
-						<< logicopToName(op->logicop)
-						<< '\n';
-			}
-		}
-		if (env->options.verbosity) {
-			env->log << "\tThe following cases appear in both "
-				<< env->options.db1Name
-				<< " and "
-				<< env->options.db2Name
-				<< ":\n";
-			for (np = newR.results.begin();
-			    np != newR.results.end(); ++np){
-				for (op = oldR.results.begin();
-				    op != oldR.results.end(); ++op)
-					if (np->logicop == op->logicop)
-						break;
-				if (op != oldR.results.end())
-					env->log << "\t\t"
-						<< logicopToName(np->logicop)
-						<< '\n';
-			}
-		}
-	}
-} // LogicopFuncTest::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // Result I/O functions:
 ///////////////////////////////////////////////////////////////////////////////
 void
diff --git a/tests/glean/tmultitest.cpp b/tests/glean/tmultitest.cpp
index a95bd173a..6e5f846de 100644
--- a/tests/glean/tmultitest.cpp
+++ b/tests/glean/tmultitest.cpp
@@ -100,25 +100,6 @@ MultiTest::logOne(MultiTestResult &r)
 }
 
 
-void
-MultiTest::compareOne(MultiTestResult &oldR,
-			    MultiTestResult &newR)
-{
-	if (oldR.numPassed != newR.numPassed ||
-		oldR.numFailed != newR.numFailed) {
-		env->log << "Different results: passed: "
-				 << oldR.numPassed
-				 << " vs. "
-				 << newR.numPassed
-				 << "  failed: "
-				 << oldR.numFailed
-				 << " vs. "
-				 << newR.numFailed
-				 << "\n";
-	}
-}
-
-
 #if 0
 MultiTest multiTest("multi", "window",
 					"",
diff --git a/tests/glean/torthpos.cpp b/tests/glean/torthpos.cpp
index a50cfeabf..8939420c1 100644
--- a/tests/glean/torthpos.cpp
+++ b/tests/glean/torthpos.cpp
@@ -95,49 +95,6 @@ failHeader(bool& pass, const string& name,
 	}
 } // failHeader
 
-void
-doComparison(const GLEAN::OPResult& oldR,
-    const GLEAN::OPResult& newR,
-    GLEAN::DrawingSurfaceConfig* config,
-    bool& same,
-    const string& name,
-    GLEAN::Environment* env,
-    const char* title) {
-	if (newR.hasGaps != oldR.hasGaps) {
-		diffHeader(same, name, config, env);
-		env->log << '\t' << env->options.db1Name
-			<< ' ' << title << ' '
-			<< (oldR.hasGaps? " has": " does not have")
-			<< " gaps\n";
-		env->log << '\t' << env->options.db2Name
-			<< ' ' << title << ' '
-			<< (newR.hasGaps? " has": " does not have")
-			<< " gaps\n";
-	}
-	if (newR.hasOverlaps != oldR.hasOverlaps) {
-		diffHeader(same, name, config, env);
-		env->log << '\t' << env->options.db1Name
-			<< ' ' << title << ' '
-			<< (oldR.hasOverlaps? " has": " does not have")
-			<< " overlaps\n";
-		env->log << '\t' << env->options.db2Name
-			<< ' ' << title << ' '
-			<< (newR.hasOverlaps? " has": " does not have")
-			<< " overlaps\n";
-	}
-	if (newR.hasBadEdges != oldR.hasBadEdges) {
-		diffHeader(same, name, config, env);
-		env->log << '\t' << env->options.db1Name
-			<< ' ' << title << ' '
-			<< (oldR.hasBadEdges? " has": " does not have")
-			<< " incorrect edges\n";
-		env->log << '\t' << env->options.db2Name
-			<< ' ' << title << ' '
-			<< (newR.hasBadEdges? " has": " does not have")
-			<< " incorrect edges\n";
-	}
-} // doComparison
-
 GLubyte
 logicalSum(GLubyte* start, int stride, int count) {
 	GLubyte* p = start;
@@ -405,30 +362,6 @@ OrthoPosPoints::logStats(OPResult& r) {
 } // OrthoPosPoints::logStats
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-OrthoPosPoints::compareOne(OPResult& oldR, OPResult& newR) {
-	bool same = true;
-
-	doComparison(oldR, newR, newR.config, same, name,
-		     env, "immediate-mode points");
-
-	if (same && env->options.verbosity) {
-		env->log << name << ":  SAME "
-			 << newR.config->conciseDescription()
-			 << "\n";
-	}
-
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-} // OrthoPosPoints::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 OrthoPosPoints orthoPosPointsTest("orthoPosPoints",
@@ -547,30 +480,6 @@ OrthoPosVLines::logStats(OPResult& r) {
 } // OrthoPosVLines::logStats
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-OrthoPosVLines::compareOne(OPResult& oldR, OPResult& newR) {
-	bool same = true;
-
-	doComparison(oldR, newR, newR.config, same, name,
-		env, "immediate-mode vertical lines");
-
-	if (same && env->options.verbosity) {
-		env->log << name << ":  SAME "
-			<< newR.config->conciseDescription()
-			<< "\n";
-	}
-
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-} // OrthoPosVLines::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 OrthoPosVLines orthoPosVLinesTest("orthoPosVLines",
@@ -692,30 +601,6 @@ OrthoPosHLines::logStats(OPResult& r) {
 } // OrthoPosHLines::logStats
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-OrthoPosHLines::compareOne(OPResult& oldR, OPResult& newR) {
-	bool same = true;
-
-	doComparison(oldR, newR, newR.config, same, name,
-		env, "immediate-mode horizontal lines");
-
-	if (same && env->options.verbosity) {
-		env->log << name << ":  SAME "
-			<< newR.config->conciseDescription()
-			<< "\n";
-	}
-
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-} // OrthoPosHLines::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 OrthoPosHLines orthoPosHLinesTest("orthoPosHLines",
@@ -839,30 +724,6 @@ OrthoPosTinyQuads::logStats(OPResult& r) {
 } // OrthoPosTinyQuads::logStats
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-OrthoPosTinyQuads::compareOne(OPResult& oldR, OPResult& newR) {
-	bool same = true;
-
-	doComparison(oldR, newR, newR.config, same, name,
-		env, "immediate-mode 1x1 quads");
-
-	if (same && env->options.verbosity) {
-		env->log << name << ":  SAME "
-			<< newR.config->conciseDescription()
-			<< "\n";
-	}
-
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-} // OrthoPosTinyQuads::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 OrthoPosTinyQuads orthoPosTinyQuadsTest("orthoPosTinyQuads",
@@ -966,30 +827,6 @@ OrthoPosRandRects::logStats(OPResult& r) {
 } // OrthoPosRandRects::logStats
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-OrthoPosRandRects::compareOne(OPResult& oldR, OPResult& newR) {
-	bool same = true;
-
-	doComparison(oldR, newR, newR.config, same, name,
-		env, "immediate-mode axis-aligned rectangles");
-
-	if (same && env->options.verbosity) {
-		env->log << name << ":  SAME "
-			<< newR.config->conciseDescription()
-			<< "\n";
-	}
-
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-} // OrthoPosRandRects::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 OrthoPosRandRects orthoPosRandRectsTest("orthoPosRandRects",
@@ -1105,30 +942,6 @@ OrthoPosRandTris::logStats(OPResult& r) {
 } // OrthoPosRandTris::logStats
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-OrthoPosRandTris::compareOne(OPResult& oldR, OPResult& newR) {
-	bool same = true;
-
-	doComparison(oldR, newR, newR.config, same, name,
-		env, "immediate-mode triangles");
-
-	if (same && env->options.verbosity) {
-		env->log << name << ":  SAME "
-			<< newR.config->conciseDescription()
-			<< "\n";
-	}
-
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-} // OrthoPosRandTris::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 OrthoPosRandTris orthoPosRandTrisTest("orthoPosRandTris",
diff --git a/tests/glean/tpgos.cpp b/tests/glean/tpgos.cpp
index 71e982c43..029550d48 100644
--- a/tests/glean/tpgos.cpp
+++ b/tests/glean/tpgos.cpp
@@ -578,69 +578,6 @@ PgosTest::runOne(POResult& r, GLEAN::Window& w) {
 	r.pass = r.bigEnoughMRD && r.smallEnoughMRD && r.slopeOffsetsPassed;
 } // PgosTest::runOne
 
-///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-PgosTest::compareOne(POResult& oldR, POResult& newR) {
-	comparePassFail(oldR, newR);
-	if (oldR.bigEnoughMRD != newR.bigEnoughMRD) {
-		env->log << "\tMin size MRD criterion: "
-			<< env->options.db1Name
-			<< (oldR.bigEnoughMRD? " PASS, ": " FAIL, ")
-			<< env->options.db2Name
-			<< (newR.bigEnoughMRD? " PASS\n": " FAIL\n");
-	}
-	if (oldR.smallEnoughMRD != newR.smallEnoughMRD) {
-		env->log << "\tMax size MRD criterion: "
-			<< env->options.db1Name
-			<< (oldR.smallEnoughMRD? " PASS, ": " FAIL, ")
-			<< env->options.db2Name
-			<< (newR.smallEnoughMRD? " PASS\n": " FAIL\n");
-	}
-	if (oldR.slopeOffsetsPassed != newR.slopeOffsetsPassed) {
-		env->log << "\tSlope-relative offsets criterion: "
-			<< env->options.db1Name
-			<< (oldR.slopeOffsetsPassed? " PASS, ": " FAIL, ")
-			<< env->options.db2Name
-			<< (newR.slopeOffsetsPassed? " PASS\n": " FAIL\n");
-	}
-	if (!oldR.slopeOffsetsPassed && !newR.slopeOffsetsPassed) {
-		if (oldR.failingAngle != newR.failingAngle) {
-			env->log << '\t'
-				<< env->options.db1Name
-				<< " failed at angle "
-				<< oldR.failingAngle
-				<< ", "
-				<< env->options.db2Name
-				<< " failed at angle "
-				<< newR.failingAngle
-				<< '\n';
-		}
-		if (oldR.failingAxis[0] != newR.failingAxis[0]
-		 || oldR.failingAxis[1] != newR.failingAxis[1]
-		 || oldR.failingAxis[2] != newR.failingAxis[2]) {
-			env->log << '\t'
-				<< env->options.db1Name
-				<< " failed at axis ("
-				<< oldR.failingAxis[0]
-				<< ", "
-				<< oldR.failingAxis[1]
-				<< ", "
-				<< oldR.failingAxis[2]
-				<< "), "
-				<< env->options.db2Name
-				<< " failed at axis ("
-				<< newR.failingAxis[0]
-				<< ", "
-				<< newR.failingAxis[1]
-				<< ", "
-				<< newR.failingAxis[2]
-				<< ")\n";
-		}
-	}
-} // PgosTest::compareOne
-
 void
 PgosTest::logOne(POResult& r) {
 	logPassFail(r);
diff --git a/tests/glean/treadpix.cpp b/tests/glean/treadpix.cpp
index 5044d4c6c..632672558 100644
--- a/tests/glean/treadpix.cpp
+++ b/tests/glean/treadpix.cpp
@@ -277,138 +277,6 @@ ReadPixSanityTest::runOne(ReadPixSanityResult& r, GLEAN::Window& w) {
 	r.pass = r.passRGBA & r.passDepth & r.passStencil & r.passIndex;
 } // ReadPixSanityTest::runOne
 
-///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-ReadPixSanityTest::compareOne(ReadPixSanityResult& oldR, ReadPixSanityResult& newR) {
-	comparePassFail(oldR, newR);
-	summarize("RGBA:    ", oldR.passRGBA, newR.passRGBA);
-	summarize("Depth:   ", oldR.passDepth, newR.passDepth);
-	summarize("Stencil: ", oldR.passStencil, newR.passStencil);
-	summarize("Index:   ", oldR.passIndex, newR.passIndex);
-	if (env->options.verbosity) {
-		if (!oldR.passRGBA && !newR.passRGBA) {
-			if (oldR.xRGBA != newR.xRGBA
-			 || oldR.yRGBA != newR.yRGBA)
-				env->log << "\tRGBA:    "
-					<< env->options.db1Name
-					<< " failed at ("
-					<< oldR.xRGBA
-					<< ", "
-					<< oldR.yRGBA
-					<< "); "
-					<< env->options.db2Name
-					<< " failed at ("
-					<< newR.xRGBA
-					<< ", "
-					<< newR.yRGBA
-					<< ").\n"
-					;
-			if (oldR.errRGBA != newR.errRGBA)
-				env->log << "\tRGBA:    "
-					<< env->options.db1Name
-					<< " had "
-					<< oldR.errRGBA
-					<< " bits in error; "
-					<< env->options.db2Name
-					<< " had "
-					<< newR.errRGBA
-					<< " bits in error.\n"
-					;
-		}
-		if (!oldR.passDepth && !newR.passDepth) {
-			if (oldR.xDepth != newR.xDepth
-			 || oldR.yDepth != newR.yDepth)
-				env->log << "\tDepth:   "
-					<< env->options.db1Name
-					<< " failed at ("
-					<< oldR.xDepth
-					<< ", "
-					<< oldR.yDepth
-					<< "); "
-					<< env->options.db2Name
-					<< " failed at ("
-					<< newR.xDepth
-					<< ", "
-					<< newR.yDepth
-					<< ").\n"
-					;
-			if (oldR.errDepth != newR.errDepth)
-				env->log << "\tDepth:   "
-					<< env->options.db1Name
-					<< " had "
-					<< oldR.errDepth
-					<< " bits in error; "
-					<< env->options.db2Name
-					<< " had "
-					<< newR.errDepth
-					<< " bits in error.\n"
-					;
-		}
-		if (!oldR.passStencil && !newR.passStencil) {
-			if (oldR.xStencil != newR.xStencil
-			 || oldR.yStencil != newR.yStencil)
-				env->log << "\tStencil: "
-					<< env->options.db1Name
-					<< " failed at ("
-					<< oldR.xStencil
-					<< ", "
-					<< oldR.yStencil
-					<< "); "
-					<< env->options.db2Name
-					<< " failed at ("
-					<< newR.xStencil
-					<< ", "
-					<< newR.yStencil
-					<< ").\n"
-					;
-		}
-		if (!oldR.passIndex && !newR.passIndex) {
-			if (oldR.xIndex != newR.xIndex
-			 || oldR.yIndex != newR.yIndex)
-				env->log << "\tIndex: "
-					<< env->options.db1Name
-					<< " failed at ("
-					<< oldR.xIndex
-					<< ", "
-					<< oldR.yIndex
-					<< "); "
-					<< env->options.db2Name
-					<< " failed at ("
-					<< newR.xIndex
-					<< ", "
-					<< newR.yIndex
-					<< ").\n"
-					;
-		}
-	}
-} // ReadPixSanityTest::compareOne
-
-void
-ReadPixSanityTest::summarize(const char* label, bool oldPass, bool newPass) {
-	if (oldPass == newPass) {
-		if (env->options.verbosity)
-			env->log << "\t"
-				<< label
-				<< "both "
-				<< (oldPass? "passed": "failed")
-				<< ".\n";
-	} else {
-		env->log << "\t"
-			<< label
-			<< env->options.db1Name
-			<< " "
-			<< (oldPass? "passed": "failed")
-			<< "; "
-			<< env->options.db2Name
-			<< " "
-			<< (newPass? "passed": "failed")
-			<< ".\n"
-			;
-	}
-} // ReadPixSanityTest::summarize
-
 void
 ReadPixSanityTest::logOne(ReadPixSanityResult& r) {
 	logPassFail(r);
@@ -764,120 +632,6 @@ ExactRGBATest::runOne(ExactRGBAResult& r, GLEAN::Window& w) {
 	r.skipped = false;
 } // ExactRGBATest::runOne
 
-///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-ExactRGBATest::compareOne(ExactRGBAResult& oldR, ExactRGBAResult& newR) {
-	if (oldR.skipped || newR.skipped) {
-		env->log << name
-			 << ((oldR.skipped && newR.skipped)? ":  SAME "
-			 	: ":  DIFF ")
-			 << newR.config->conciseDescription()
-			 << '\n';
-		if (oldR.skipped)
-			 env->log << "\t"
-				  << env->options.db1Name
-				  << " skipped\n";
-		if (newR.skipped)
-			 env->log << "\t"
-				  << env->options.db2Name
-				  << " skipped\n";
-		env->log << "\tNo comparison is possible.\n";
-		return;
-	}
-
-	if (oldR.ub == newR.ub && oldR.us == newR.us && oldR.ui == newR.ui) {
-		if (env->options.verbosity)
-			env->log << name
-				 << ":  SAME "
-				 << newR.config->conciseDescription()
-				 << '\n'
-				 << (oldR.pass
-				     ? "\tBoth PASS\n"
-				     : "\tBoth FAIL\n");
-	} else {
-		env->log << name
-			 << ":  DIFF "
-			 << newR.config->conciseDescription()
-			 << '\n'
-#if 1
-			 << '\t'
-			 << env->options.db1Name
-			 << (oldR.pass? " PASS, ": " FAIL, ")
-			 << env->options.db2Name
-			 << (newR.pass? " PASS\n": " FAIL\n");
-#endif
-			 ;
-	}
-
-	summarize("Unsigned byte:   ", oldR.ub, newR.ub);
-	summarize("Unsigned short:  ", oldR.us, newR.us);
-	summarize("Unsigned int:    ", oldR.ui, newR.ui);
-} // ExactRGBATest::compareOne
-
-void
-ExactRGBATest::summarize(const char* label, const ExactRGBAResult::Flavor& o,
-    const ExactRGBAResult::Flavor& n) {
-	if (o == n) {
-		if (env->options.verbosity)
-			env->log << "\t"
-				<< label
-				<< "both "
-				<< (o.pass? "passed": "failed")
-				<< ".\n";
-	} else {
-		if (o.pass != n.pass)
-			env->log << "\t"
-				<< label
-				<< env->options.db1Name
-				<< " "
-				<< (o.pass? "passed": "failed")
-				<< "; "
-				<< env->options.db2Name
-				<< " "
-				<< (n.pass? "passed": "failed")
-				<< ".\n"
-				;
-		if (o.x != n.x || o.y != n.y)
-			env->log << "\t"
-				<< env->options.db1Name
-				<< " failed at ("
-				<< o.x
-				<< ", "
-				<< o.y
-				<< "); "
-				<< env->options.db2Name
-				<< " failed at ("
-				<< n.x
-				<< ", "
-				<< n.y
-				<< ")\n"
-				;
-		if (o.err != n.err)
-			env->log << "\t"
-				<< env->options.db1Name
-				<< " had max error "
-				<< o.err
-				<< "; "
-				<< env->options.db2Name
-				<< " had max error "
-				<< n.err
-				<< "\n"
-				;
-		if (o.expected[0] != n.expected[0]
-		 || o.expected[1] != n.expected[1]
-		 || o.expected[2] != n.expected[2]
-		 || o.expected[3] != n.expected[3])
-			env->log << "\tExpected values differ.\n";
-		if (o.actual[0] != n.actual[0]
-		 || o.actual[1] != n.actual[1]
-		 || o.actual[2] != n.actual[2]
-		 || o.actual[3] != n.actual[3])
-			env->log << "\tActual values differ.\n";
-	}
-} // ExactRGBATest::summarize
-
 void
 ExactRGBATest::logFlavor(const char* label, const ExactRGBAResult::Flavor& r) {
 	if (!r.pass) {
diff --git a/tests/glean/treadpix.h b/tests/glean/treadpix.h
index 6f65b2a52..53de5ccbc 100644
--- a/tests/glean/treadpix.h
+++ b/tests/glean/treadpix.h
@@ -168,7 +168,6 @@ public:
 	void checkDepth(ReadPixSanityResult& r, Window& w);
 	void checkStencil(ReadPixSanityResult& r, Window& w);
 	void checkIndex(ReadPixSanityResult& r, Window& w);
-	void summarize(const char* label, bool oldPass, bool newPass);
 }; // class ReadPixSanityTest
 extern ReadPixSanityTest readPixSanityTest;
 
@@ -283,8 +282,6 @@ public:
 	GLEAN_CLASS_WH(ExactRGBATest, ExactRGBAResult,
 		EXACT_RGBA_WIN_SIZE, EXACT_RGBA_WIN_SIZE);
 
-	void summarize(const char* label, const ExactRGBAResult::Flavor& o,
-	    const ExactRGBAResult::Flavor& n);
 	void logFlavor(const char* label, const ExactRGBAResult::Flavor& r);
 }; // class ExactRGBATest
 extern ExactRGBATest exactRGBATest;
diff --git a/tests/glean/tscissor.cpp b/tests/glean/tscissor.cpp
index f72bfb4a0..e45e7a249 100644
--- a/tests/glean/tscissor.cpp
+++ b/tests/glean/tscissor.cpp
@@ -166,14 +166,6 @@ ScissorTest::logOne( BasicResult& r ) {
 } // ScissorTest::logOne
 
 ///////////////////////////////////////////////////////////////////////////////
-// compareOne:  Compare results for a single test case
-///////////////////////////////////////////////////////////////////////////////
-void
-ScissorTest::compareOne( BasicResult&, BasicResult& ) {
-	// FIXME: Implement this...
-} // ScissorTest::compareOne
-
-///////////////////////////////////////////////////////////////////////////////
 // The test object itself:
 ///////////////////////////////////////////////////////////////////////////////
 ScissorTest scissorTest( "scissor", "window, rgb",
diff --git a/tests/glean/tshaderapi.cpp b/tests/glean/tshaderapi.cpp
index 8a1edca9d..5111c301f 100644
--- a/tests/glean/tshaderapi.cpp
+++ b/tests/glean/tshaderapi.cpp
@@ -533,14 +533,6 @@ ShaderAPITest::logOne(ShaderAPIResult &r)
 
 
 void
-ShaderAPITest::compareOne(ShaderAPIResult &oldR,
-						  ShaderAPIResult &newR)
-{
-	comparePassFail(oldR, newR);
-}
-
-
-void
 ShaderAPIResult::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/tstencil2.cpp b/tests/glean/tstencil2.cpp
index 9440c6f35..a7ff1d33e 100644
--- a/tests/glean/tstencil2.cpp
+++ b/tests/glean/tstencil2.cpp
@@ -834,14 +834,6 @@ Stencil2Test::logOne(Stencil2Result &r)
 
 
 void
-Stencil2Test::compareOne(Stencil2Result &oldR,
-			     Stencil2Result &stencil2R)
-{
-	comparePassFail(oldR, stencil2R);
-}
-
-
-void
 Stencil2Result::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/ttexcombine4.cpp b/tests/glean/ttexcombine4.cpp
index c35a27104..ac2257f91 100644
--- a/tests/glean/ttexcombine4.cpp
+++ b/tests/glean/ttexcombine4.cpp
@@ -376,14 +376,6 @@ TexCombine4Test::logOne(TexCombine4Result &r)
 
 
 void
-TexCombine4Test::compareOne(TexCombine4Result &oldR,
-			     TexCombine4Result &newR)
-{
-	comparePassFail(oldR, newR);
-}
-
-
-void
 TexCombine4Result::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/ttexswizzle.cpp b/tests/glean/ttexswizzle.cpp
index 3a92b03bf..667dda287 100644
--- a/tests/glean/ttexswizzle.cpp
+++ b/tests/glean/ttexswizzle.cpp
@@ -406,14 +406,6 @@ TexSwizzleTest::logOne(TexSwizzleResult &r)
 
 
 void
-TexSwizzleTest::compareOne(TexSwizzleResult &oldR,
-			     TexSwizzleResult &newR)
-{
-	comparePassFail(oldR, newR);
-}
-
-
-void
 TexSwizzleResult::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/ttexture_srgb.cpp b/tests/glean/ttexture_srgb.cpp
index a79019ca6..62688cb88 100644
--- a/tests/glean/ttexture_srgb.cpp
+++ b/tests/glean/ttexture_srgb.cpp
@@ -318,24 +318,6 @@ TextureSRGBTest::logOne(TextureSRGBResult &r)
 
 
 void
-TextureSRGBTest::compareOne(TextureSRGBResult &oldR,
-			     TextureSRGBResult &newR)
-{
-	comparePassFail(oldR, newR);
-
-	if (newR.pass && oldR.pass == newR.pass) {
-		// XXX
-	}
-	else {
-		env->log << "\tNew: ";
-		env->log << (newR.pass ? "PASS" : "FAIL");
-		env->log << "\tOld: ";
-		env->log << (oldR.pass ? "PASS" : "FAIL");
-	}
-}
-
-
-void
 TextureSRGBResult::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/tvertarraybgra.cpp b/tests/glean/tvertarraybgra.cpp
index 3852b2e4f..67651d354 100644
--- a/tests/glean/tvertarraybgra.cpp
+++ b/tests/glean/tvertarraybgra.cpp
@@ -206,14 +206,6 @@ VertArrayBGRATest::logOne(VertArrayBGRAResult &r)
 
 
 void
-VertArrayBGRATest::compareOne(VertArrayBGRAResult &oldR,
-			     VertArrayBGRAResult &newR)
-{
-	comparePassFail(oldR, newR);
-}
-
-
-void
 VertArrayBGRAResult::putresults(ostream &s) const
 {
 	if (pass) {
diff --git a/tests/glean/tvertattrib.cpp b/tests/glean/tvertattrib.cpp
index 9b87cd995..d8c681d77 100644
--- a/tests/glean/tvertattrib.cpp
+++ b/tests/glean/tvertattrib.cpp
@@ -1600,18 +1600,6 @@ VertAttribTest::logStats(VertAttribResult& r)
 }
 
 
-void
-VertAttribTest::compareOne(VertAttribResult& oldR, VertAttribResult& newR)
-{
-	if (env->options.verbosity) {
-		env->log << env->options.db1Name << ':';
-		logStats(oldR);
-		env->log << env->options.db2Name << ':';
-		logStats(newR);
-	}
-}
-
-
 // Instantiate this test object
 VertAttribTest vertAttribTest("vertattrib", "window, rgb",
 	"Verify that the glVertexAttribNV, glVertexAttribARB, and glVertexAttrib\n"
diff --git a/tests/glean/winsys.cpp b/tests/glean/winsys.cpp
index 7f9049c3d..871dc873b 100644
--- a/tests/glean/winsys.cpp
+++ b/tests/glean/winsys.cpp
@@ -49,16 +49,6 @@ namespace GLEAN {
 ///////////////////////////////////////////////////////////////////////////////
 #if defined(__X11__)
 WindowSystem::WindowSystem(Options& o) {
-	// If running in "compare" mode we never actually use the window
-	// system, so we don't initialize it here.  This allows us to run
-	// on systems without graphics hardware/software.
-	if (o.mode == Options::compare) {
-		dpy = 0;
-		GLXVersMajor = GLXVersMinor = 0;
-		vip = 0;
-		return;
-	}
-
 	// Open the X11 display:
 	dpy = XOpenDisplay(o.dpyName.c_str());
 	if (!dpy)