diff options
Diffstat (limited to 'tests/glean')
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) |