diff --git a/Tests/NumLib/NaturalNodeCoordinates.cpp b/Tests/NumLib/NaturalNodeCoordinates.cpp
index 2655b205284cd161f33646dab11080446bdb330e..18d6f1a8ede62f290e0d0334bd62a4b2efe62548 100644
--- a/Tests/NumLib/NaturalNodeCoordinates.cpp
+++ b/Tests/NumLib/NaturalNodeCoordinates.cpp
@@ -16,7 +16,7 @@
 #include "NumLib/Fem/CoordinatesMapping/NaturalNodeCoordinates.h"
 #include "NumLib/Fem/CoordinatesMapping/ShapeMatrices.h"
 #include "NumLib/Fem/FiniteElement/C0IsoparametricElements.h"
-#include "NumLib/Fem/Integration/GaussIntegrationPolicy.h"
+#include "NumLib/Fem/Integration/GaussLegendreIntegrationPolicy.h"
 #include "NumLib/Fem/ShapeMatrixPolicy.h"
 
 template <typename ShapeFunction, int GlobalDim>
diff --git a/Tests/NumLib/TestFe.cpp b/Tests/NumLib/TestFe.cpp
index fd789279b28c7b31aef073543a6afb392e8bcad3..b09c3f1789e6578b1623de489e6ef9d99301db38 100644
--- a/Tests/NumLib/TestFe.cpp
+++ b/Tests/NumLib/TestFe.cpp
@@ -19,7 +19,7 @@
 
 #include "NumLib/Fem/CoordinatesMapping/ShapeMatrices.h"
 #include "NumLib/Fem/FiniteElement/C0IsoparametricElements.h"
-#include "NumLib/Fem/Integration/GaussIntegrationPolicy.h"
+#include "NumLib/Fem/Integration/GaussLegendreIntegrationPolicy.h"
 #include "NumLib/Fem/ShapeMatrixPolicy.h"
 
 #include "FeTestData/TestFeLINE2.h"
@@ -101,7 +101,7 @@ class NumLibFemIsoTest : public ::testing::Test, public T::TestFeType
      static const unsigned n_sample_pt_order2 = TestFeType::n_sample_pt_order2;
      static const unsigned n_sample_pt_order3 = TestFeType::n_sample_pt_order3;
 
-     using IntegrationMethod = typename NumLib::GaussIntegrationPolicy<
+     using IntegrationMethod = typename NumLib::GaussLegendreIntegrationPolicy<
          MeshElementType>::IntegrationMethod;
 
  public:
@@ -255,7 +255,7 @@ TYPED_TEST(NumLibFemIsoTest, CheckMassLaplaceMatrices)
 }
 
 #if 0
-TYPED_TEST(NumLibFemIsoTest, CheckGaussIntegrationLevel)
+TYPED_TEST(NumLibFemIsoTest, CheckGaussLegendreIntegrationLevel)
 {
     // Refer to typedefs in the fixture
     using FeType = typename TestFixture::FeType;
diff --git a/Tests/NumLib/TestFemIntegration.cpp b/Tests/NumLib/TestFemIntegration.cpp
index 1c04529ae820fa38d15d387569912ea37841257d..14cb3d789b7ed0fd254b9db4c4e5bc85074dac3e 100644
--- a/Tests/NumLib/TestFemIntegration.cpp
+++ b/Tests/NumLib/TestFemIntegration.cpp
@@ -15,11 +15,11 @@
 
 #include "Tests/TestTools.h"
 
-#include "NumLib/Fem/Integration/IntegrationGaussRegular.h"
+#include "NumLib/Fem/Integration/IntegrationGaussLegendreRegular.h"
 
 using namespace NumLib;
 
-TEST(NumLib, FemIntegrationGaussRegular)
+TEST(NumLib, FemIntegrationGaussLegendreRegular)
 {
     const std::size_t integrationOrder = 2;
     const double eps = std::numeric_limits<double>::epsilon();
@@ -29,27 +29,45 @@ TEST(NumLib, FemIntegrationGaussRegular)
     {
         std::size_t expected[1] = { 0u };
         ASSERT_ARRAY_EQ(expected,
-                IntegrationGaussRegular<1>::getPositionIndices(integrationOrder, 0).data(), 1u);
+                        IntegrationGaussLegendreRegular<1>::getPositionIndices(
+                            integrationOrder, 0)
+                            .data(),
+                        1u);
         expected[0] = 1u;
         ASSERT_ARRAY_EQ(expected,
-                IntegrationGaussRegular<1>::getPositionIndices(integrationOrder, 1).data(), 1u);
+                        IntegrationGaussLegendreRegular<1>::getPositionIndices(
+                            integrationOrder, 1)
+                            .data(),
+                        1u);
     }
     // dim = 2
     {
         std::size_t expected[2] = { 0u, 0u };
         ASSERT_ARRAY_EQ(expected,
-                IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 0).data(), 2);
+                        IntegrationGaussLegendreRegular<2>::getPositionIndices(
+                            integrationOrder, 0)
+                            .data(),
+                        2);
         expected[1] = 1u;
         ASSERT_ARRAY_EQ(expected,
-                IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 1).data(), 2);
+                        IntegrationGaussLegendreRegular<2>::getPositionIndices(
+                            integrationOrder, 1)
+                            .data(),
+                        2);
         expected[0] = 1u;
         expected[1] = 0u;
         ASSERT_ARRAY_EQ(expected,
-                IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 2).data(), 2);
+                        IntegrationGaussLegendreRegular<2>::getPositionIndices(
+                            integrationOrder, 2)
+                            .data(),
+                        2);
         expected[0] = 1u;
         expected[1] = 1u;
         ASSERT_ARRAY_EQ(expected,
-                IntegrationGaussRegular<2>::getPositionIndices(integrationOrder, 3).data(), 2);
+                        IntegrationGaussLegendreRegular<2>::getPositionIndices(
+                            integrationOrder, 3)
+                            .data(),
+                        2);
     }
     // dim = 3
     {
@@ -61,9 +79,12 @@ TEST(NumLib, FemIntegrationGaussRegular)
                 for (std::size_t k(0); k <= 1; k++) {
                     expected[2] = k;
                     const std::size_t l(i * 4 + j * 2 + k);
-                    ASSERT_ARRAY_EQ(expected,
-                            IntegrationGaussRegular<3>::getPositionIndices(integrationOrder, l).data(),
-                            3);
+                    ASSERT_ARRAY_EQ(
+                        expected,
+                        IntegrationGaussLegendreRegular<3>::getPositionIndices(
+                            integrationOrder, l)
+                            .data(),
+                        3);
                 }
             }
         }
@@ -72,60 +93,102 @@ TEST(NumLib, FemIntegrationGaussRegular)
     // dim = 1
     // weight
     ASSERT_NEAR(1.0,
-            IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
+                IntegrationGaussLegendreRegular<1>::getWeightedPoint(
+                    integrationOrder, 0)
+                    .getWeight(),
+                eps);
     // pos
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 0)[0], eps);
+                IntegrationGaussLegendreRegular<1>::getWeightedPoint(
+                    integrationOrder, 0)[0],
+                eps);
     // weight
     ASSERT_NEAR(1.0,
-            IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
+                IntegrationGaussLegendreRegular<1>::getWeightedPoint(
+                    integrationOrder, 1)
+                    .getWeight(),
+                eps);
     // pos
     ASSERT_NEAR(-0.577350269189626,
-            IntegrationGaussRegular<1>::getWeightedPoint(integrationOrder, 1)[0], eps);
+                IntegrationGaussLegendreRegular<1>::getWeightedPoint(
+                    integrationOrder, 1)[0],
+                eps);
 
     // dim = 2
     ASSERT_NEAR(1.0,
-            IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
+                IntegrationGaussLegendreRegular<2>::getWeightedPoint(
+                    integrationOrder, 0)
+                    .getWeight(),
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0)[0], eps);
+                IntegrationGaussLegendreRegular<2>::getWeightedPoint(
+                    integrationOrder, 0)[0],
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 0)[1], eps);
+                IntegrationGaussLegendreRegular<2>::getWeightedPoint(
+                    integrationOrder, 0)[1],
+                eps);
     ASSERT_NEAR(1.0,
-            IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
+                IntegrationGaussLegendreRegular<2>::getWeightedPoint(
+                    integrationOrder, 1)
+                    .getWeight(),
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1)[0], eps);
+                IntegrationGaussLegendreRegular<2>::getWeightedPoint(
+                    integrationOrder, 1)[0],
+                eps);
     ASSERT_NEAR(-0.577350269189626,
-            IntegrationGaussRegular<2>::getWeightedPoint(integrationOrder, 1)[1], eps);
+                IntegrationGaussLegendreRegular<2>::getWeightedPoint(
+                    integrationOrder, 1)[1],
+                eps);
 
     // dim = 3
     ASSERT_NEAR(1.0,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0).getWeight(), eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 0)
+                    .getWeight(),
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[0], eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 0)[0],
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[1], eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 0)[1],
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 0)[2], eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 0)[2],
+                eps);
     ASSERT_NEAR(1.0,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1).getWeight(), eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 1)
+                    .getWeight(),
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[0], eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 1)[0],
+                eps);
     ASSERT_NEAR(0.577350269189626,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[1], eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 1)[1],
+                eps);
     ASSERT_NEAR(-0.577350269189626,
-            IntegrationGaussRegular<3>::getWeightedPoint(integrationOrder, 1)[2], eps);
+                IntegrationGaussLegendreRegular<3>::getWeightedPoint(
+                    integrationOrder, 1)[2],
+                eps);
 
     // check other member functions
-    IntegrationGaussRegular<1> q1;
+    IntegrationGaussLegendreRegular<1> q1;
     ASSERT_EQ(2u, q1.getIntegrationOrder());
     ASSERT_EQ(2u, q1.getNumberOfPoints());
     q1.setIntegrationOrder(3u);
     ASSERT_EQ(3u, q1.getIntegrationOrder());
     ASSERT_EQ(3u, q1.getNumberOfPoints());
-    IntegrationGaussRegular<2> q2;
+    IntegrationGaussLegendreRegular<2> q2;
     ASSERT_EQ(2u, q2.getIntegrationOrder());
     ASSERT_EQ(4u, q2.getNumberOfPoints());
-    IntegrationGaussRegular<3> q3;
+    IntegrationGaussLegendreRegular<3> q3;
     ASSERT_EQ(2u, q3.getIntegrationOrder());
     ASSERT_EQ(8u, q3.getNumberOfPoints());
 }
diff --git a/Tests/NumLib/TestFunctionInterpolation.cpp b/Tests/NumLib/TestFunctionInterpolation.cpp
index bbfe197a891ec60c1538587175f197193774e844..38f0d72800c639fc1cbc19945110b2dbf9896dd4 100644
--- a/Tests/NumLib/TestFunctionInterpolation.cpp
+++ b/Tests/NumLib/TestFunctionInterpolation.cpp
@@ -19,8 +19,7 @@
 
 #include "MeshLib/Elements/Element.h"
 
-#include "NumLib/Fem/Integration/GaussIntegrationPolicy.h"
-
+#include "NumLib/Fem/Integration/GaussLegendreIntegrationPolicy.h"
 
 TEST(NumLibFunctionInterpolationTest, TwoVariablesTwoNodes)
 {
@@ -50,7 +49,7 @@ TEST(NumLibFunctionInterpolationTest, Linear1DElement)
 
     using FemType = NumLib::TemplateIsoparametric<ShapeFunction, ShapeMatricesType>;
 
-    using IntegrationMethod = NumLib::GaussIntegrationPolicy<
+    using IntegrationMethod = NumLib::GaussLegendreIntegrationPolicy<
         ShapeFunction::MeshElement>::IntegrationMethod;
 
     // set up mesh element
diff --git a/Tests/NumLib/TestGradShapeFunction.cpp b/Tests/NumLib/TestGradShapeFunction.cpp
index 230f30962d977b868312daf190f5b5a6ae098623..111f9ac24acf8fdd21cf55e74bc29927924fc6ff 100644
--- a/Tests/NumLib/TestGradShapeFunction.cpp
+++ b/Tests/NumLib/TestGradShapeFunction.cpp
@@ -24,7 +24,7 @@
 
 #include "NumLib/Fem/CoordinatesMapping/ShapeMatrices.h"
 #include "NumLib/Fem/FiniteElement/C0IsoparametricElements.h"
-#include "NumLib/Fem/Integration/GaussIntegrationPolicy.h"
+#include "NumLib/Fem/Integration/GaussLegendreIntegrationPolicy.h"
 #include "NumLib/Fem/ShapeMatrixPolicy.h"
 
 #include "FeTestData/TestFeLINE2.h"
@@ -122,7 +122,7 @@ public:
     static const unsigned n_sample_pt_order2 = TestFeType::n_sample_pt_order2;
     static const unsigned n_sample_pt_order3 = TestFeType::n_sample_pt_order3;
 
-    using IntegrationMethod = typename NumLib::GaussIntegrationPolicy<
+    using IntegrationMethod = typename NumLib::GaussLegendreIntegrationPolicy<
         MeshElementType>::IntegrationMethod;
 
 public: