Changeset 1248

Timestamp:

Mar 20, 2008, 12:07:30 AM (15 years ago)

Author:

Peter

Message:

fixes tests - ticket:223

Location:

trunk/test

Files:

• fileutil_test.cc (modified) (4 diffs)
• score_test.cc (modified) (5 diffs)
• smart_ptr_test.cc (modified) (4 diffs)
• statistics_test.cc (modified) (3 diffs)
• subset_generator_test.cc (modified) (19 diffs)
• svd_test.cc (modified) (4 diffs)
• svm_test.cc (modified) (8 diffs)
• target_test.cc (modified) (6 diffs)
• ttest_test.cc (modified) (3 diffs)
• utility_test.cc (modified) (5 diffs)
• vector_test.cc (modified) (27 diffs)
• view_test.cc (modified) (6 diffs)

trunk/test/fileutil_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/utility/FileUtil.h"
 #include "yat/utility/Exception.h"
@@ -29 +31 @@
 #include <string>
 
-int main(const int argc,const char* argv[])
-
+int main(int argc,char* argv[])
 {  
   using namespace theplu::yat;
-
-  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 << "fileio_test -v : for printing extra information\n";
-  }
-  *error << "testing FileUtil ... " << std::endl;
-
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing FileUtil ... " << std::endl;
 
   // checking permissions for current directory
   try {
-    *error << "FileUtil Test 1" << std::endl;
+    suite.err() << "FileUtil Test 1" << std::endl;
     bool testval=true;
     utility::FileUtil file(".");
     if (testval=file.exists())
-      *error << "\tfile exists: " << file.path() << std::endl;
-    ok&=testval;
+      suite.err() << "\tfile exists: " << file.path() << std::endl;
+    suite.add(testval);
     if (!(testval=file.permissions("rwx")))
-      *error << "\trwx permissions on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\trwx permissions on " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("rx")))
-      *error << "\trx permissions on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\trx permissions on " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("d")))
-      *error << "\td permissions on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\td permissions on " << file.path() << std::endl;
+    suite.add(!testval);
   }
   catch (utility::IO_error e) {
-    ok=false;
-    *error << e.what() << std::endl;
+    suite.add(false);
+    suite.err() << e.what() << std::endl;
   }
 
   // checking permissions on non-existent file with ./ in path
   try {
-    *error << "FileUtil Test 2" << std::endl;
+    suite.err() << "FileUtil Test 2" << std::endl;
     bool testval=true;
     // filename below should be unique
     utility::FileUtil file("./fileio_test.sdf34DSF");
-    *error << "\tpath: " << std::endl;
+    suite.err() << "\tpath: " << std::endl;
     if (!(testval=file.exists()))
-      *error << "\tfile does not exist: " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tfile does not exist: " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("r")))
-      *error << "\tr permission on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tr permission on " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("rwx")))
-      *error << "\trwx permissions on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\trwx permissions on " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("w")))
-      *error << "\tw permission on " << file.path() << std::endl;
-    ok&=!testval; // 'w' on non-existent file ok if directory writeable
+      suite.err() << "\tw permission on " << file.path() << std::endl;
+    suite.add(!testval); // 'w' on non-existent file ok if directory writeable
     if (!(testval=file.permissions("d")))
-      *error << "\td permission on " << file.path() << std::endl;
-    ok&=!testval; 
+      suite.err() << "\td permission on " << file.path() << std::endl;
+    suite.add(!testval); 
   }
   catch (utility::IO_error e) {
-    ok=false;
-    *error << e.what() << std::endl;
+    suite.add(false);
+    suite.err() << e.what() << std::endl;
   }
 
   // checking permissions on non-existent file without ./ in path
   try {
-    *error << "FileUtil Test 3" << std::endl;
+    suite.err() << "FileUtil Test 3" << std::endl;
     bool testval=true;
     // filename below should be unique
     utility::FileUtil file("fileio_test.sdf34DSF");
     if (!(testval=file.exists()))
-      *error << "\tfile does not exist: " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tfile does not exist: " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("r")))
-      *error << "\tr permission on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tr permission on " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("rwx")))
-      *error << "\trwx permissions on " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\trwx permissions on " << file.path() << std::endl;
+    suite.add(!testval);
     if (!(testval=file.permissions("w")))
-      *error << "\tw permission on " << file.path() << std::endl;
-    ok&=!testval; // 'w' on non-existent file ok if directory writeable
+      suite.err() << "\tw permission on " << file.path() << std::endl;
+    suite.add(!testval); // 'w' on non-existent file ok if directory writeable
     if (!(testval=file.permissions("d")))
-      *error << "\td permission on " << file.path() << std::endl;
-    ok&=!testval; 
+      suite.err() << "\td permission on " << file.path() << std::endl;
+    suite.add(!testval); 
   }
   catch (utility::IO_error e) {
-    ok=false;
-    *error << e.what() << std::endl;
+    suite.add(false);
+    suite.err() << e.what() << std::endl;
   }
 
@@ -127 +118 @@
   // directories in path
   try {
-    *error << "FileUtil Test 4" << std::endl;
+    suite.err() << "FileUtil Test 4" << std::endl;
     bool testval=true;
      // intermediate dir must be unique!
     utility::FileUtil file("./fileio_test.sdf34DSF/file");
     if (!(testval=file.exists()))
-      *error << "\tfile does not exist: " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tfile does not exist: " << file.path() << std::endl;
+    suite.add(!testval);
     if ((testval=file.permissions("r")))
-      *error << "\tr permission failed on " << file.path() << std::endl;
-    ok&=testval;
+      suite.err() << "\tr permission failed on " << file.path() << std::endl;
+    suite.add(testval);
     if (testval=file.permissions("rwx"))
-      *error << "\trwx permissions failed on " << file.path() << std::endl;
-    ok&=testval;
+      suite.err() << "\trwx permissions failed on " << file.path() << std::endl;
+    suite.add(testval);
     if (testval=file.permissions("w"))
-      *error << "\tw permission failed on " << file.path() << std::endl;
-    ok&=testval;
+      suite.err() << "\tw permission failed on " << file.path() << std::endl;
+    suite.add(testval);
     if (testval=file.permissions("d"))
-      *error << "\td permission failed on " << file.path() << std::endl;
-    ok&=testval; 
+      suite.err() << "\td permission failed on " << file.path() << std::endl;
+    suite.add(testval); 
   }
   catch (utility::IO_error e) {
-    ok=false;
-    *error << e.what() << std::endl;
+    suite.add(false);
+    suite.err() << e.what() << std::endl;
   }
 
@@ -155 +146 @@
   // has been checked
   try {
-    *error << "FileUtil Test 5" << std::endl;
+    suite.err() << "FileUtil Test 5" << std::endl;
     bool testval=true;
      // intermediate dir must be unique!
     utility::FileUtil file("./fileio_test.sdf34DSF/file");
     if (!(testval=file.exists()))
-      *error << "\tfile does not exist: " << file.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tfile does not exist: " << file.path() << std::endl;
+    suite.add(!testval);
     utility::FileUtil file2("fileutil_test.cc");
     if (!(testval=!file2.exists()))
-      *error << "\tfile does exist: " << file2.path() << std::endl;
-    ok&=!testval;
+      suite.err() << "\tfile does exist: " << file2.path() << std::endl;
+    suite.add(!testval);
   }
   catch (utility::IO_error e) {
-    ok=false;
-    *error << e.what() << std::endl;
+    suite.add(false);
+    suite.err() << e.what() << std::endl;
   }
 
   try {
-    *error << "FileUtil Test 6" << std::endl;
+    suite.err() << "FileUtil Test 6" << std::endl;
     utility::FileUtil file("fileutil_test.cc");
     file.permissions("rxwa"); // should throw
-    ok = false; 
+    suite.add(false); 
   }
   catch (std::invalid_argument& e) {
-    *error << "Expected exception thrown with what: " << e.what() << std::endl;
+    suite.err() << "Expected exception thrown with what: " << e.what() << std::endl;
   }
 
-  
-  
-
-  *error << (ok ? "OK" : "Failed") << std::endl;
-  if (error!=&std::cerr)
-    delete error;
-
-  return (ok ? 0 : -1);
+  return suite.return_value();
 }

trunk/test/score_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/classifier/Target.h"
 #include "yat/statistics/FoldChange.h"
@@ -41 +43 @@
 using namespace theplu::yat;
 
-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 << "score_test -v : for printing extra information\n";
-  }
-  *error << "testing score classes" << std::endl;
-  bool ok = true;
+  test::Suite suite(argc, argv);
 
-  *error << "testing AUC" << std::endl;
+  suite.err() << "testing score classes" << std::endl;
+
+  suite.err() << "testing AUC" << std::endl;
   utility::Vector value(31);
   std::vector<std::string> label(31,"negative");
@@ -64 +59 @@
   statistics::AUC auc(false);
   double area = auc.score(target, value);
-  if (area!=0.0){
-    *error << "test_auc: area is " << area << " should be 0.0" 
+  if (!(suite.equal(1-area,1))){
+    suite.err() << "test_auc: area is " << area << " should be 0.0" 
            << std::endl;
-    ok = false;
+    suite.add(false);
   }
   target.set_binary(0,false);
   target.set_binary(1,true);
   area = auc.score(target, value);
-  if (area!=1.0){
-    *error << "test_auc: area is " << area << " should be 1.0" 
+  if (!suite.equal(area,1.0)){
+    suite.err() << "test_auc: area is " << area << " should be 1.0" 
            << std::endl;
-    ok = false;
+    suite.add(false);
   }
   
@@ -91 +86 @@
   correct_area(2)=0.0;
 
-  const double tol = 0.001;
   for (size_t i=0; i<data.rows(); i++){
     utility::VectorView vec(data,i);
     if (vec.size()!=target2.size()){
-      *error << "vec.size() is " << vec.size() << " and target2.size() is " 
+      suite.err() << "vec.size() is " << vec.size() << " and target2.size() is " 
              << target2.size() << ". Should be equal." << std::endl; 
-      ok=false;
+      suite.add(false);
     }
     area = auc.score(target2,vec);
-    if (area<correct_area(i)-tol || area>correct_area(i)+tol){
-      *error << "test_roc: area is " << area << " should be " 
+    if (!suite.equal(area, correct_area(i)) ){
+      suite.err() << "test_roc: area is " << area << " should be " 
              << correct_area(i) << std::endl;
-      ok=false;
+      suite.add(false);
     }
   }
@@ -111 +105 @@
     utility::VectorView vec = data.row_view(i);
     area = auc.score(target2, vec, weight);
-    if (area<correct_area(i)-tol || area>correct_area(i)+tol){
-      *error << "test_roc: weighted area is " << area << " should be " 
+    if (!suite.equal(area,correct_area(i)) ){
+      suite.err() << "test_roc: weighted area is " << area << " should be " 
              << correct_area(i) << std::endl;
-      ok=false;
+      suite.add(false);
     }
   }
 
-  *error << "testing FoldChange" << std::endl;
+  suite.err() << "testing FoldChange" << std::endl;
   statistics::FoldChange fold_change(true);
 
-  *error << "testing tScore" << std::endl;
+  suite.err() << "testing tScore" << std::endl;
   statistics::tScore t_score(true);
 
-  *error << "testing Pearson" << std::endl;
+  suite.err() << "testing Pearson" << std::endl;
   statistics::Pearson pearson(true);
 
-  *error << "testing WilcoxonFoldChange" << std::endl;
+  suite.err() << "testing WilcoxonFoldChange" << std::endl;
   statistics::WilcoxonFoldChange wfc(true);
 
-  *error << "testing SAMScore" << std::endl;
+  suite.err() << "testing SAMScore" << std::endl;
   statistics::SAMScore sam(1.0,true);
 
-  *error << "testing SNRScore" << std::endl;
+  suite.err() << "testing SNRScore" << std::endl;
   statistics::SNRScore snr(true);
 
 
-  if (ok)
-    return 0;
-  return -1;
+  return suite.return_value();
 }

trunk/test/smart_ptr_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/utility/SmartPtr.h"
 #include "yat/utility/Matrix.h"
@@ -28 +30 @@
 #include <iostream>
 
-int main(const int argc,const char* argv[])
-
+int main(int argc, char* argv[])
 {  
   using namespace theplu::yat;
 
-  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 << "smart_ptr_test -v : for printing extra information\n";
-  }
-  *error << "testing smart_ptr" << std::endl;
+  test::Suite suite(argc, argv);
 
-  bool ok = true;
+  suite.err() << "testing smart_ptr" << std::endl;
 
   utility::SmartPtr<utility::Matrix> m(new utility::Matrix(10,10));
@@ -51 +44 @@
   }
   else
-    ok = false;
+    suite.add(false);
 
   m = m;
@@ -57 +50 @@
 
   if (m->columns()!=10)
-    ok = false;
+    suite.add(false);
 
-  if(ok)
-    *error << "OK" << std::endl;
-  else
-    *error << "Failed" << std::endl;
-  if (error!=&std::cerr)
-    delete error;
-
-
-  if (ok) 
-    return 0;
-  return -1;
-
+  return suite.return_value();
 }

trunk/test/statistics_test.cc

@@ -24 +24 @@
 */
 
+#include "Suite.h"
+
 #include "yat/statistics/utility.h"
 #include "yat/utility/Vector.h"
@@ -32 +34 @@
 #include <cmath>
 
-int main()
+int main(int argc, char* argv[])
 {  
   using namespace theplu::yat;
+  test::Suite suite(argc, argv);
+
   utility::Vector gsl_vec(10);
   std::vector<double> data;
@@ -45 +49 @@
   double m_gsl=statistics::median(gsl_vec.begin(), gsl_vec.end());
   if (m!=4.5 || m!=m_gsl)
-    return -1;
+    suite.add(false);
   statistics::percentile(data.begin(), data.end(), 100);
   data.resize(1);
   statistics::median(data.begin(), data.end());
 
-  double tolerance=1e-10;
   double skewness_gsl=statistics::skewness(gsl_vec);
-  if (std::abs(skewness_gsl)>tolerance)
-    return -1;
+  if (!suite.equal(1-skewness_gsl, 1.0) )
+    suite.add(false);
   double kurtosis_gsl=statistics::kurtosis(gsl_vec);
-  if (std::abs(kurtosis_gsl+1.5616363636363637113)>tolerance) 
-    return -1;  
+  if (!(std::abs(kurtosis_gsl+1.5616363636363637113)<1e-10) ) 
+    suite.add(false); 
   return 0;
 }

trunk/test/subset_generator_test.cc

@@ -22 +22 @@
   02111-1307, USA.
 */
+
+#include "Suite.h"
 
 #include "yat/classifier/BootstrapSampler.h"
@@ -41 +43 @@
 using namespace theplu::yat;
 
-bool class_count_test(const std::vector<size_t>&, std::ostream*);
-bool sample_count_test(const std::vector<size_t>&, std::ostream*);
-bool test_nested(std::ostream* error);
-bool test_cv(std::ostream*);
-bool test_creation(std::ostream* error);
-bool test_bootstrap(std::ostream* error);
-
-
-int main(const int argc,const char* argv[])
+bool class_count_test(const std::vector<size_t>&, test::Suite&);
+bool sample_count_test(const std::vector<size_t>&, test::Suite&);
+bool test_nested(test::Suite&);
+bool test_cv(test::Suite&);
+bool test_creation(test::Suite&);
+bool test_bootstrap(test::Suite&);
+
+
+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 << "subset_generator -v : for printing extra information\n";
-  }
-  *error << "testing subset_generator" << std::endl;
-  bool ok = true;
-
-  ok = ok && test_creation(error);
-  ok = ok && test_nested(error);
-  ok = ok && test_cv(error);
-
-  if (ok)
-    return 0;
-  return -1;
-}
-
-
-bool test_creation(std::ostream* error)
+  test::Suite suite(argc, argv);
+  suite.err() << "testing subset_generator" << std::endl;
+
+  test_creation(suite);
+  test_nested(suite);
+  test_cv(suite);
+
+  return suite.return_value();
+}
+
+
+bool test_creation(test::Suite& suite)
 {
   bool ok=true;
   std::ifstream is("data/nm_target_bin.txt");
-  *error << "loading target " << std::endl;
+  suite.err() << "loading target " << std::endl;
   classifier::Target target(is);
   is.close();
-  *error << "number of targets: " << target.size() << std::endl;
-  *error << "number of classes: " << target.nof_classes() << std::endl;
+  suite.err() << "number of targets: " << target.size() << std::endl;
+  suite.err() << "number of classes: " << target.nof_classes() << std::endl;
   is.open("data/nm_data_centralized.txt");
-  *error << "loading data " << std::endl;
+  suite.err() << "loading data " << std::endl;
   utility::Matrix m(is);
   is.close();
   classifier::MatrixLookup data(m);
-  *error << "number of samples: " << data.columns() << std::endl;
-  *error << "number of features: " << data.rows() << std::endl;
+  suite.err() << "number of samples: " << data.columns() << std::endl;
+  suite.err() << "number of features: " << data.rows() << std::endl;
   assert(data.columns()==target.size());
 
-  *error << "building kernel" << std::endl;
+  suite.err() << "building kernel" << std::endl;
   classifier::PolynomialKernelFunction kf(1);
   classifier::Kernel_SEV kernel_core(data,kf);
   classifier::KernelLookup kernel(kernel_core);
-  *error << "building Sampler" << std::endl;
+  suite.err() << "building Sampler" << std::endl;
   classifier::CrossValidationSampler sampler(target, 30, 3);
 
   statistics::AUC score;
   classifier::FeatureSelectorIR fs(score, 96, 0);
-  *error << "building SubsetGenerator" << std::endl;
+  suite.err() << "building SubsetGenerator" << std::endl;
   classifier::SubsetGenerator<classifier::MatrixLookup> 
     subset_data(sampler, data, fs);
@@ -107 +99 @@
 }
 
-bool test_nested(std::ostream* error)
+bool test_nested(test::Suite& suite)
 {
   bool ok=true;
@@ -114 +106 @@
   //
 
-  *error << "\ntesting two nested crossplitters" << std::endl;
+  suite.err() << "\ntesting two nested crossplitters" << std::endl;
   std::vector<std::string> label(9);
   label[0]=label[1]=label[2]="0";
@@ -156 +148 @@
       if(test_target(i)!=target(test_index[i])) {
         ok=false;
-        *error << "ERROR: incorrect mapping of test indices" << std:: endl;
+        suite.err() << "ERROR: incorrect mapping of test indices" << std:: endl;
       }        
     }
@@ -180 +172 @@
           || test_index.size()+v_index.size()+t_index.size() !=  target.size()){
         ok = false;
-        *error << "ERROR: size of training samples, validation samples " 
+        suite.err() << "ERROR: size of training samples, validation samples " 
                << "and test samples in is invalid." 
                << std::endl;
@@ -187 +179 @@
           v_index.size()!=3){
         ok = false;
-        *error << "ERROR: size of training, validation, and test samples"
+        suite.err() << "ERROR: size of training, validation, and test samples"
                << " is invalid." 
                << " Expected sizes to be 3" << std::endl;
@@ -211 +203 @@
       }
   
-      ok = ok && sample_count_test(tv_sample_count,error);      
-
-    }
-    ok = ok && sample_count_test(v_sample_count,error);
-    ok = ok && sample_count_test(t_sample_count,error);
+      ok = ok && sample_count_test(tv_sample_count,suite);      
+
+    }
+    ok = ok && sample_count_test(v_sample_count,suite);
+    ok = ok && sample_count_test(t_sample_count,suite);
     
-    ok = ok && class_count_test(t_class_count,error);
-    ok = ok && class_count_test(t_class_count2,error);
-    ok = ok && class_count_test(v_class_count,error);
-
-
-  }
-  ok = ok && sample_count_test(test_sample_count,error);
-  ok = ok && class_count_test(test_class_count,error);
+    ok = ok && class_count_test(t_class_count,suite);
+    ok = ok && class_count_test(t_class_count2,suite);
+    ok = ok && class_count_test(v_class_count,suite);
+
+
+  }
+  ok = ok && sample_count_test(test_sample_count,suite);
+  ok = ok && class_count_test(test_class_count,suite);
   
   if(test_value1[0]!=135 || test_value1[1]!=36 || test_value1[2]!=45 ||
      test_value1[3]!=54) {
     ok=false;
-    *error << "ERROR: incorrect sums of test values in row 1" 
+    suite.err() << "ERROR: incorrect sums of test values in row 1" 
            << " found: " << test_value1[0] << ", "  << test_value1[1] 
            << ", "  << test_value1[2] << " and "  << test_value1[3] 
@@ -239 +231 @@
      test_value2[3]!=84) {
     ok=false;
-    *error << "ERROR: incorrect sums of test values in row 2" 
+    suite.err() << "ERROR: incorrect sums of test values in row 2" 
            << " found: " << test_value2[0] << ", "  << test_value2[1] 
            << ", "  << test_value2[2] << " and "  << test_value2[3] 
@@ -247 +239 @@
   if(t_value[0]!=270 || t_value[1]!=72 || t_value[2]!=90 || t_value[3]!=108)  {
     ok=false;
-    *error << "ERROR: incorrect sums of training values in row 1" 
+    suite.err() << "ERROR: incorrect sums of training values in row 1" 
            << " found: " << t_value[0] << ", "  << t_value[1] 
            << ", "  << t_value[2] << " and "  << t_value[3] 
@@ -255 +247 @@
   if(v_value[0]!=270 || v_value[1]!=72 || v_value[2]!=90 || v_value[3]!=108)  {
     ok=false;
-    *error << "ERROR: incorrect sums of validation values in row 1" 
+    suite.err() << "ERROR: incorrect sums of validation values in row 1" 
            << " found: " << v_value[0] << ", "  << v_value[1] 
            << ", "  << v_value[2] << " and "  << v_value[3] 
@@ -264 +256 @@
 
 bool class_count_test(const std::vector<size_t>& class_count, 
-                      std::ostream* error)  
+                      test::Suite& suite)  
 {
   bool ok=true;
@@ -270 +262 @@
     if (class_count[i]==0){
       ok = false;
-      *error << "ERROR: class " << i << " was not in set." 
+      suite.err() << "ERROR: class " << i << " was not in set." 
              << " Expected at least one sample from each class." 
              << std::endl;
@@ -278 +270 @@
 
 bool sample_count_test(const std::vector<size_t>& sample_count, 
-                       std::ostream* error)  
+                       test::Suite& suite)  
 {
   bool ok=true;
@@ -284 +276 @@
     if (sample_count[i]!=1){
       ok = false;
-      *error << "ERROR: sample " << i << " was in a group " << sample_count[i] 
+      suite.err() << "ERROR: sample " << i << " was in a group " << sample_count[i] 
              << " times." << " Expected to be 1 time" << std::endl;
     }
@@ -292 +284 @@
 
 
-bool test_bootstrap(std::ostream* error)
+bool test_bootstrap(test::Suite& suite)
 {
   bool ok=true;
@@ -309 +301 @@
 
 
-bool test_cv(std::ostream* error)
+bool test_cv(test::Suite& suite)
 {
   bool ok=true;
@@ -330 +322 @@
         target.size()){
       ok = false;
-      *error << "ERROR: size of training samples plus " 
+      suite.err() << "ERROR: size of training samples plus " 
              << "size of validation samples is invalid." << std::endl;
     }
     if (cv.validation_index(j).size()!=3 && cv.validation_index(j).size()!=4){
       ok = false;
-      *error << "ERROR: size of validation samples is invalid." 
+      suite.err() << "ERROR: size of validation samples is invalid." 
              << "expected size to be 3 or 4" << std::endl;
     }
@@ -345 +337 @@
       class_count[target(cv.training_index(j)[i])]++;
     }
-    ok = ok && class_count_test(class_count,error);
-  }
-  ok = ok && sample_count_test(sample_count,error);
-  
-  return ok;
-}
+    ok = ok && class_count_test(class_count,suite);
+  }
+  ok = ok && sample_count_test(sample_count,suite);
+  
+  return ok;
+}

trunk/test/svd_test.cc

@@ -25 +25 @@
 */
 
+#include "Suite.h"
+
 #include "yat/random/random.h"
 #include "yat/utility/Matrix.h"
@@ -32 +34 @@
 using namespace theplu::yat;
 
-double this_norm(const utility::Matrix& A)
+void do_test(size_t m, size_t n, utility::SVD::SVDalgorithm algo,
+             test::Suite& suite)
 {
-  double sum=0.0;
-  for (size_t i=0; i<A.rows(); ++i)
-    for (size_t j=0; j<A.columns(); ++j)
-      sum += A(i,j)*A(i,j);
-  return sum;
-}
-
-
-
-bool test(size_t m, size_t n, utility::SVD::SVDalgorithm algo)
-{
-  double MAXTOL=1e-13; // accepted error
-
   // initialise a random test-matrix
   theplu::yat::random::ContinuousUniform rnd;
+
+  // set seed to make test deterministic
+  theplu::yat::random::RNG::instance()->seed(20);
+
   utility::Matrix A(m,n);
   for (size_t i=0; i<m; ++i)
@@ -66 +60 @@
   Areconstruct*=S;
   Areconstruct*=Vtranspose;
-  Areconstruct-=A;  // Expect null matrix
-  double error = this_norm(Areconstruct);
-  bool testerror=false;
-  if (error>MAXTOL) {
-    std::cerr << "test_svd: FAILED, algorithm " << algo 
-              << " recontruction error ("
-              << error << ") > tolerance (" << MAXTOL << "), matrix dimension ("
-              << m << ',' << n << ')' << std::endl;
-    testerror=true;
+  if (!suite.equal_range(A.begin(), A.end(), Areconstruct.begin(), 1000)) {
+    suite.err() << "test_svd: FAILED, algorithm " << algo << std::endl;
+    suite.err() << "reconstruction error" << std::endl;
+    suite.add(false);
   }
 
   Vtranspose*=svd.V();  // Expect unity matrix
-  error=this_norm(Vtranspose)-n;
-  if (error>MAXTOL) {
-    std::cerr << "test_svd: FAILED, algorithm " << algo 
-              << " V orthogonality error ("
-              << error << ") > tolerance (" << MAXTOL << ')' << std::endl;
-    testerror=true;
+  Vtranspose += 1.0;
+  utility::Matrix eye(Vtranspose.rows(), Vtranspose.columns(), 1.0);
+  for (size_t i=0; i<eye.rows() && i<eye.columns(); ++i)
+    eye(i,i)=2.0;
+  if (!suite.equal_range(eye.begin(), eye.end(), Vtranspose.begin(), 100) ) {
+    suite.err() << "test_svd: FAILED, algorithm " << algo 
+                << " V orthogonality error " << std::endl;
+    suite.add(false);
   }
 
@@ -89 +80 @@
   Utranspose.transpose();
   Utranspose*=svd.U();  // Expect unity matrix
-  error=this_norm(Utranspose)-n;
-  if (error>MAXTOL) {
-    std::cerr << "test_svd: FAILED, algorithm " << algo 
-              << " U orthogonality error ("
-              << error << ") > tolerance (" << MAXTOL << ')' << std::endl;
-    testerror=true;
+  Utranspose += 1.0;
+  eye = utility::Matrix(Utranspose.rows(), Utranspose.columns(), 1.0);
+  for (size_t i=0; i<eye.rows() && i<eye.columns(); ++i)
+    eye(i,i)=2.0;
+  if (!suite.equal_range(eye.begin(), eye.end(), Utranspose.begin(), 100) ) {
+    suite.err() << "test_svd: FAILED, algorithm " << algo 
+                << " U orthogonality error " << std::endl;
+    suite.add(false);
   }
-  return testerror;
 }
 
 
 
-int main(const int argc,const char* argv[])
+int main(int argc, char* argv[])
 {
-  bool testfail=false;
+  theplu::yat::test::Suite suite(argc, argv);
 
   // The GSL Jacobi, Golub-Reinsch, and modified Golub-Reinsch
   // implementations supports rows>=columns matrix dimensions only
-  testfail|=test(12,12,utility::SVD::GolubReinsch);
-  testfail|=test(12,4,utility::SVD::GolubReinsch);
-  testfail|=test(12,12,utility::SVD::ModifiedGolubReinsch);
-  testfail|=test(12,4,utility::SVD::ModifiedGolubReinsch);
-  testfail|=test(12,12,utility::SVD::Jacobi);
-  testfail|=test(12,4,utility::SVD::Jacobi);
+  do_test(12,12,utility::SVD::GolubReinsch, suite);
+  do_test(12,4,utility::SVD::GolubReinsch, suite);
+  do_test(12,12,utility::SVD::ModifiedGolubReinsch, suite);
+  do_test(12,4,utility::SVD::ModifiedGolubReinsch, suite);
+  do_test(12,12,utility::SVD::Jacobi, suite);
+  do_test(12,4,utility::SVD::Jacobi, suite);
 
-  return (testfail ? -1 : 0);
+  return suite.return_value();
 }

trunk/test/svm_test.cc

@@ -24 +24 @@
 */
 
+#include "Suite.h"
+
 #include "yat/classifier/SVM.h"
 #include "yat/classifier/Kernel.h"
@@ -43 +45 @@
 using namespace theplu::yat;
 
-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 << "svm_test -v : for printing extra information\n";
-  }
-  *error << "testing svm" << std::endl;
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing svm" << std::endl;
 
   utility::Matrix data2_core(2,3);
@@ -77 +70 @@
   for (size_t i=0; i<3; i++){
     for (size_t j=0; j<3; j++)
-      *error << kernel2(i,j) << " ";
-    *error << std::endl;
+      suite.err() << kernel2(i,j) << " ";
+    suite.err() << std::endl;
   }
   classifier::KernelLookup kv2(kernel2);
-  *error << "testing with linear kernel" << std::endl;
+  suite.err() << "testing with linear kernel" << std::endl;
   assert(kv2.rows()==target2.size());
   classifier::SVM classifier2;
-  *error << "training...";
+  suite.err() << "training...";
   classifier2.train(kv2, target2);
-  *error << " done!" << std::endl;
+  suite.err() << " done!" << std::endl;
 
   double tmp=0;
@@ -96 +89 @@
 
   if (tmp){
-    *error << "ERROR: found " << tmp << " expected zero" << std::endl;
+    suite.err() << "ERROR: found " << tmp << " expected zero" << std::endl;
     return -1;
   }
@@ -103 +96 @@
   if (std::abs(classifier2.alpha()(1)-2)>tol || 
       std::abs(classifier2.alpha()(2)-2)>tol){
-    *error << "wrong alpha" << std::endl;
-    *error << "alpha: " << classifier2.alpha() <<  std::endl;
-    *error << "expected: 4 2 2" <<  std::endl;
+    suite.err() << "wrong alpha" << std::endl;
+    suite.err() << "alpha: " << classifier2.alpha() <<  std::endl;
+    suite.err() << "expected: 4 2 2" <<  std::endl;
 
     return -1;
@@ -139 +132 @@
   theplu::yat::utility::Vector diff_alpha(alpha);
   diff_alpha-=alpha_matlab;
-  if (diff_alpha*diff_alpha> 1e-10 ){
-    *error << "Difference to matlab alphas too large\n";
-    ok=false;
+  if (!(diff_alpha*diff_alpha<1e-10) ){
+    suite.err() << "Difference to matlab alphas too large\n";
+    suite.add(false);
   }
 
@@ -157 +150 @@
   double slack_bound=2e-7;
   if (slack > slack_bound || std::isnan(slack)){
-    *error << "Slack too large. Is the bias correct?\n";
-    *error << "slack: " << slack << std::endl;
-    *error << "expected less than " << slack_bound << std::endl;
-    ok = false;
+    suite.err() << "Slack too large. Is the bias correct?\n";
+    suite.err() << "slack: " << slack << std::endl;
+    suite.err() << "expected less than " << slack_bound << std::endl;
+    suite.add(false);
   }
   
@@ -166 +159 @@
   delete kf2;
 
-  if (error!=&std::cerr)
-    delete error;
-
-  if(ok)
-    return 0;
-  return -1;
-  
+  return suite.return_value();
 }

trunk/test/target_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/classifier/Target.h"
 #include "yat/utility/Index.h"
@@ -32 +34 @@
 using namespace theplu::yat;
 
-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 << "target_test -v : for printing extra information\n";
-  }
-  *error << "testing target" << std::endl;
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing target" << std::endl;
 
   // This test assumes classes are introduced in order of appearence
@@ -60 +54 @@
   for (size_t i=0; i<facit.size(); i++){
     if (target3(i)!=facit[i]){
-      ok=false;
-      *error << "target(" << i << ") is " << target3(0) << " expected " 
+      suite.add(false);
+      suite.err() << "target(" << i << ") is " << target3(0) << " expected " 
              << facit[i] << std::endl;
     }
@@ -70 +64 @@
   classifier::Target sub_target(target3,utility::Index(sub));
   if (target3(sub[0])!=sub_target(0) || target3(sub[1])!=sub_target(1)){
-    ok = false;
-    *error << "error in constructor Target(const Target&, std::vector<size_t>&)"
+    suite.add(false);
+    suite.err() << "error in constructor Target(const Target&, std::vector<size_t>&)"
            << "\nclasses are not preserved" << std::endl;
   }
   if (target3.binary(sub[0])!=sub_target.binary(0) || 
       target3.binary(sub[1])!=sub_target.binary(1)){
-    ok = false;
-    *error << "error in constructor Target(const Target&, std::vector<size_t>&)"
+    suite.add(false);
+    suite.err() << "error in constructor Target(const Target&, std::vector<size_t>&)"
            << "\nbinary classes are not preserved" << std::endl;
   }
@@ -88 +82 @@
   classifier::Target target(label);
   if (target.nof_classes()!=3){
-    ok=false;
-    *error << "Expected number of classes to be 3" << std::endl;
+    suite.add(false);
+    suite.err() << "Expected number of classes to be 3" << std::endl;
   }
   if (target(0)!=0){
-    ok=false;
-    *error << "Error: target(0)!=0" << std::endl;
+    suite.add(false);
+    suite.err() << "Error: target(0)!=0" << std::endl;
   }
   if (target(20)!=2){
-    ok=false;
-    *error << "Error: target(20)!=2" << std::endl;
+    suite.add(false);
+    suite.err() << "Error: target(20)!=2" << std::endl;
   }
   if (!target.binary(0)){
-    ok=false;
-    *error << "Error: target.binary(0) not true" << std::endl;
+    suite.add(false);
+    suite.err() << "Error: target.binary(0) not true" << std::endl;
   }   
   if (target.binary(20)){
-    ok=false;
-    *error << "Error: target.binary(20) not false" << std::endl;
+    suite.add(false);
+    suite.err() << "Error: target.binary(20) not false" << std::endl;
   }   
   target.set_binary(2,true);
   if (!target.binary(20)){
-    ok=false;
-    *error << "Error: target.binary(20) not true" << std::endl;
+    suite.add(false);
+    suite.err() << "Error: target.binary(20) not true" << std::endl;
   }   
   std::ifstream is("data/rank_target.txt");
@@ -116 +110 @@
   is.close();
   if (target2.size()!=6){
-    ok=false;
-    *error << "ERROR: size of target is " << target2.size() << " expected 6." 
-           << std::endl;
+    suite.add(false);
+    suite.err() << "ERROR: size of target is " << target2.size() 
+                << " expected 6."  << std::endl;
   }   
 
-  if (ok)
-    return 0;
-  return -1;
+  suite.return_value();
 }

trunk/test/ttest_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/classifier/Target.h"
 #include "yat/statistics/tTest.h"
@@ -34 +36 @@
 using namespace theplu::yat;
 
-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 << "ttest_test -v : for printing extra information\n";
-  }
-  bool ok = true;
+  test::Suite suite(argc, argv);
 
-  *error << "testing ttest" << std::endl;
+  suite.err() << "testing ttest" << std::endl;
   utility::Vector value(31);
   std::vector<std::string> label(31,"positive");
@@ -60 +54 @@
   double p = test.p_value_one_sided();
   double p2 = test.p_value();
-  if (p2 != 2*p) {
-    ok = false;
-    *error << "Two-sided P-value should equal 2 * one-sided P-value.\n";
+  if (!suite.equal(p2, 2*p) ){
+    suite.add(false);
+    suite.err() << "Two-sided P-value should equal 2 * one-sided P-value.\n";
   }
 
-  if (ok)
-    return 0;
-  return -1;
+  return suite.return_value();
 }

trunk/test/utility_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/utility/utility.h"
 
@@ -28 +30 @@
 #include <string>
 
-int main(const int argc,const char* argv[])
-
+int main(int argc, char* argv[])
 {  
   using namespace theplu::yat;
-
-  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 << "utility_test -v : for printing extra information\n";
-  }
-  *error << "testing utility ... " << std::endl;
-
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing utility ... " << std::endl;
 
   // test float/double
   std::string s("1.2");
   if (!utility::is_double(s)){
-    ok=false;
+    suite.add(false);
   }
   else if (!utility::is_float(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (utility::is_int(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (utility::is_nan(s)) {
-    ok=false;
+    suite.add(false);
   }
 
@@ -63 +54 @@
   s="23";
   if (!utility::is_double(s)){
-    ok=false;
+    suite.add(false);
   }
   else if (!utility::is_float(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (!utility::is_int(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (utility::is_nan(s)) {
-    ok=false;
+    suite.add(false);
   }
 
@@ -78 +69 @@
   s=" nAn  ";
   if (!utility::is_double(s)){
-    ok=false;
+    suite.add(false);
   }
   else if (!utility::is_float(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (!utility::is_int(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (!utility::is_nan(s)) {
-    ok=false;
+    suite.add(false);
   }
   
@@ -93 +84 @@
   s=" 23 23   ";
   if (utility::is_double(s)){
-    ok=false;
+    suite.add(false);
   }
   else if (utility::is_float(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (utility::is_int(s)) {
-    ok=false;
+    suite.add(false);
   }
   else if (utility::is_nan(s)) {
-    ok=false;
+    suite.add(false);
   }
 
   if (utility::convert<double>("1.23")!=1.23)
-    ok = false;
+    suite.add(false);
   utility::convert<double>("-inf");
   utility::convert<double>("inf");
   utility::convert<double>("NaN");
 
-  if(ok)
-    *error << "OK" << std::endl;
-  else
-    *error << "Failed" << std::endl;
-  if (error!=&std::cerr)
-    delete error;
-
-
-  if (ok) 
-    return 0;
-  return -1;
-
+  return suite.return_value();
 }

trunk/test/vector_test.cc

@@ -24 +24 @@
   02111-1307, USA.
 */
+
+#include "Suite.h"
 
 #include "yat/utility/Exception.h"
@@ -46 +48 @@
 }
 
-int main(const int argc,const char* argv[])
+int main(int argc,char* argv[])
 {  
-  std::ostream* message;
-  if (argc>1 && argv[1]==std::string("-v"))
-    message = &std::cerr;
-  else {
-    message = new std::ofstream("/dev/null");
-    if (argc>1)
-      std::cout << "vector_test -v : for printing extra "  << "information\n";
-  }
-  *message << "testing vector" << std::endl;
-  bool ok = true;
+  test::Suite suite(argc, argv);
+  suite.err() << "testing vector" << std::endl;
 
   utility::Vector vec(12);
@@ -64 +58 @@
 
   // checking that shuffle works
-  *message << "shuffle" << std::endl;
+  suite.err() << "shuffle" << std::endl;
   double sum_before = utility::sum(vec);
   shuffle(vec);
   double sum_after = utility::sum(vec);
   if (sum_after!=sum_before){
-    *message << "shuffle failed" << std::endl;
-    ok = false;
+    suite.err() << "shuffle failed" << std::endl;
+    suite.add(false);
   }
 
   // checking that view works
-  *message << "view" << std::endl;
+  suite.err() << "view" << std::endl;
   sum_before=0;
   for (size_t i=0; i<vec.size(); i+=2) 
@@ -80 +74 @@
   utility::VectorView vec_view(vec,0,6,2);
   sum_after=utility::sum(vec_view);
-  ok &= (sum_after==sum_before);
+  suite.add(suite.equal(sum_after, sum_before));
   vec(0)=0;
   vec_view(0)=24;
-  ok &= (vec(0)==vec_view(0));
+  suite.add(suite.equal(vec(0), vec_view(0)));
 
   // Test of const view implementation (make sure no zero pointer is
@@ -90 +84 @@
   // core dump!
   {
-    *message << "const view implementation" << std::endl;
+    suite.err() << "const view implementation" << std::endl;
     const utility::Vector vv(10,3.0);
     utility::VectorConstView vview(vv,0,5,1);
@@ -97 +91 @@
     vv2.mul(vview); // should work even without const since const arg passing
     vv2.div(vview); // should work even without const since const arg passing
-    ok &= (vview*vview == 3.0*3.0*vview.size());
+    suite.add(suite.equal(vview*vview, 3.0*3.0*vview.size()));
   }
 
@@ -103 +97 @@
   // a non-view vector is copied
   {
-    *message << "copy constructor" << std::endl;
+    suite.err() << "copy constructor" << std::endl;
     utility::Vector vec2(vec);
-    ok &= (vec.size()==vec2.size());
-    ok &= (vec2==vec);
-    ok &= (&vec2 != &vec);
-    ok &= !vec2.isview();
+    suite.add(vec.size()==vec2.size());
+    suite.add(suite.equal_range(vec2.begin(), vec2.end(), vec.begin()));
+    suite.add(&vec2 != &vec);
+    suite.add(!vec2.isview());
   }
 
@@ -114 +108 @@
   // a view vector is copied
   {
-    *message << "copy contructor on view" << std::endl;
+    suite.err() << "copy contructor on view" << std::endl;
     utility::Vector vec3(vec_view);
-    ok &= (vec_view.size()==vec3.size());
-    ok &= (vec3 == vec_view);
-    ok &= !vec3.isview();
+    suite.add(vec_view.size()==vec3.size());
+    suite.add(suite.equal_range(vec3.begin(), vec3.end(), vec_view.begin()));
+    suite.add(!vec3.isview());
   }
 
@@ -124 +118 @@
   // differ in size
   {
-    *message << "assignment operator" << std::endl;
+    suite.err() << "assignment operator" << std::endl;
     // GSL will catch the error in this test there for the GSL error
     // handling must be disabled until after the exception is
@@ -138 +132 @@
     }
     if (!exception_happens) {
-      *message << "Vector assignment operator did not throw expected exception"
+      suite.err() << "Vector assignment operator did not throw expected exception"
                << std::endl;
-      ok=false;
+      suite.add(false);
     }
     gsl_set_error_handler(err_handler);
@@ -148 +142 @@
   // a view is changed.
   {
-    *message << "assignment operator on view" << std::endl;
+    suite.err() << "assignment operator on view" << std::endl;
     vec(3)=vec(4)=vec(5)=13;
     utility::VectorView vec_view(vec,3,3,1);
@@ -154 +148 @@
     vec_view=vec2;
     if (vec(3)!=vec_view(0) || vec(4)!=vec_view(1) || vec(5)!=vec_view(2)){
-      *message << " failed\n";
-      ok=false;
+      suite.err() << " failed\n";
+      suite.add(false);
     }
   }
@@ -161 +155 @@
   // checking clone functionality
   {
-    *message << "clone functionality" << std::endl;
+    suite.err() << "clone functionality" << std::endl;
     bool this_ok=true;
-    *message << "\tcloning normal vector" << std::endl;
+    suite.err() << "\tcloning normal vector" << std::endl;
     utility::Vector vec2(3,123.0);
     vec2 = vec;
@@ -174 +168 @@
     if (vec.gsl_vector_p()==vec2.gsl_vector_p())
       this_ok=false;
-    *message << "\tcloning vector view" << std::endl;
+    suite.err() << "\tcloning vector view" << std::endl;
     utility::VectorView* vec_view=new utility::VectorView(vec,3,3,1);
     utility::VectorView vec_view2(*vec_view);
@@ -185 +179 @@
         if ((*vec_view)(i)!=vec_view2(i))
           this_ok=false;
-    *message << "\tcloned vector view independence" << std::endl;
+    suite.err() << "\tcloned vector view independence" << std::endl;
     delete vec_view;
     if (vec(3)!=vec_view2(0) || vec(4)!=vec_view2(1) || vec(5)!=vec_view2(2))
@@ -191 +185 @@
 
     if (!this_ok) {
-      *message << "FAIL: clone test" << std::endl;
-      ok=false;
+      suite.err() << "FAIL: clone test" << std::endl;
+      suite.add(false);
     }
   }
@@ -198 +192 @@
   // checking that reading vectors from properly formatted files works
   try {
-    *message << "stream" << std::endl;
+    suite.err() << "stream" << std::endl;
     std::string data1("data/vector1.data");
     std::string data2("data/vector2.data");
@@ -212 +206 @@
     std::ifstream data_stream4(data4.c_str());
     utility::Vector vec1(data_stream1);
-    ok &= (vec1.size()==9);
+    suite.add(vec1.size()==9);
     vec1=utility::Vector(data_stream2);
-    ok &= (vec1.size()==9);
+    suite.add(vec1.size()==9);
     utility::Vector vec2(data_stream3);
-    ok &= (vec2.size()==12);
+    suite.add(vec2.size()==12);
     vec2=utility::Vector(data_stream4);
-    ok &= (vec2.size()==12);
+    suite.add(vec2.size()==12);
   } catch (utility::IO_error& err) {
-    *message << err.what() << std::endl;
-    ok=false;
+    suite.err() << err.what() << std::endl;
+    suite.add(false);
   }
 
@@ -227 +221 @@
   // vector stream output operator produces.
   {
-    *message << "checking that output stream is valid as an input stream"
+    suite.err() << "checking that output stream is valid as an input stream"
              << std::endl;
     std::stringstream s;
     s << vec;
     utility::Vector vec2(s);
-    ok &= (vec==vec2);
+    suite.add(suite.equal_range(vec.begin(), vec.end(), vec2.begin()));
   }
 
   // Checking that badly formatted files are not accepted, or at least
   // throws an exception for the programmer to catch.
-  *message << "checking that bad stream are rejected" << std::endl;
+  suite.err() << "checking that bad stream are rejected" << std::endl;
   bool this_ok=false;
   // Checking that unexpected characters in a stream gives error. 
@@ -246 +240 @@
     utility::Vector dummy(data_stream5); // this will give an exception
   } catch (utility::IO_error& err) {
-    *message << err.what() << std::endl;
+    suite.err() << err.what() << std::endl;
     this_ok=true; // good, exception thrown, test passed
   }
@@ -255 +249 @@
     utility::Vector dummy(data_stream); // this will give an exception
   } catch (utility::IO_error& err) {
-    *message << err.what() << std::endl;
+    suite.err() << err.what() << std::endl;
     this_ok=true; // good, exceoption thrown, test passed
   }
-  ok &= this_ok;
+  suite.add(this_ok);
 
   this_ok=false;
@@ -267 +261 @@
     vec=utility::Vector(data_stream); // this will give an exception
   } catch (utility::IO_error& err) {
-    *message << err.what() << std::endl;
+    suite.err() << err.what() << std::endl;
     this_ok=true; // good, exceoption thrown, test passed
   }
-  ok &= this_ok;
+  suite.add(this_ok);
 
 
@@ -283 +277 @@
     utility::sort_index(dummy,vec3);
     if(dummy.size()!=vec3.size()) {
-      ok=false;
-      *message << "Vector of sorted indices has incorrect size" << std::endl;
+      suite.add(false);
+      suite.err() << "Vector of sorted indices has incorrect size" << std::endl;
     }
     if(dummy[0]!=11 || dummy[dummy.size()-1]!=8) {
-      ok=false;
-      *message << "Vector of sorted indices incorrect" << std::endl;
+      suite.add(false);
+      suite.err() << "Vector of sorted indices incorrect" << std::endl;
     }
     size_t k=3;
@@ -294 +288 @@
     utility::sort_smallest_index(dummy,k,vec3);
     if(dummy.size()!=k) {
-      ok=false;
-      *message << "Vector of sorted smallest indices has incorrect size" << std::endl;
+      suite.add(false);
+      suite.err() << "Vector of sorted smallest indices has incorrect size" << std::endl;
     }
     if(dummy[0]!=11 || dummy[dummy.size()-1]!=9) {
-      ok=false;
-      *message << "Vector of sorted smallest indices incorrect" << std::endl;
+      suite.add(false);
+      suite.err() << "Vector of sorted smallest indices incorrect" << std::endl;
     }
 
@@ -305 +299 @@
     utility::sort_largest_index(dummy,k,vec3);
     if(dummy.size()!=k) {
-      ok=false;
-      *message << "Vector of sorted largest indices has incorrect size" << std::endl;
+      suite.add(false);
+      suite.err() << "Vector of sorted largest indices has incorrect size" << std::endl;
     }
     if(dummy[0]!=8 || dummy[dummy.size()-1]!=5) {
-      ok=false;
-      *message << "Vector of sorted largest indices incorrect" << std::endl;
+      suite.add(false);
+      suite.err() << "Vector of sorted largest indices incorrect" << std::endl;
     }
   }
@@ -319 +313 @@
     vec = vv;
     if (vec.size()!=10){
-      *message << "indirect self-assignment failed - size should be 10\n";
-      ok = false;
+      suite.err() << "indirect self-assignment failed - size should be 10\n";
+      suite.add(false);
     }
     if (vec(0)!=2.3){
-      *message << "indirect self-assignment failed - vec(0) should be 2.3\n";
-      ok = false;
+      suite.err() << "indirect self-assignment failed - vec(0) should be 2.3\n";
+      suite.add(false);
     }
     utility::VectorView vv2(vec, 0, 5);
     vec = vv2;
     if (vec.size()!=5){
-      *message << "indirect self-assignment failed - size should be 5\n";
-      ok = false;
+      suite.err() << "indirect self-assignment failed - size should be 5\n";
+      suite.add(false);
     }
     if (vec(0)!=2.3){
-      *message << "indirect self-assignment failed - vec(0) should be 2.3\n";
-      ok = false;
+      suite.err() << "indirect self-assignment failed - vec(0) should be 2.3\n";
+      suite.add(false);
     }
   }
@@ -345 +339 @@
   }
 
-  if (!ok)
-    *message << "vector test failed" << std::endl;
-
-  if (message!=&std::cerr)
-    delete message;
-
-  return (ok ? 0 : -1);
+  return suite.return_value();
 }

trunk/test/view_test.cc

@@ -22 +22 @@
 */
 
+#include "Suite.h"
+
 #include "yat/utility/Matrix.h"
 #include "yat/utility/VectorBase.h"
@@ -32 +34 @@
 #include <string>
 
-int main(const int argc,const char* argv[])
+int main(int argc, char* argv[])
 {  
   using namespace theplu::yat::utility;
-  std::ostream* message;
-  if (argc>1 && argv[1]==std::string("-v"))
-    message = &std::cerr;
-  else {
-    message = new std::ofstream("/dev/null");
-    if (argc>1)
-      std::cout << "vector_test -v : for printing extra "  << "information\n";
-  }
-  *message << "testing vector" << std::endl;
-  bool ok = true;
+  theplu::yat::test::Suite suite(argc, argv);
+  suite.err() << "testing vector" << std::endl;
 
   Matrix data1;
@@ -59 +53 @@
   VectorView bajs(data2, 0, false);
   if (a(0)!=data1(0,0)){
-    *message << "Matrix::column_const_view failed\n";
-    ok =false;
+    suite.err() << "Matrix::column_const_view failed\n";
+    suite.add(false);
   }
   if (b(0)!=data2(0,0)){
-    *message << "Matrix::column_view failed\n";
-    ok =false;
+    suite.err() << "Matrix::column_view failed\n";
+    suite.add(false);
   }
 
   data1.column_const_view(0);
   if (b.size()!=3){
-    ok =false;
-    *message << "ERROR: expected size to be 3 - found " << b.size() << std::endl;
+    suite.add(false);
+    suite.err() << "ERROR: expected size to be 3 - found " << b.size() << std::endl;
   }
   if ( !(b(0)==1 && b(1)==(1) && b(2)==1) )
-    ok = false;
+    suite.add(false);
 
   if (a.begin()!=data1.begin_column(0)){
-    ok=false;
-    *message << "VectorConstView::begin should equal " 
+    suite.add(false);
+    suite.err() << "VectorConstView::begin should equal " 
              << "Matrix::begin_column(size_t)\n";
   }
   if (a.end()!=data1.end_column(0)) {
-    ok=false;
-    *message << "VectorConstView::end should equal " 
+    suite.add(false);
+    suite.err() << "VectorConstView::end should equal " 
              << "Matrix::end_column(size_t)\n";
   }
   if (b.begin()!=data2.begin_column(0)){
-    ok=false;
-    *message << "VectorView::begin " 
+    suite.add(false);
+    suite.err() << "VectorView::begin " 
              << b.begin().base() << " should equal\n"
              << "Matrix::begin_column(size_t) "
@@ -93 +87 @@
   }
   if (b.end()!=data2.end_column(0)){
-    ok=false;
-    *message << "VectorView::end should equal " 
+    suite.add(false);
+    suite.err() << "VectorView::end should equal " 
              << "Matrix::end_column(size_t)\n";
   }
@@ -100 +94 @@
   VectorView d=data2.row_view(0);
   if (c.begin()!=data1.begin_row(0)) {
-    ok=false;
-    *message << "VectorConstView::begin should equal " 
+    suite.add(false);
+    suite.err() << "VectorConstView::begin should equal " 
              << "Matrix::begin_row(size_t)\n";
   }
   if (c.end()!=data1.end_row(0)){
-    ok=false;
-    *message << "VectorConstView::end should equal " 
+    suite.add(false);
+    suite.err() << "VectorConstView::end should equal " 
              << "Matrix::end_row(size_t)\n";
   }
   if (d.begin()!=data2.begin_row(0)){
-    ok=false;
-    *message << "VectorView::begin should equal " 
+    suite.add(false);
+    suite.err() << "VectorView::begin should equal " 
              << "Matrix::begin_row(size_t)\n";
   }
   if (d.end()!=data2.end_row(0)){
-    ok=false;
-    *message << "VectorView::end should equal " 
+    suite.add(false);
+    suite.err() << "VectorView::end should equal " 
              << "Matrix::end_row(size_t)\n";
   }
@@ -129 +123 @@
     delete vv;
     if (vcv.size()!=10)
-      ok = false;
+      suite.add(false);
     if (vcv(0)!=1.2)
-      ok = false;
+      suite.add(false);
   }
   
 
-  if (ok)
-    *message << "test is ok" << std::endl;
-  else
-    *message << "view test failed" << std::endl;
-
-  if (message!=&std::cerr)
-    delete message;
-
-  return (ok ? 0 : -1);
+  return suite.return_value();
 }