[Piglit] [PATCH 13/19] glean: Remove support for comparing result databases.
Kenneth Graunke
kenneth at whitecape.org
Mon Dec 31 18:41:02 PST 2012
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.
---
tests/glean/environ.cpp | 17 ---
tests/glean/environ.h | 12 --
tests/glean/main.cpp | 34 +-----
tests/glean/options.cpp | 1 -
tests/glean/options.h | 8 +-
tests/glean/tbase.h | 93 ++--------------
tests/glean/tbasic.cpp | 8 --
tests/glean/tbinding.cpp | 8 --
tests/glean/tblend.cpp | 92 ---------------
tests/glean/tbufferobject.cpp | 8 --
tests/glean/tclipflat.cpp | 8 --
tests/glean/tdepthstencil.cpp | 29 -----
tests/glean/test.cpp | 16 ---
tests/glean/test.h | 10 --
tests/glean/tgetstr.cpp | 93 ----------------
tests/glean/tlogicop.cpp | 99 -----------------
tests/glean/tmultitest.cpp | 19 ----
tests/glean/torthpos.cpp | 187 -------------------------------
tests/glean/tpgos.cpp | 63 -----------
tests/glean/treadpix.cpp | 246 -----------------------------------------
tests/glean/treadpix.h | 3 -
tests/glean/tscissor.cpp | 8 --
tests/glean/tshaderapi.cpp | 8 --
tests/glean/tstencil2.cpp | 8 --
tests/glean/ttexcombine4.cpp | 8 --
tests/glean/ttexswizzle.cpp | 8 --
tests/glean/ttexture_srgb.cpp | 18 ---
tests/glean/tvertarraybgra.cpp | 8 --
tests/glean/tvertattrib.cpp | 12 --
tests/glean/winsys.cpp | 10 --
30 files changed, 10 insertions(+), 1132 deletions(-)
diff --git a/tests/glean/environ.cpp b/tests/glean/environ.cpp
index a05c165..d06a966 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 5cd0032..30b907d 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 b29f0aa..5b8ce1a 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 051eb32..a221a91 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 60a47ab..c68dc71 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 667a2a9..d4f283f 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 b4fab02..1e5fe2e 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 c73cfae..e2b4e44 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 4d65c88..6611729 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 6ab2ea2..3ed464b 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 cb62ef1..843193e 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 20cb594..7de5d34 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 0d3dbfb..f94680f 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 55da317..d0f500b 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 48d6634..a32d030 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 507a73b..66a2045 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 a95bd17..6e5f846 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 a50cfea..8939420 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 71e982c..029550d 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 5044d4c..6326725 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 6f65b2a..53de5cc 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 f72bfb4..e45e7a2 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 8a1edca..5111c30 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 9440c6f..a7ff1d3 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 c35a271..ac2257f 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 3a92b03..667dda2 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 a79019c..62688cb 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 3852b2e..67651d3 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 9b87cd9..d8c681d 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 7f9049c..871dc87 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)
--
1.8.0.3
More information about the Piglit
mailing list