ported new tests to catch2

tests/include/igl/circulation.cpp

@@ -4,7 +4,7 @@
 #include <igl/unique_edge_map.h>
 #include <igl/matlab_format.h>
 
-TEST(circulation,single_edge)
+TEST_CASE("circulation: single_edge", "[igl]")
 {
   //       7    
   //     /₆|₇\

tests/include/igl/copyleft/cgal/delaunay_triangulation.cpp

@@ -3,7 +3,7 @@
 #include <igl/unique_simplices.h>
 #include <igl/matlab_format.h>
 
-TEST(igl_copyleft_cgal_delaunay_triangulation, two_triangles)
+TEST_CASE("igl_copyleft_cgal_delaunay_triangulation: two_triangles", "[igl/copyleft/cgal]")
 {
   const Eigen::MatrixXd V = 
     (Eigen::MatrixXd(4,2)<<
@@ -15,12 +15,12 @@ TEST(igl_copyleft_cgal_delaunay_triangulation, two_triangles)
   igl::copyleft::cgal::delaunay_triangulation(V,F);
   // Ground truth
   Eigen::MatrixXi Fgt = (Eigen::MatrixXi(2,3)<<0,1,3,0,3,2).finished();
-  ASSERT_EQ(F.rows(),2);
+  REQUIRE (2 == F.rows());
   Eigen::MatrixXi Fu;
   Eigen::VectorXi IA,IC;
   igl::unique_simplices(
     (Eigen::MatrixXi(4,3)<<F,Fgt).finished(),
     Fu,IA,IC);
   // Now new faces w.r.t. ground truth
-  ASSERT_EQ(Fu.rows(),2);
+  REQUIRE (2 == Fu.rows());
 }

tests/include/igl/cotmatrix_entries.cpp

@@ -134,7 +134,7 @@ TEST_CASE("cotmatrix_entries: simple", "[igl]")
     for(int v = 0;v<3;v++)
        REQUIRE (C2(f,v) == Approx (0.5 / tan(M_PI / 3.0)).margin( epsilon));
   }
-}//TEST(cotmatrix_entries, simple)
+}// TEST_CASE("cotmatrix_entries: simple", "[igl]")
 
 TEST_CASE("cotmatrix_entries: intrinsic", "[igl]")
 {

tests/include/igl/cotmatrix_intrinsic.cpp

@@ -5,9 +5,7 @@
 #include <igl/matlab_format.h>
 #include <igl/EPS.h>
 
-class cotmatrix_intrinsic : public ::testing::TestWithParam<std::string> {};
-
-TEST(cotmatrix_intrinsic, periodic)
+TEST_CASE("cotmatrix_intrinsic: periodic", "[igl]")
 {
   const Eigen::MatrixXi F = (Eigen::MatrixXi(18,3)<<
     0,3,1,
@@ -63,28 +61,26 @@ TEST(cotmatrix_intrinsic, periodic)
   test_common::assert_near(L_d,L_gt,igl::EPS<double>());
 }
 
-TEST_P(cotmatrix_intrinsic , manifold_meshes)
+TEST_CASE("cotmatrix_intrinsic: manifold_meshes", "[igl]")
 {
-  Eigen::MatrixXd V;
-  Eigen::MatrixXi F;
-  test_common::load_mesh(GetParam(), V, F);
-  Eigen::MatrixXd l;
-  igl::edge_lengths(V,F,l);
-  Eigen::SparseMatrix<double> L,Li;
-  igl::cotmatrix(V,F,L);
-  igl::cotmatrix_intrinsic(l,F,Li);
-  // Augh, we don't have assert_near for sparse matrices...
-  // Instead test that bilinear form is near equal for 2 random vectors
-  const Eigen::VectorXd u = Eigen::VectorXd::Random(V.rows(),1);
-  const Eigen::VectorXd v = Eigen::VectorXd::Random(V.rows(),1);
-  const double uv = u.norm()*v.norm();
-  ASSERT_NEAR( u.dot(L*v)/uv, u.dot(Li*v)/uv, igl::EPS<double>());
+  auto test_case = [](const std::string &param)
+  {
+    Eigen::MatrixXd V;
+    Eigen::MatrixXi F;
+    test_common::load_mesh(param, V, F);
+    Eigen::MatrixXd l;
+    igl::edge_lengths(V,F,l);
+    Eigen::SparseMatrix<double> L,Li;
+    igl::cotmatrix(V,F,L);
+    igl::cotmatrix_intrinsic(l,F,Li);
+    // Augh, we don't have assert_near for sparse matrices...
+    // Instead test that bilinear form is near equal for 2 random vectors
+    const Eigen::VectorXd u = Eigen::VectorXd::Random(V.rows(),1);
+    const Eigen::VectorXd v = Eigen::VectorXd::Random(V.rows(),1);
+    const double uv = u.norm()*v.norm();
+    REQUIRE (u.dot(Li*v)/uv == Approx (u.dot(L*v)/uv).margin( igl::EPS<double>()));
+  };
+
+  test_common::run_test_cases(test_common::manifold_meshes(), test_case);
 }
 
-INSTANTIATE_TEST_CASE_P
-(
- manifold_meshes,
- cotmatrix_intrinsic,
- ::testing::ValuesIn(test_common::manifold_meshes()),
- test_common::string_test_name
-);

tests/include/igl/cumprod.cpp

@@ -1,7 +1,7 @@
 #include <test_common.h>
 #include <igl/cumprod.h>
 
-TEST(cumprod,col_factorial)
+TEST_CASE("cumprod: col_factorial", "[igl]")
 {
   Eigen::Vector4d X(1,2,3,4);
   Eigen::Vector4d Y;
@@ -10,7 +10,7 @@ TEST(cumprod,col_factorial)
   test_common::assert_eq(Y,Ygt);
 }
 
-TEST(cumprod,row_factorial)
+TEST_CASE("cumprod: row_factorial", "[igl]")
 {
   Eigen::RowVector4d X(1,2,3,4);
   Eigen::RowVector4d Y;

tests/include/igl/cumsum.cpp

@@ -1,7 +1,7 @@
 #include <test_common.h>
 #include <igl/cumsum.h>
 
-TEST(cumsum,col)
+TEST_CASE("cumsum: col", "[igl]")
 {
   Eigen::Vector4d X(1,2,3,4);
   Eigen::Vector4d Y;
@@ -10,7 +10,7 @@ TEST(cumsum,col)
   test_common::assert_eq(Y,Ygt);
 }
 
-TEST(cumsum,row)
+TEST_CASE("cumsum: row", "[igl]")
 {
   Eigen::RowVector4d X(1,2,3,4);
   Eigen::RowVector4d Y;

tests/include/igl/edge_exists_near.cpp

@@ -2,7 +2,7 @@
 #include <igl/edge_exists_near.h>
 #include <igl/unique_edge_map.h>
 
-TEST(edge_exists_near,tet)
+TEST_CASE("edge_exists_near: tet", "[igl]")
 {
   const Eigen::MatrixXi F = (Eigen::MatrixXi(4,3)<<
      0,1,2,
@@ -21,7 +21,7 @@ TEST(edge_exists_near,tet)
       {
         if(i != j)
         {
-          ASSERT_TRUE(igl::edge_exists_near(uE,EMAP,uE2E,i,j,uei));
+          REQUIRE (igl::edge_exists_near(uE,EMAP,uE2E,i,j,uei));
         }
       }
     }

tests/include/igl/grad.cpp

@@ -6,7 +6,7 @@
 #include <igl/doublearea.h>
 #include <igl/EPS.h>
 
-TEST(grad,laplace_grid)
+TEST_CASE("grad: laplace_grid", "[igl]")
 {
   Eigen::MatrixXd V2;
   Eigen::MatrixXi F;

tests/include/igl/grad_intrinsic.cpp

@@ -6,7 +6,7 @@
 #include <igl/doublearea.h>
 #include <igl/EPS.h>
 
-TEST(grad_intrinsic,laplace_grid)
+TEST_CASE("grad_intrinsic: laplace_grid", "[igl]")
 {
   Eigen::MatrixXd V2;
   Eigen::MatrixXi F;

tests/include/igl/grid.cpp

@@ -2,7 +2,7 @@
 #include <igl/grid.h>
 #include <igl/matlab_format.h>
 
-TEST(grid,3d)
+TEST_CASE("grid: 3d", "[igl]")
 {
   Eigen::Vector3i res(3,3,3);
   Eigen::MatrixXd GV;
@@ -39,7 +39,7 @@ TEST(grid,3d)
   test_common::assert_eq(GV,GVgt);
 }
 
-TEST(grid,2d)
+TEST_CASE("grid: 2d", "[igl]")
 {
   Eigen::Vector2i res(3,3);
   Eigen::MatrixXd GV;

tests/include/igl/intrinsic_delaunay_cotmatrix.cpp

@@ -4,9 +4,7 @@
 #include <igl/triangulated_grid.h>
 #include <igl/is_border_vertex.h>
 
-class intrinsic_delaunay_cotmatrix : public ::testing::TestWithParam<std::string> {};
-
-TEST(intrinsic_delaunay_cotmatrix,skewed_grid)
+TEST_CASE("intrinsic_delaunay_cotmatrix: skewed_grid", "[igl]")
 {
   Eigen::MatrixXd V;
   Eigen::MatrixXi F;
@@ -34,40 +32,38 @@ TEST(intrinsic_delaunay_cotmatrix,skewed_grid)
   {
     if(LI(k) != LJ(k) && !is_boundary_edge(LI(k),LJ(k),s))
     {
-      ASSERT_GT(LV(k),-igl::EPS<double>());
+      REQUIRE (-igl::EPS<double>() < LV(k));
     }
   }
 }
 
-TEST_P(intrinsic_delaunay_cotmatrix,manifold_meshes)
+TEST_CASE("intrinsic_delaunay_cotmatrix: manifold_meshes", "[igl]")
 {
-  Eigen::MatrixXd V;
-  Eigen::MatrixXi F;
-  test_common::load_mesh(GetParam(), V, F);
-  Eigen::SparseMatrix<double> L;
-  Eigen::MatrixXi F_intrinsic;
-  Eigen::MatrixXd l_intrinsic;
-  igl::intrinsic_delaunay_cotmatrix(V,F,L,l_intrinsic,F_intrinsic);
-  Eigen::VectorXi LI,LJ;
-  Eigen::VectorXd LV;
-  igl::find(L,LI,LJ,LV);
-
-  const std::vector<bool> is_boundary_vertex = igl::is_border_vertex(F);
-  // Off diagonals should be all non-positive
-  for(int k = 0;k<LI.size();k++)
+  auto test_case = [](const std::string &param)
   {
-    if(LI(k) != LJ(k) && 
-      !(is_boundary_vertex[LI(k)] && is_boundary_vertex[LJ(k)]))
+    Eigen::MatrixXd V;
+    Eigen::MatrixXi F;
+    test_common::load_mesh(param, V, F);
+    Eigen::SparseMatrix<double> L;
+    Eigen::MatrixXi F_intrinsic;
+    Eigen::MatrixXd l_intrinsic;
+    igl::intrinsic_delaunay_cotmatrix(V,F,L,l_intrinsic,F_intrinsic);
+    Eigen::VectorXi LI,LJ;
+    Eigen::VectorXd LV;
+    igl::find(L,LI,LJ,LV);
+
+    const std::vector<bool> is_boundary_vertex = igl::is_border_vertex(F);
+    // Off diagonals should be all non-positive
+    for(int k = 0;k<LI.size();k++)
     {
-      ASSERT_GT(LV(k),-igl::EPS<double>());
+      if(LI(k) != LJ(k) && 
+        !(is_boundary_vertex[LI(k)] && is_boundary_vertex[LJ(k)]))
+      {
+        REQUIRE (-igl::EPS<double>() < LV(k));
+      }
     }
-  }
+  };
+
+  test_common::run_test_cases(test_common::manifold_meshes(), test_case);
 }
 
-INSTANTIATE_TEST_CASE_P
-(
- manifold_meshes,
- intrinsic_delaunay_cotmatrix,
- ::testing::ValuesIn(test_common::manifold_meshes()),
- test_common::string_test_name
-);

tests/include/igl/intrinsic_delaunay_triangulation.cpp

@@ -9,7 +9,7 @@
 #include <igl/get_seconds.h>
 #include <igl/matlab_format.h>
 
-TEST(intrinsic_delaunay_triangulation, two_triangles)
+TEST_CASE("intrinsic_delaunay_triangulation: two_triangles", "[igl]")
 {
   const Eigen::MatrixXd V = 
     (Eigen::MatrixXd(4,2)<<
@@ -31,7 +31,7 @@ TEST(intrinsic_delaunay_triangulation, two_triangles)
   test_common::assert_near(l,lext,1e-10);
 }
 
-TEST(intrinsic_delaunay_triangulation, skewed_grid)
+TEST_CASE("intrinsic_delaunay_triangulation: skewed_grid", "[igl]")
 {
   Eigen::MatrixXd V;
   Eigen::MatrixXi F_in;
@@ -53,7 +53,7 @@ TEST(intrinsic_delaunay_triangulation, skewed_grid)
   test_common::assert_eq(D,Dtrue);
 }
 
-TEST(intrinsic_delaunay_triangulation, peaks)
+TEST_CASE("intrinsic_delaunay_triangulation: peaks", "[igl]")
 {
   Eigen::MatrixXd V2;
   Eigen::MatrixXi F_in;
@@ -86,7 +86,7 @@ TEST(intrinsic_delaunay_triangulation, peaks)
   test_common::assert_eq(D,D_gt);
 }
 
-TEST(intrinsic_delaunay_triangulation,tet)
+TEST_CASE("intrinsic_delaunay_triangulation: tet", "[igl]")
 {
   const Eigen::MatrixXd V = (Eigen::MatrixXd(4,3)<<
     10, 4,7,

tests/include/igl/is_delaunay.cpp

@@ -1,7 +1,7 @@
 #include <test_common.h>
 #include <igl/is_delaunay.h>
 
-TEST(is_delaunay, two_triangles)
+TEST_CASE("is_delaunay: two_triangles", "[igl]")
 {
   const Eigen::MatrixXd V = 
     (Eigen::MatrixXd(4,2)<<
@@ -19,7 +19,7 @@ TEST(is_delaunay, two_triangles)
   {
     for(int c=0;c<DD.cols();c++)
     {
-      ASSERT_TRUE(DD(f,c));
+      REQUIRE (DD(f,c));
     }
   }
   const Eigen::MatrixXi FN = 
@@ -27,6 +27,6 @@ TEST(is_delaunay, two_triangles)
      0,1,2,
      2,1,3).finished();
   igl::is_delaunay(V,FN,DN);
-  ASSERT_FALSE(DN(0,0));
-  ASSERT_FALSE(DN(1,2));
+  REQUIRE (!DN(0,0));
+  REQUIRE (!DN(1,2));
 }

tests/include/igl/is_intrinsic_delaunay.cpp

@@ -2,7 +2,7 @@
 #include <igl/is_intrinsic_delaunay.h>
 #include <igl/edge_lengths.h>
 
-TEST(is_intrinsic_delaunay, two_triangles)
+TEST_CASE("is_intrinsic_delaunay: two_triangles", "[igl]")
 {
   const Eigen::MatrixXd V = 
     (Eigen::MatrixXd(4,2)<<
@@ -22,7 +22,7 @@ TEST(is_intrinsic_delaunay, two_triangles)
   {
     for(int c=0;c<DD.cols();c++)
     {
-      ASSERT_TRUE(DD(f,c));
+      REQUIRE (DD(f,c));
     }
   }
   const Eigen::MatrixXi FN = 
@@ -32,6 +32,6 @@ TEST(is_intrinsic_delaunay, two_triangles)
   Eigen::MatrixXd lN;
   igl::edge_lengths(V,FN,lN);
   igl::is_intrinsic_delaunay(lN,FN,DN);
-  ASSERT_FALSE(DN(0,0));
-  ASSERT_FALSE(DN(1,2));
+  REQUIRE (!DN(0,0));
+  REQUIRE (!DN(1,2));
 }

tests/include/igl/triangulated_grid.cpp

@@ -2,18 +2,18 @@
 #include <igl/triangulated_grid.h>
 #include <igl/doublearea.h>
 
-TEST(triangulated_grid,area)
+TEST_CASE("triangulated_grid: area", "[igl]")
 {
   Eigen::MatrixXd V;
   Eigen::MatrixXi F;
   const int nx = 4;
   const int ny = 7;
   igl::triangulated_grid(nx,ny,V,F);
-  ASSERT_EQ(V.rows(),nx*ny);
-  ASSERT_EQ(F.rows(),2*(nx-1)*(ny-1));
+  REQUIRE (nx*ny == V.rows());
+  REQUIRE (2*(nx-1)*(ny-1) == F.rows());
   Eigen::VectorXd dblA;
   igl::doublearea(V,F,dblA);
-  ASSERT_NEAR(dblA.array().sum(),2.0,1e-10);
+  REQUIRE (2.0 == Approx (dblA.array().sum()).margin(1e-10));
   const Eigen::VectorXd dblAgt = 
     Eigen::VectorXd::Constant(
       2*(nx-1)*(ny-1),

tests/include/igl/unique_simplices.cpp

@@ -1,7 +1,7 @@
 #include <test_common.h>
 #include <igl/unique_simplices.h>
 
-TEST(igl_unique_simplices, duplicate_triangles)
+TEST_CASE("igl_unique_simplices: duplicate_triangles", "[igl]")
 {
   const Eigen::MatrixXi F = (Eigen::MatrixXi(2,3)<<0,1,2,0,1,2).finished();
 
@@ -24,7 +24,7 @@ TEST(igl_unique_simplices, duplicate_triangles)
           Eigen::VectorXi IA,IC;
           igl::unique_simplices(Fij,Fu,IA,IC);
           // There's only one unique simplex
-          ASSERT_EQ(Fu.rows(),1);
+          REQUIRE (1 == Fu.rows());
         }
       }
     }