Changeset 1232

Timestamp:

Mar 15, 2008, 4:06:01 AM (13 years ago)

Author:

Peter

Message:

working on ticket:223

Location:

trunk/test

Files:

• Suite.cc (modified) (2 diffs)
• Suite.h (modified) (2 diffs)
• alignment_test.cc (modified) (2 diffs)
• averager_test.cc (modified) (19 diffs)
• commandline_test.cc (modified) (31 diffs)
• consensus_inputranker_test.cc (modified) (6 diffs)
• regression_test.cc (modified) (28 diffs)

trunk/test/Suite.cc

@@ -60 +60 @@
 
 
+  void Suite::add(bool ok)
+  {
+    ok_ = ok_ && ok;
+  }
+
+
   std::ostream& Suite::err(void) const
   {
@@ -79 +85 @@
   {
     return ok_;
-  }
-
-
-  void Suite::ok(bool ok)
-  {
-    ok_ = ok;
   }
 

trunk/test/Suite.h

@@ -44 +44 @@
 
     /**
+       set ok to 'b && ok' 
+    */
+    void add(bool b);
+
+    /**
        \return In verbose mode std::cerr, else a ofstream to "/dev/null".
     */
@@ -52 +57 @@
     */
     bool ok(void) const;
-
-    /**
-      \brief set ok
-    */
-    void ok(bool);
 
     /**

trunk/test/alignment_test.cc

@@ -115 +115 @@
   double score=utility::SmithWaterman(m, 100, 100);
   if (score!=21)
-    suite.ok(false);
+    suite.add(false);
 
   // testing ssearch
@@ -122 +122 @@
                 << utility::ssearch("Hello", "Hll", 0.0, 1.0)
                 << " expected " << 2 << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if (utility::ssearch("Hello", "Peter said you can't say 'allo", 1, 1)!=3)
-    suite.ok(false);
+    suite.add(false);
 
   return suite.return_value();

trunk/test/averager_test.cc

@@ -67 +67 @@
   a.add(5);
   if (a.n()!=3 || a.mean()!=3 || a.sum_xx()!=35){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error: add\n";
   }
@@ -75 +75 @@
   u_int tol = 10;
   if (!equal(a,*a1, tol, suite)){
-    suite.ok(false);
+    suite.add(false);
     suite.err().precision(25);
     suite.err() << a.sum_x() << '\t' << a1->sum_x() << std::endl;
@@ -90 +90 @@
   a1 = new Averager(a);
   if (!equal(a,*a1, tol, suite)){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error: Copy constructor\n";
   }
@@ -98 +98 @@
   if (std::abs(a.standard_error()-sqrt(a.variance()/a.n()))>
       std::numeric_limits<double>().round_error() ){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error: standard_error\n";
   }
@@ -105 +105 @@
   if ( std::abs(a.variance() - a.std()*a.std())>
        std::numeric_limits<double>().round_error() ){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error: std squared should be variance" << std::endl;
     suite.err() << "std2: " << a.std()*a.std() << std::endl;
@@ -113 +113 @@
   
   if ( a.variance() != a.variance(a.mean()) ){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error: variance incorrect\n" << std::endl;
     suite.err() << "variance: " << a.variance() << std::endl;
@@ -143 +143 @@
     suite.err() << "error: AveragerWeighted with unitary weights should " 
            << "be equal to Averager" << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -149 +149 @@
   if (!equal(aw,*aw2,tol,suite)){
     suite.err() << "error: AveragerWeighted copy constructor " << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
     
@@ -156 +156 @@
     suite.err() << "error: AveragerWeighted adding a data point with weight=0 " 
            << "should make no change " << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
       
@@ -165 +165 @@
     suite.err() << "error: AveragerWeighted rescaling weights " 
            << "should make no change " << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   delete aw2;
@@ -185 +185 @@
     ap.add(static_cast<double>(i),i);
   if (std::abs(ap.correlation()-1)>tol){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "correlation: " << ap.correlation() << std::endl;
     suite.err() << "error: correlation between identical vectors should be unity" 
@@ -191 +191 @@
   }
   if (ap.x_averager().variance()!=ap.covariance()){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error: covariance of identical vectors should equal to variance" 
            << std::endl;
@@ -209 +209 @@
     suite.err() << "error: AveragerPairWeighted with unitary weights should " 
            << "be equal to AveragerPair" << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -215 +215 @@
   if (!equal(apw,*apw2,tol,suite)){
     suite.err() << "error: AveragerPairWeighted copy constructor " << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
     
@@ -222 +222 @@
     suite.err() << "error: AveragerWeighted adding a data point with weight=0 " 
            << "should make no change " << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
       
@@ -231 +231 @@
     suite.err() << "error: AveragerWeighted rescaling weights " 
            << "should make no change " << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   delete apw2;
@@ -294 +294 @@
   bool ok = true;
   if  ( std::abs(a.covariance()-b.covariance())>tol){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error covariance: " << a.covariance() << "\t" 
            << b.covariance() << std::endl;
   }
   if ( std::abs(a.correlation()-b.correlation())>tol ) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error correlation" << std::endl;
   } 
@@ -310 +310 @@
   bool ok = true;
   if  ( std::abs(a.covariance()-b.covariance())>tol){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error covariance: " << a.covariance() << "\t" 
            << b.covariance() << std::endl;
   }
   if ( std::abs(a.correlation()-b.correlation())>tol ) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error correlation" << std::endl;
     suite.err() << "unweighted:" << a.correlation() << std::endl;
@@ -333 +333 @@
   bool ok = true;
   if  ( !test::equal(a.covariance(),b.covariance(),tol) ){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error covariance: " << a.covariance() << "\t" 
            << b.covariance() << std::endl;
   }
   if ( !test::equal(a.correlation(), b.correlation(), tol) ) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "error correlation" << std::endl;
     suite.err() << "a:" << a.correlation() << std::endl;

trunk/test/commandline_test.cc

@@ -2 +2 @@
 
 /*
-  Copyright (C) 2007 Peter Johansson
+  Copyright (C) 2007 2008 Peter Johansson
 
   This file is part of the yat library, http://trac.thep.lu.se/yat
@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/utility/CommandLine.h"
 #include "yat/utility/OptionArg.h"
@@ -31 +33 @@
 #include <stdexcept>
 
-using namespace theplu::yat::utility;
-bool cmd_help(std::ostream& error);
-bool test_switch(std::ostream& error);
-bool test_arg(std::ostream& error);
-bool test_file(std::ostream& error);
-bool test_failures(std::ostream& error);
-
-int main(const int argc,const char* argv[])
+using namespace theplu;
+using namespace yat::utility;
+bool cmd_help(yat::test::Suite& error);
+bool test_switch(yat::test::Suite& error);
+bool test_arg(yat::test::Suite& error);
+bool test_file(yat::test::Suite& error);
+bool test_failures(yat::test::Suite& error);
+
+int main(int argc, char* argv[])
 {  
 
-  std::ostream* error;
-  if (argc>1 && argv[1]==std::string("-v"))
-    error = &std::cerr;
-  else {
-    error = new std::ofstream("/dev/null");
-    if (argc>1)
-      std::cout << "commandline_test -v : for printing extra "  
-                << "information\n";
-  }
-  *error << "testing commandline" << std::endl;
-  bool ok = true;
+  yat::test::Suite suite(argc, argv);
+
+  suite.err() << "testing commandline" << std::endl;
 
   try {
-    ok &= cmd_help(*error);
-  
-    ok &= test_switch(*error);
-    ok &= test_arg(*error);
-    ok &= test_file(*error);
-    ok &= test_failures(*error);
+    suite.add(cmd_help(suite));
+    suite.add(test_switch(suite));
+    suite.add(test_arg(suite));
+    suite.add(test_file(suite));
+    suite.add(test_failures(suite));
   }
   catch (std::runtime_error& e) {
-    *error << "exception thrown\n" << e.what() << std::endl;
+    suite.err() << "exception thrown\n" << e.what() << std::endl;
   }
 
@@ -68 +62 @@
   OptionFile file(cmd, "f,file", "description");
 
-  if (!ok)
-    *error << "commandline test failed" << std::endl;
-  else
-    *error << "All tests are OK." << std::endl;
-  
-  if (error!=&std::cerr)
-    delete error;
-
-  return (ok ? 0 : -1);
-}
-
-
-bool cmd_help(std::ostream& error)
+  return suite.return_value();
+}
+
+
+bool cmd_help(yat::test::Suite& suite)
 {
   using namespace theplu::yat::utility;
@@ -90 +76 @@
   OptionSwitch version(cmd, "version", "output version and exit");
 
-  error << cmd;
+  suite.err() << cmd;
   return true;
 }
 
-bool test_switch(std::ostream& error)
+bool test_switch(yat::test::Suite& suite)
 {
   bool ok=true;
@@ -101 +87 @@
   OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);
 
-  error << "Testing OptionSwitch -T...";
+  suite.err() << "Testing OptionSwitch -T...";
   {
     int ac = 2;
@@ -107 +93 @@
     cmd.parse(ac,av);
     if (target.present() && !verbose.present())
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-
-  error << "Testing OptionSwitch --target...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+
+  suite.err() << "Testing OptionSwitch --target...";
   {
     int ac = 2;
@@ -121 +107 @@
     cmd.parse(ac,av);
     if (target.present() && !verbose.present())
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-  error << "Testing OptionSwitch -T -v...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+  suite.err() << "Testing OptionSwitch -T -v...";
   {
     int ac = 3;
@@ -134 +120 @@
     cmd.parse(ac,av);
     if (target.present() && verbose.present())
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-  error << "Testing OptionSwitch -vT...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+  suite.err() << "Testing OptionSwitch -vT...";
   {
     int ac = 2;
@@ -147 +133 @@
     cmd.parse(ac,av);
     if (target.present() && verbose.present())
-      error << "ok\n";
-    else {
-      error << "failed\n";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
       ok =false;
     }
@@ -157 +143 @@
 
 
-bool test_arg(std::ostream& error)
+bool test_arg(yat::test::Suite& suite)
 {
   bool ok=true;
@@ -164 +150 @@
   OptionArg<u_int> n(cmd, "n", "number of lines");
 
-  error << "Testing OptionArg existence -i file...";
+  suite.err() << "Testing OptionArg existence -i file...";
   {
     int ac = 3;
@@ -170 +156 @@
     cmd.parse(ac,av);
     if (input.present())
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-  error << "Testing OptionArg value -i file...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+  suite.err() << "Testing OptionArg value -i file...";
   {
     int ac = 3;
@@ -183 +169 @@
     cmd.parse(ac,av);
     if (input.value()=="file")
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-  error << "Testing OptionArg existence --input file...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+  suite.err() << "Testing OptionArg existence --input file...";
   {
     int ac = 3;
@@ -196 +182 @@
     cmd.parse(ac,av);
     if (input.present())
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-  error << "Testing OptionArg value --input=file...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+  suite.err() << "Testing OptionArg value --input=file...";
   {
     int ac = 2;
@@ -209 +195 @@
     cmd.parse(ac,av);
     if (input.value()=="file")
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-  error << "Testing OptionArg value --input=\"file called something\"...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
   {
     int ac = 2;
@@ -222 +208 @@
     cmd.parse(ac,av);
     if (input.value()=="file called something")
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      error << "value is `" << input.value() << "'\n"
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      suite.err() << "value is `" << input.value() << "'\n"
             << "expected `file called something'\n";
       ok =false;
@@ -231 +217 @@
   }
 
-  error << "Testing OptionArg u_int value -n 3...";
+  suite.err() << "Testing OptionArg u_int value -n 3...";
   {
     int ac = 3;
@@ -237 +223 @@
     cmd.parse(ac,av);
     if (n.value()==3)
-      error << "ok\n";
-    else {
-      error << "failed\n";
-      ok =false;
-    }
-  }
-
-
-  error << "Testing OptionArg 2 value --input file -n 3...";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
+      ok =false;
+    }
+  }
+
+
+  suite.err() << "Testing OptionArg 2 value --input file -n 3...";
   {
     int ac = 5;
@@ -251 +237 @@
     cmd.parse(ac,av);
     if (input.value()=="file")
-      error << "ok\n";
-    else {
-      error << "failed\n";
+      suite.err() << "ok\n";
+    else {
+      suite.err() << "failed\n";
       ok =false;
     }
@@ -262 +248 @@
 }
 
-bool test_failures(std::ostream& error)
+bool test_failures(yat::test::Suite& suite)
 {
   bool ok=true;
@@ -270 +256 @@
   OptionArg<u_int> n(cmd, "n", "number of lines");
 
-  error << "Testing unknown option --peter...";
+  suite.err() << "Testing unknown option --peter...";
   {
     int ac = 2;
@@ -276 +262 @@
     try{
       cmd.parse(ac,av);
-      error << "failed\n";
-      ok =false;
-    }
-    catch (...) {
-      error << "ok\n";
-    }
-  }
-
-  error << "Testing unknown option -jvjhsgad...";
+      suite.err() << "failed\n";
+      ok =false;
+    }
+    catch (...) {
+      suite.err() << "ok\n";
+    }
+  }
+
+  suite.err() << "Testing unknown option -jvjhsgad...";
   {
     int ac = 2;
@@ -290 +276 @@
     try{
       cmd.parse(ac,av);
-      error << "failed\n";
-      ok =false;
-    }
-    catch (...) {
-      error << "ok\n";
-    }
-  }
-
-
-  error << "Testing invalid option -nv 3...";
+      suite.err() << "failed\n";
+      ok =false;
+    }
+    catch (...) {
+      suite.err() << "ok\n";
+    }
+  }
+
+
+  suite.err() << "Testing invalid option -nv 3...";
   {
     int ac = 3;
@@ -305 +291 @@
     try{
       cmd.parse(ac,av);
-      error << "failed\n";
-      ok =false;
-    }
-    catch (...) {
-      error << "ok\n";
-    }
-  }
-
-
-  error << "Testing 23.12 is not u_int...";
+      suite.err() << "failed\n";
+      ok =false;
+    }
+    catch (...) {
+      suite.err() << "ok\n";
+    }
+  }
+
+
+  suite.err() << "Testing 23.12 is not u_int...";
   {
     int ac = 3;
@@ -320 +306 @@
     try{
       cmd.parse(ac,av);
-      error << "failed\n";
+      suite.err() << "failed\n";
       ok =false;
     }
     catch (std::runtime_error& e) {
-      error << "ok\n";
-    }
-  }
-
-  error << "Testing -1 is not u_int...";
+      suite.err() << "ok\n";
+    }
+  }
+
+  suite.err() << "Testing -1 is not u_int...";
   {
     int ac = 3;
@@ -334 +320 @@
     try{
       cmd.parse(ac,av);
-      error << "failed\n";
-      ok =false;
-    }
-    catch (...) {
-      error << "ok\n";
-    }
-  }
-
-
-  error << "Testing OptionArg required ...";
+      suite.err() << "failed\n";
+      ok =false;
+    }
+    catch (...) {
+      suite.err() << "ok\n";
+    }
+  }
+
+
+  suite.err() << "Testing OptionArg required ...";
   {
     OptionArg<std::string> required(cmd, "required", "required", true); 
@@ -350 +336 @@
     try{
       cmd.parse(ac,av);
-      error << "failed\n";
-      ok =false;
-    }
-    catch (...) {
-      error << "ok\n";
+      suite.err() << "failed\n";
+      ok =false;
+    }
+    catch (...) {
+      suite.err() << "ok\n";
     }
   }
@@ -363 +349 @@
 
 
-bool test_file(std::ostream& error)
+bool test_file(yat::test::Suite& suite)
 {
   bool ok=true;
@@ -372 +358 @@
   OptionSwitch help(cmd, "h,help", "display this help and exit");
 
-  error << "Testing OptionFile... ";
+  suite.err() << "Testing OptionFile... ";
   {
     int ac = 2;
@@ -379 +365 @@
                    "commandline_test.cc"};
     cmd.parse(ac,av);
-    error << "ok\n";
+    suite.err() << "ok\n";
   }
   return ok;

trunk/test/consensus_inputranker_test.cc

@@ -4 +4 @@
   Copyright (C) 2004, 2005 Peter Johansson
   Copyright (C) 2006 Jari Häkkinen, Peter Johansson
-  Copyright (C) 2007 Peter Johansson
+  Copyright (C) 2007 2008 Peter Johansson
 
   This file is part of the yat library, http://trac.thep.lu.se/yat
@@ -24 +24 @@
 */
 
+#include "Suite.h"
+
 #include "yat/classifier/ConsensusInputRanker.h"
 #include "yat/statistics/AUC.h"
@@ -38 +40 @@
 using namespace std;
 
-int main(const int argc,const char* argv[])
+int main(int argc, char* argv[])
 {  
-  std::ostream* error;
-  if (argc>1 && argv[1]==std::string("-v"))
-    error = &std::cerr;
-  else {
-    error = new std::ofstream("/dev/null");
-    if (argc>1)
-      std::cout << "consensus_inputranker_test -v : for printing extra " 
-                << "information\n";
-  }
-  *error << "testing consensus_inputranker" << std::endl;
-  bool ok = true;
+  theplu::yat::test::Suite suite(argc, argv);
+  suite.err() << "testing consensus_inputranker" << std::endl;
 
   ifstream is("data/rank_data.txt");
@@ -64 +57 @@
   theplu::yat::statistics::AUC roc;
   theplu::yat::classifier::CrossValidationSampler sampler(target,30,3);
-  *error << "Building Consensus_Inputranker" << std::endl;
+  suite.err() << "Building Consensus_Inputranker" << std::endl;
   theplu::yat::classifier::IRRank retrieve;
   theplu::yat::statistics::Median median;
@@ -70 +63 @@
   cir.add(sampler,data,roc);
 
-  *error << "test ids... ";
+  suite.err() << "test ids... ";
   if (cir.id(0)!=2 || cir.id(1)!=0 || cir.id(2)!=1){
-    *error << "\nincorrect id for weighted" << endl;
-    ok=false;
+    suite.err() << "\nincorrect id for weighted" << endl;
+    suite.add(false);
   }
   else 
-    *error << "ok." << std::endl;
+    suite.err() << "ok." << std::endl;
 
-  *error << "test ranks... ";
+  suite.err() << "test ranks... ";
   if (cir.rank(0)!=1 || cir.rank(1)!=2 || cir.rank(2)!=0){
-    *error << "\nincorrect rank for weighted" << endl;
-    ok=false;
+    suite.err() << "\nincorrect rank for weighted" << endl;
+    suite.add(false);
   }
   else 
-    *error << "ok." << std::endl;
+    suite.err() << "ok." << std::endl;
 
   theplu::yat::utility::Matrix flag(data.rows(),data.columns(),1);
@@ -91 +84 @@
   cir2.add(sampler,data,roc);
 
-  *error << "test ids... ";
+  suite.err() << "test ids... ";
   if (cir2.id(0)!=2 || cir2.id(1)!=0 || cir2.id(2)!=1){
-    *error << "\nincorrect id for weighted" << endl;
-    ok=false;
+    suite.err() << "\nincorrect id for weighted" << endl;
+    suite.add(false);
   }
   else 
-    *error << "ok." << std::endl;
+    suite.err() << "ok." << std::endl;
   
-  *error << "test ranks... ";
+  suite.err() << "test ranks... ";
   if (cir2.rank(0)!=1 || cir2.rank(1)!=2 || cir2.rank(2)!=0){
-    *error << "\nincorrect rank for weighted" << endl;
-    ok=false;
+    suite.err() << "\nincorrect rank for weighted" << endl;
+    suite.add(false);
   }
   else 
-    *error << "ok." << std::endl;
+    suite.err() << "ok." << std::endl;
 
-  if (error!=&std::cerr)
-    delete error;
-
-  if(ok)
-    return 0;
-  return -1;
+  return suite.return_value();
 }

trunk/test/regression_test.cc

@@ -86 +86 @@
     suite.err() << "       fit_parameters(1) = " 
            << polynomial.fit_parameters()(1) << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if (test::equal(polynomial.fit_parameters()(0),
@@ -94 +94 @@
     suite.err() << "error: alpha-beta*m_x = " 
            << linear.alpha()-linear.beta()*1985 << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial.chisq()-linear.chisq())>0.0001){
     suite.err() << "error: chisq not same in linear and polynomial(1)" 
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial.predict(1.0)-linear.predict(1.0))>0.0001){
     suite.err() << "error: predict not same in linear and polynomial(1)" 
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial.standard_error2(1985)-linear.standard_error2(1985))
@@ -112 +112 @@
            << "\n  linear: " << linear.standard_error2(1985)
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -125 +125 @@
     suite.err() << "predicted value: " << y_predicted << " expected 12.8" 
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -139 +139 @@
     suite.err() << "       fit_parameters(1) = " 
            << polynomial_w.fit_parameters()(1) << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial_w.fit_parameters()(0)-linear_w.alpha()+
@@ -147 +147 @@
     suite.err() << "error: alpha-beta*m_x = " 
            << linear.alpha()-linear.beta()*1990 << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial_w.s2()-linear_w.s2())>0.0001){
     suite.err() << "error: chisq not same in linear and polynomial(1)" 
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial_w.predict(1.0)-linear_w.predict(1.0))>0.0001){
     suite.err() << "error: predict not same in linear and polynomial(1)" 
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   if ( std::abs(polynomial_w.standard_error2(1985)-linear_w.standard_error2(1985))
@@ -165 +165 @@
            << "\n  linear: " << linear.standard_error2(1985)
            << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -181 +181 @@
     suite.err() << "returned value: " << y_predicted << std::endl;
     suite.err() << "expected: " << 0.1*12+0.2*11+0.3*14+0.4*13 << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -190 +190 @@
   if (!Local_test(rl,kb)) {
     suite.err() << "regression_Local: Linear cannot reproduce fit." << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
   regression::NaiveWeighted rn;
   if (!Local_test(rn,kb)) {
     suite.err() << "regression_Local: Naive cannot reproduce fit." << std::endl;
-    suite.ok(false);
+    suite.add(false);
   }
 
@@ -216 +216 @@
              fit(2)+1.159674470130)>1e-11) {
       suite.err() << "regression_Polynomial: cannot reproduce fit." << std::endl;
-      suite.ok(false);
+      suite.add(false);
     }
   }
@@ -254 +254 @@
   rw.fit(x,y,w);
   if (std::abs(r.predict(2000) - rw.predict(2000))>1e-15) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: predict not equal\n" 
            << "   weighted: " << rw.predict(2000) << "\n"
@@ -261 +261 @@
   }
   if (std::abs(r.s2()-rw.s2(1.0))>10E-7){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: s2 not equal non-weighted version." << std::endl;
     suite.err() << "weighted s2 = " << rw.s2(1.0) << std::endl;
@@ -267 +267 @@
   }
   if (std::abs(r.standard_error2(2000)-rw.standard_error2(2000))>10e-7){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: standard_error not equal non-weighted version." 
            << std::endl;
   }
   if (std::abs(r.r2()-rw.r2())>10E-7){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: r2 not equal non-weighted version." << std::endl;
     suite.err() << "weighted r2 = " << rw.r2() << std::endl;
@@ -278 +278 @@
   }
   if (std::abs(r.prediction_error2(2000)-rw.prediction_error2(2000,1))>10e-7){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: prediction_error2 not equal non-weighted version.\n" 
            << "       weighted: " << rw.prediction_error2(2000,1) << "\n"
@@ -303 +303 @@
   wr.fit(x,y,w);
   if (std::abs(wr.predict(2000)-predict)>10e-11){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: predict not equal after rescaling.\n";
     suite.err() << "       predict = " << predict 
@@ -310 +310 @@
   }
   if (std::abs(wr.s2(2)-s2)>10e-11){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: s2 not equal after rescaling.\n";
     suite.err() << "       s2 = " << s2 << " and after doubling weights.\n";
@@ -317 +317 @@
   }
   if (std::abs(wr.standard_error2(2000)-standard_error2)>10e-6){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: standard_error2 not equal after rescaling.\n";
     suite.err() << "       standard_error2 = " << standard_error2 
@@ -327 +327 @@
   }
   if (std::abs(wr.r2()-r2)>10e-6){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: r2 not equal after rescaling.\n";
   }
   if (std::abs(wr.prediction_error2(2000,2)-prediction_error2)>10e-6){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: prediction_error2 not equal after rescaling.\n";
     suite.err() << "       prediction_error2 = " << prediction_error2 
@@ -365 +365 @@
   wr.fit(x2,y2,w2);
   if (std::abs(wr.predict(2000) - predict)>1e-10) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: predict not equal.\n";
     suite.err() << "       weighted predict: " << wr.predict(2000) << "\n";
@@ -373 +373 @@
   }
   if (std::abs(wr.prediction_error2(2000) - prediction_error2)>1e-13) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: prediction_error2 not equal.\n";
   }
   if (std::abs(wr.r2() - r2)>1e-15) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: r2 not equal.\n";
     suite.err() << "   r2: " << r2 << "\n";
@@ -383 +383 @@
   }
   if (std::abs(wr.s2() - s2)>1e-15) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: s2 not equal.\n";
   }
   if (std::abs(wr.standard_error2(2000) - standard_error2)>1e-15) {
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: standard_error2 not equal.\n";
   }
@@ -414 +414 @@
   z(2)=2000*2000;
   if (!test::equal(md.predict(z), mdw.predict(z))){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: predict not equal\n" 
            << "   weighted: " << mdw.predict(z) << "\n"
@@ -422 +422 @@
 
   if (std::abs(md.standard_error2(z)-mdw.standard_error2(z))>10e-6){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: standard_error2 not equal\n" 
            << "   weighted: " << mdw.standard_error2(z) << "\n"
@@ -429 +429 @@
   }
   if (std::abs(md.prediction_error2(z)-mdw.prediction_error2(z,1.0))>10e-7){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: prediction_error2 not equal\n" 
            << "   weighted: " << mdw.prediction_error2(z,1.0) << "\n"
@@ -446 +446 @@
   mdw.fit(data,y,w);
   if (std::abs(mdw.predict(z)-predict)>10e-10){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: predict not equal after rescaling.\n";
     suite.err() << "   predict = " << predict << " and after doubling weights.\n";
@@ -452 +452 @@
   }
   if (std::abs(mdw.prediction_error2(z,2)-prediction_error2)>10e-7){ 
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: prediction_error2 not equal after rescaling.\n";
     suite.err() << "       predict_error2 = " << prediction_error2 
@@ -459 +459 @@
   }
   if (std::abs(mdw.s2(2)-s2)>10e-10){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: s2 not equal after rescaling.\n";
     suite.err() << "       s2 = " << s2 << " and after doubling weights.\n";
@@ -465 +465 @@
   }
   if (std::abs(mdw.standard_error2(z)-standard_error2)>10e-7){
-    suite.ok(false);
+    suite.add(false);
     suite.err() << "Error: standard_error2 not equal after rescaling.\n";
     suite.err() << " standard_error2 = " << standard_error2