Add test_Matrix.cpp for auto compare member functions of class Matrix

paddle/math/tests/CMakeLists.txt

@@ -2,7 +2,7 @@
 
 add_simple_unittest(test_ExecViaCpu)
 add_simple_unittest(test_SIMDFunctions)
-add_simple_unittest(test_matrix)
+add_simple_unittest(test_SparseMatrix)
 
 # TODO(yuyang18): Refactor TestUtil.cpp. Remove this cross module reference.
 add_unittest(test_matrixCompare
@@ -14,5 +14,6 @@ add_simple_unittest(test_perturbation)
 add_simple_unittest(test_CpuGpuVector)
 add_simple_unittest(test_Allocator)
 add_simple_unittest(test_FPException)
-add_simple_unittest(test_BaseMatrix)
 add_simple_unittest(test_GpuProfiler)
+add_simple_unittest(test_BaseMatrix)
+add_simple_unittest(test_Matrix)

paddle/math/tests/TensorCheck.h

@@ -37,6 +37,7 @@ public:
         }
       }
     }
+
     return true;
   }
 
@@ -61,7 +62,7 @@ template <>
 class CopyToCpu<GpuMatrix> {
 public:
   explicit CopyToCpu(const GpuMatrix& arg)
-    : arg_(arg.getHeight(), arg.getWidth()) {
+      : arg_(arg.getHeight(), arg.getWidth()) {
     arg_.copyFrom(arg);
   }
   CpuMatrix& copiedArg() { return arg_; }
@@ -70,7 +71,7 @@ private:
   CpuMatrix arg_;
 };
 
-template<typename AssertEq>
+template <typename AssertEq>
 void TensorCheck(AssertEq compare,
                  const CpuMatrix& matrix1,
                  const CpuMatrix& matrix2) {
@@ -94,15 +95,19 @@ void TensorCheck(AssertEq compare,
   EXPECT_EQ(count, 0) << "There are " << count << " different element.";
 }
 
-template<typename AssertEq, typename Tensor1, typename Tensor2>
+template <typename AssertEq, typename Tensor1, typename Tensor2>
 extern void TensorCheck(AssertEq compare,
                         const Tensor1& tensor1,
                         const Tensor2& tensor2) {
-  TensorCheck(
-    compare,
-    CopyToCpu<Tensor1>(tensor1).copiedArg(),
-    CopyToCpu<Tensor2>(tensor2).copiedArg());
+  TensorCheck(compare,
+              CopyToCpu<Tensor1>(tensor1).copiedArg(),
+              CopyToCpu<Tensor2>(tensor2).copiedArg());
 }
 
-}  // namespace autotest
+template <typename AssertEq>
+void TensorCheck(AssertEq compare, real args1, real args2) {
+  EXPECT_EQ(compare(args1, args2), true) << "[Test error] args1 = " << args1
+                                         << ", args2 = " << args2;
+}
 
+}  // namespace autotest

paddle/math/tests/test_Matrix.cpp

@@ -0,0 +1,49 @@
+/* Copyright (c) 2016 Baidu, Inc. All Rights Reserve.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifndef PADDLE_ONLY_CPU
+/**
+ * This test file compares the implementation of CPU and GPU function
+ * in Matrix.cpp.
+ */
+
+#include <gtest/gtest.h>
+#include "paddle/utils/Util.h"
+#include "paddle/math/BaseMatrix.h"
+#include "TestUtils.h"
+
+using namespace paddle;  // NOLINT
+using namespace std;     // NOLINT
+
+/**
+ * Test member functions which prototype is
+ * void (Matrix::*)(Matrix&).
+ */
+TEST(BaseMatrix, real) {
+  typedef void (Matrix::*FunctionProto)(Matrix&);
+#define MATRIXCOMPARE(function) \
+  BaseMatrixCompare<0>(static_cast<FunctionProto>(&Matrix::function), true);
+
+  MATRIXCOMPARE(softmax);
+
+#undef MATRIXCOMPARE
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  initMain(argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+#endif

paddle/math/tests/test_matrixCompare.cpp

@@ -693,24 +693,6 @@ TEST(Matrix, unary) {
   }
 }
 
-void testMatrixSoftmax(int height, int width) {
-  MatrixPtr cpuInput = std::make_shared<CpuMatrix>(height, width);
-  MatrixPtr cpuOutput = std::make_shared<CpuMatrix>(height, width);
-  MatrixPtr gpuInput = std::make_shared<GpuMatrix>(height, width);
-  MatrixPtr gpuOutput = std::make_shared<GpuMatrix>(height, width);
-
-  cpuInput->randomizeUniform();
-  gpuInput->copyFrom(*cpuInput);
-  cpuOutput->zero();
-  gpuOutput->zero();
-  cpuInput->softmax(*cpuOutput);
-  gpuInput->softmax(*gpuOutput);
-
-  MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
-  outputCheck->copyFrom(*gpuOutput);
-  MatrixCheckErr(*cpuOutput, *outputCheck);
-}
-
 void testSequenceSoftmax(int batchSize) {
   // forward
   int inputDim = 1;
@@ -793,7 +775,6 @@ TEST(Matrix, softmax) {
     for (auto width : {1, 32, 100, 512, 1000}) {
       VLOG(3) << " height=" << height << " width=" << width;
 
-      testMatrixSoftmax(height, width);
       testMatrixSoftmaxBp(height, width);
       testMatrixSoftmaxThreshold(height, width);
     }