Changeset 789 for trunk/test

Timestamp:

Mar 10, 2007, 9:07:13 PM (16 years ago)

Author:

Jari Häkkinen

Message:

Addresses #193. vector now works as outlined here. Added some
functionality. Added a clone function that facilitates resizing of
vectors. clone is needed since assignement operator functionality is
changed.

Location:

trunk/test

Files:

• matrix_test.cc (modified) (1 diff)
• regression_test.cc (modified) (1 diff)
• vector_test.cc (modified) (8 diffs)

trunk/test/matrix_test.cc

@@ -186 +186 @@
     *error << "error sub-vector test 5" << std::endl;
   }
-  // Checking that vector::operator= indeed makes a view to become a
-  // "normal" vector.
-  v5subrow=utility::vector(23,22);
-  double m5_sum6=0;
-  for (size_t i=0; i<m5.rows(); ++i)
-    for (size_t j=0; j<m5.columns(); ++j)
-      m5_sum6+=m5(i,j);
-  if (m5_sum6-m5_sum5>1e-13) {
-    ok=false;
-    *error << "error sub-vector test 6" << std::endl;
-  }
 
   // Checking that the memberfunction matrixwrapper::row() returns a

trunk/test/regression_test.cc

@@ -502 +502 @@
   rl.fit(10, 100);
 
-  utility::vector y = rl.y_predicted();
+  utility::vector y(rl.y_predicted());
   for (size_t i=0; i<y.size(); i++) 
     if (y(i)!=10.0){

trunk/test/vector_test.cc

@@ -43 +43 @@
 int main(const int argc,const char* argv[])
 {  
-  bool print = (argc>1 && argv[1]==std::string("-p"));
+  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 << argv[0] << " -v : for printing extra "  << "information\n";
+  }
+  *message << "testing vector" << std::endl;
   bool ok = true;
 
@@ -51 +59 @@
 
   // checking that shuffle works
+  *message << "shuffle" << std::endl;
   double sum_before = utility::sum(vec);
   shuffle(vec);
   double sum_after = utility::sum(vec);
-  if (sum_after != sum_before)
-    ok = false;
+  ok &= (sum_after==sum_before);
 
   // checking that view works
+  *message << "view" << std::endl;
   sum_before=0;
   for (unsigned int i=0; i<vec.size(); i+=2) 
@@ -63 +72 @@
   utility::vector vec_view(vec,0,6,2);
   sum_after=utility::sum(vec_view);
-  if (sum_after != sum_before)
-    ok = false;
+  ok &= (sum_after==sum_before);
   vec[0]=0;
   vec_view[0]=24;
-  if (vec[0]!=vec_view[0])
-    ok=false;
-
-  // checking that copy constructor creates an independent object
-  utility::vector vec2(vec);
-  if (vec.size()!=vec2.size())
-    ok=false;
-  if (&vec2 == &vec)
-    ok=false;
-  if (vec2.isview())
-    ok=false;
+  ok &= (vec[0]==vec_view[0]);
+
+  // Test of const view implementation (make sure no zero pointer is
+  // used). Here we use the bad style of not making the view const!
+  {
+    *message << "const view implementation" << std::endl;
+    const utility::vector vv(10,3.0);
+    utility::vector vview(vv,0,5,1);
+    // const utility::vector vview(vv,0,5,1); // this is the proper line
+    utility::vector vv2(5,2.0);
+    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());
+  }
 
   // checking that copy constructor creates an independent object when
-  // copying a view
-  vec2=vec_view;
-  if (vec_view.size()!=vec2.size())
-    ok=false;
-  if ((&vec2 == &vec_view) || (&vec2 == &vec))
-    ok=false;
-  if (vec2.isview())
-    ok=false;
-  vec2[0]=0;
-  vec_view[0]=24;
-  if (vec2[0]==vec_view[0])
-    ok=false;
+  // a non-view vector is copied
+  {
+    *message << "copy constructor" << std::endl;
+    utility::vector vec2(vec);
+    ok &= (vec.size()==vec2.size());
+    ok &= (vec2==vec);
+    ok &= (&vec2 != &vec);
+    ok &= !vec2.isview();
+  }
+
+  // checking that copy constructor creates an independent object when
+  // a view vector is copied
+  {
+    *message << "copy contructor on view" << std::endl;
+    utility::vector vec3(vec_view);
+    ok &= (vec_view.size()==vec3.size());
+    ok &= (vec3 == vec_view);
+    ok &= (&vec3 != &vec_view);
+    ok &= !vec3.isview();
+  }
+
+  // checking that assignment operator throws an exception if vectors
+  // differ in size
+  {
+    *message << "assignment operator" << std::endl;
+    bool exception_happens=false;
+    try {
+      utility::vector v(vec_view.size()+1,0.0);
+      v=vec_view;
+    } catch (utility::GSL_error& err) {
+      exception_happens=true;
+    }
+    if (!exception_happens) {
+      *message << "Vector assignment operator did not throw expected exception"
+               << std::endl;
+      ok=false;
+    }
+  }
+
+  // checking that assignment operator changes the underlying object when
+  // a view is changed.
+  {
+    *message << "assignment operator on view" << std::endl;
+    vec[3]=vec[4]=vec[5]=13;
+    utility::vector vec_view(vec,3,3,1);
+    utility::vector vec2(3,123.0);
+    vec_view=vec2;
+    if (vec[3]!=vec_view[0] || vec[4]!=vec_view[1] || vec[5]!=vec_view[2])
+      ok=false;
+  }
+
+  // checking clone functionality
+  {
+    *message << "clone functionality" << std::endl;
+    bool this_ok=true;
+    *message << "\tcloning normal vector" << std::endl;
+    utility::vector vec2(3,123.0);
+    vec2.clone(vec);
+    if (vec.size()!=vec2.size())
+      this_ok=false;
+    else
+      for (unsigned int i=0; i<vec.size(); ++i)
+        if (vec(i)!=vec2(i))
+          this_ok=false;
+    if (vec.gsl_vector_p()==vec2.gsl_vector_p())
+      this_ok=false;
+    *message << "\tcloning vector view" << std::endl;
+    utility::vector* vec_view=new utility::vector(vec,3,3,1);
+    utility::vector vec_view2;
+    vec_view2.clone(*vec_view);
+    if (!vec_view2.isview())
+      this_ok=false;
+    if (vec_view->size()!=vec_view2.size())
+      this_ok=false;
+    else
+      for (u_int i=0; i<vec_view2.size(); ++i)
+        if ((*vec_view)(i)!=vec_view2(i))
+          this_ok=false;
+    *message << "\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])
+      this_ok=false;
+
+    if (!this_ok) {
+      *message << "FAIL: clone test" << std::endl;
+      ok=false;
+    }
+  }
 
   // checking that reading vectors from properly formatted files works
   try {
+    *message << "stream" << std::endl;
     std::string data1("data/vector1.data");
     std::string data2("data/vector2.data");
@@ -107 +195 @@
     std::ifstream data_stream3(data3.c_str());
     std::ifstream data_stream4(data4.c_str());
-    vec=utility::vector(data_stream1);
-    if (vec.size()!=9)
-      ok=false;
-    vec=utility::vector(data_stream2);
-    if (vec.size()!=9)
-      ok=false;
-    vec=utility::vector(data_stream3);
-    if (vec.size()!=12)
-      ok=false;
-    vec=utility::vector(data_stream4);
-    if (vec.size()!=12)
-      ok=false;
-  } catch (utility::IO_error& err) {
-    if (print)
-      std::cerr << err.what() << std::endl;
+    utility::vector vec1(data_stream1);
+    ok &= (vec1.size()==9);
+    vec1=utility::vector(data_stream2);
+    ok &= (vec1.size()==9);
+    utility::vector vec2(data_stream3);
+    ok &= (vec2.size()==12);
+    vec2=utility::vector(data_stream4);
+    ok &= (vec2.size()==12);
+  } catch (utility::IO_error& err) {
+    *message << err.what() << std::endl;
     ok=false;
   }
@@ -127 +210 @@
   // Checking that vector stream input operator can read whatever
   // vector stream output operator produces.
-  std::stringstream s;
-  s << vec;
-  vec2=utility::vector(s);
-  if (!(vec==vec2))
-    ok=false;
+  {
+    *message << "checking that output stream is valid as an input stream"
+             << std::endl;
+    std::stringstream s;
+    s << vec;
+    utility::vector vec2(s);
+    ok &= (vec==vec2);
+  }
 
   // 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;
   bool this_ok=false;
   // Checking that unexpected characters in a stream gives error. 
@@ -141 +228 @@
     check_file_access(data5);
     std::ifstream data_stream5(data5.c_str());
-    vec=utility::vector(data_stream5); // this will give an exception
-  } catch (utility::IO_error& err) {
-    if (print)
-      std::cerr << err.what() << std::endl;
+    utility::vector dummy(data_stream5); // this will give an exception
+  } catch (utility::IO_error& err) {
+    *message << err.what() << std::endl;
     this_ok=true; // good, exceoption thrown, test passed
   }
@@ -151 +237 @@
     check_file_access(data);
     std::ifstream data_stream(data.c_str());
-    vec=utility::vector(data_stream); // this will give an exception
-  } catch (utility::IO_error& err) {
-    if (print)
-      std::cerr << err.what() << std::endl;
+    utility::vector dummy(data_stream); // this will give an exception
+  } catch (utility::IO_error& err) {
+    *message << err.what() << std::endl;
     this_ok=true; // good, exceoption thrown, test passed
   }
-  if (!this_ok)
-    ok=false;
+  ok &= this_ok;
+
   this_ok=false;
   try {
@@ -166 +251 @@
     vec=utility::vector(data_stream); // this will give an exception
   } catch (utility::IO_error& err) {
-    if (print)
-      std::cerr << err.what() << std::endl;
+    *message << err.what() << std::endl;
     this_ok=true; // good, exceoption thrown, test passed
   }
-
-  if (!this_ok)
-    ok=false;
-
-  // test of const view implementation (make sure no zero pointer used.
-  const utility::vector vv(10,3.0);
-  const utility::vector vview(vv,0,5,1);
-  utility::vector vv2(5,2.0);
-  vv2.mul(vview); // should work without an abort due to zero pointer in mul
-  vv2.div(vview); // should work without an abort due to zero pointer in mul
-
-  if (vview*vview!= 3.0*3.0*vview.size())
-    ok = false;
-
-  if (print && !ok)
-    std::cout << "vector_test failed" << std::endl;
-
-  
+  ok &= this_ok;
+
+  if (!ok)
+    *message << "vector test failed" << std::endl;
 
   return (ok ? 0 : -1);