diff --git a/CMakeLists.txt b/CMakeLists.txt
index 56c29a5..af1817b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,7 +58,8 @@ set(COMMAND_TO_RUN
 include_directories(${Python3_INCLUDE_DIRS})
 link_directories("${Python3_LIBRARY_DIRS}")
 
-set(COMMON_INCLUDES ${PROJECT_SOURCE_DIR}/include ${PROJECT_SOURCE_DIR}/src)
+set(COMMON_INCLUDES ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/include
+                    ${PROJECT_SOURCE_DIR}/src)
 
 enable_testing()
 include_directories(${COMMON_INCLUDES})
diff --git a/src/file_manager.cpp b/src/file_manager.cpp
index d842a3c..6ee0ba0 100644
--- a/src/file_manager.cpp
+++ b/src/file_manager.cpp
@@ -1,4 +1,4 @@
-#include "../src/file_manager.h"
+#include "src/file_manager.h"
 
 #include <filesystem>
 #include <iostream>
@@ -26,6 +26,23 @@ void FileManerger::createFile() {
   }
 }
 
+void FileManerger::openAppend() {
+  std::unique_lock<std::shared_mutex> lock(mutex_);
+
+  std::error_code ec;
+  if (!std::filesystem::create_directories(basic_path_, ec) && ec) {
+    throw std::runtime_error("Failed to create directory: " + basic_path_ +
+                             ", error: " + ec.message());
+  }
+
+  std::string full_path = basic_path_ + file_name_;
+
+  file_stream_.open(full_path, std::ios::out | std::ios::app);
+  if (!file_stream_.is_open()) {
+    throw std::runtime_error("Failed to open file for append: " + full_path);
+  }
+}
+
 void FileManerger::writeString(const std::string& str) {
   std::shared_lock<std::shared_mutex> lock(mutex_);
   if (file_stream_.is_open()) {
diff --git a/src/file_manager.h b/src/file_manager.h
index f9e5df3..1d7a5da 100644
--- a/src/file_manager.h
+++ b/src/file_manager.h
@@ -12,6 +12,7 @@ class FileManerger {
 
   void setFileName(const std::string& value);
   void createFile();
+  void openAppend();
   void writeString(const std::string& str);
   FileManerger& operator<<(const std::string& str);
   void saveFile();
diff --git a/test/ops/AbsTest.cpp b/test/ops/AbsTest.cpp
index cdf9422..d163722 100644
--- a/test/ops/AbsTest.cpp
+++ b/test/ops/AbsTest.cpp
@@ -4,11 +4,19 @@
 #include <ATen/ops/zeros.h>
 #include <gtest/gtest.h>
 
+#include <string>
 #include <vector>
 
+#include "../../src/file_manager.h"
+
+extern paddle_api_test::ThreadSafeParam g_custom_param;
+
 namespace at {
 namespace test {
 
+using paddle_api_test::FileManerger;
+using paddle_api_test::ThreadSafeParam;
+
 class AbsTest : public ::testing::Test {
  protected:
   void SetUp() override {
@@ -23,14 +31,23 @@ class AbsTest : public ::testing::Test {
   at::Tensor test_tensor;
 };
 
+static void write_abs_result_to_file(FileManerger* file,
+                                     const at::Tensor& result) {
+  *file << std::to_string(result.dim()) << " ";
+  *file << std::to_string(result.numel()) << " ";
+  float* result_data = result.data_ptr<float>();
+  for (int64_t i = 0; i < result.numel(); ++i) {
+    *file << std::to_string(result_data[i]) << " ";
+  }
+}
+
 TEST_F(AbsTest, BasicAbs) {
   at::Tensor result = at::abs(test_tensor);
-  EXPECT_EQ(result.sizes(), test_tensor.sizes());
-  float* result_data = result.data_ptr<float>();
-  EXPECT_FLOAT_EQ(result_data[0], 1.0f);
-  EXPECT_FLOAT_EQ(result_data[1], 2.0f);
-  EXPECT_FLOAT_EQ(result_data[2], 0.0f);
-  EXPECT_FLOAT_EQ(result_data[3], 3.5f);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  write_abs_result_to_file(&file, result);
+  file.saveFile();
 }
 
 TEST_F(AbsTest, PositiveTensor) {
@@ -41,10 +58,11 @@ TEST_F(AbsTest, PositiveTensor) {
   data[2] = 7.2f;
 
   at::Tensor result = at::abs(positive_tensor);
-  float* result_data = result.data_ptr<float>();
-  EXPECT_FLOAT_EQ(result_data[0], 1.5f);
-  EXPECT_FLOAT_EQ(result_data[1], 3.0f);
-  EXPECT_FLOAT_EQ(result_data[2], 7.2f);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.openAppend();
+  write_abs_result_to_file(&file, result);
+  file.saveFile();
 }
 
 TEST_F(AbsTest, NegativeTensor) {
@@ -55,10 +73,11 @@ TEST_F(AbsTest, NegativeTensor) {
   data[2] = -7.2f;
 
   at::Tensor result = at::abs(negative_tensor);
-  float* result_data = result.data_ptr<float>();
-  EXPECT_FLOAT_EQ(result_data[0], 1.5f);
-  EXPECT_FLOAT_EQ(result_data[1], 3.0f);
-  EXPECT_FLOAT_EQ(result_data[2], 7.2f);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.openAppend();
+  write_abs_result_to_file(&file, result);
+  file.saveFile();
 }
 
 }  // namespace test
diff --git a/test/ops/ArangeTest.cpp b/test/ops/ArangeTest.cpp
index 43b8676..790a97f 100644
--- a/test/ops/ArangeTest.cpp
+++ b/test/ops/ArangeTest.cpp
@@ -3,11 +3,19 @@
 #include <ATen/ops/arange.h>
 #include <gtest/gtest.h>
 
+#include <string>
 #include <vector>
 
+#include "../../src/file_manager.h"
+
+extern paddle_api_test::ThreadSafeParam g_custom_param;
+
 namespace at {
 namespace test {
 
+using paddle_api_test::FileManerger;
+using paddle_api_test::ThreadSafeParam;
+
 class ArangeTest : public ::testing::Test {
  protected:
   void SetUp() override {}
@@ -15,59 +23,74 @@ class ArangeTest : public ::testing::Test {
 
 TEST_F(ArangeTest, BasicArangeWithEnd) {
   at::Tensor result = at::arange(5, at::TensorOptions().dtype(at::kLong));
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 5);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
   int64_t* data = result.data_ptr<int64_t>();
   for (int64_t i = 0; i < 5; ++i) {
-    EXPECT_EQ(data[i], i);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(ArangeTest, ArangeWithStartEnd) {
   at::Tensor result = at::arange(2, 7, at::TensorOptions().dtype(at::kLong));
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 5);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
   int64_t* data = result.data_ptr<int64_t>();
   for (int64_t i = 0; i < 5; ++i) {
-    EXPECT_EQ(data[i], i + 2);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(ArangeTest, ArangeWithStartEndStep) {
   at::Tensor result =
       at::arange(1, 10, 2, at::TensorOptions().dtype(at::kLong));
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 5);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
   int64_t* data = result.data_ptr<int64_t>();
   for (int64_t i = 0; i < 5; ++i) {
-    EXPECT_EQ(data[i], 1 + i * 2);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(ArangeTest, ArangeWithOptions) {
   at::Tensor result = at::arange(4, at::TensorOptions().dtype(at::kFloat));
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 4);
-  EXPECT_EQ(result.dtype(), at::kFloat);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(static_cast<int>(result.scalar_type())) << " ";
   float* data = result.data_ptr<float>();
   for (int64_t i = 0; i < 4; ++i) {
-    EXPECT_FLOAT_EQ(data[i], static_cast<float>(i));
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(ArangeTest, NegativeValues) {
   at::Tensor result = at::arange(-3, 3, at::TensorOptions().dtype(at::kLong));
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 6);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
   int64_t* data = result.data_ptr<int64_t>();
   for (int64_t i = 0; i < 6; ++i) {
-    EXPECT_EQ(data[i], i - 3);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 }  // namespace test
diff --git a/test/ops/ConnectionOpsTest.cpp b/test/ops/ConnectionOpsTest.cpp
index 817eba6..1e8d829 100644
--- a/test/ops/ConnectionOpsTest.cpp
+++ b/test/ops/ConnectionOpsTest.cpp
@@ -4,11 +4,19 @@
 #include <ATen/ops/zeros.h>
 #include <gtest/gtest.h>
 
+#include <string>
 #include <vector>
 
+#include "../../src/file_manager.h"
+
+extern paddle_api_test::ThreadSafeParam g_custom_param;
+
 namespace at {
 namespace test {
 
+using paddle_api_test::FileManerger;
+using paddle_api_test::ThreadSafeParam;
+
 class ConnectionOpsTest : public ::testing::Test {
  protected:
   void SetUp() override {
@@ -30,32 +38,35 @@ class ConnectionOpsTest : public ::testing::Test {
 TEST_F(ConnectionOpsTest, CatDim0) {
   std::vector<at::Tensor> tensors = {tensor1, tensor2};
   at::Tensor result = at::cat(tensors, 0);
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.sizes()[0], 4);  // 2+2
-  EXPECT_EQ(result.sizes()[1], 3);
-  EXPECT_EQ(result.numel(), 12);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.sizes()[0]) << " ";
+  file << std::to_string(result.sizes()[1]) << " ";
+  file << std::to_string(result.numel()) << " ";
   float* data = result.data_ptr<float>();
   for (int64_t i = 0; i < 12; ++i) {
-    EXPECT_FLOAT_EQ(data[i], static_cast<float>(i));
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(ConnectionOpsTest, CatDim1) {
   std::vector<at::Tensor> tensors = {tensor1, tensor2};
   at::Tensor result = at::cat(tensors, 1);
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.sizes()[0], 2);
-  EXPECT_EQ(result.sizes()[1], 6);  // 3+3
-  EXPECT_EQ(result.numel(), 12);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.sizes()[0]) << " ";
+  file << std::to_string(result.sizes()[1]) << " ";
+  file << std::to_string(result.numel()) << " ";
   float* data = result.data_ptr<float>();
-  float expected_values[12] = {0, 1, 2, 6, 7, 8, 3, 4, 5, 9, 10, 11};
   for (int64_t i = 0; i < 12; ++i) {
-    EXPECT_FLOAT_EQ(data[i], expected_values[i]);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(ConnectionOpsTest, CatThreeTensors) {
@@ -67,10 +78,13 @@ TEST_F(ConnectionOpsTest, CatThreeTensors) {
 
   std::vector<at::Tensor> tensors = {tensor1, tensor2, tensor3};
   at::Tensor result = at::cat(tensors, 0);
-
-  EXPECT_EQ(result.sizes()[0], 6);  // 2+2+2
-  EXPECT_EQ(result.sizes()[1], 3);
-  EXPECT_EQ(result.numel(), 18);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.sizes()[0]) << " ";
+  file << std::to_string(result.sizes()[1]) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file.saveFile();
 }
 
 TEST_F(ConnectionOpsTest, CatWithDifferentTypes) {
@@ -79,11 +93,13 @@ TEST_F(ConnectionOpsTest, CatWithDifferentTypes) {
 
   std::vector<at::Tensor> tensors = {int_tensor, float_tensor};
   at::Tensor result = at::cat(tensors, 0);
-
-  // Tensors should be promoted to common type
-  EXPECT_EQ(result.dtype(), at::kInt);
-  EXPECT_EQ(result.sizes()[0], 2);
-  EXPECT_EQ(result.sizes()[1], 2);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(static_cast<int>(result.scalar_type())) << " ";
+  file << std::to_string(result.sizes()[0]) << " ";
+  file << std::to_string(result.sizes()[1]) << " ";
+  file.saveFile();
 }
 
 }  // namespace test
diff --git a/test/ops/CreationOpsTest.cpp b/test/ops/CreationOpsTest.cpp
index 23b8160..205a54d 100644
--- a/test/ops/CreationOpsTest.cpp
+++ b/test/ops/CreationOpsTest.cpp
@@ -6,11 +6,19 @@
 #include <ATen/ops/zeros.h>
 #include <gtest/gtest.h>
 
+#include <string>
 #include <vector>
 
+#include "../../src/file_manager.h"
+
+extern paddle_api_test::ThreadSafeParam g_custom_param;
+
 namespace at {
 namespace test {
 
+using paddle_api_test::FileManerger;
+using paddle_api_test::ThreadSafeParam;
+
 class CreationOpsTest : public ::testing::Test {
  protected:
   void SetUp() override {}
@@ -19,98 +27,116 @@ class CreationOpsTest : public ::testing::Test {
 TEST_F(CreationOpsTest, ZerosBasic) {
   std::vector<int64_t> shape = {2, 3};
   at::Tensor result = at::zeros(shape);
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.numel(), 6);
-  EXPECT_EQ(result.sizes()[0], 2);
-  EXPECT_EQ(result.sizes()[1], 3);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(result.sizes()[0]) << " ";
+  file << std::to_string(result.sizes()[1]) << " ";
   float* data = result.data_ptr<float>();
   for (int64_t i = 0; i < 6; ++i) {
-    EXPECT_FLOAT_EQ(data[i], 0.0f);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, ZerosWithOptions) {
   at::Tensor result = at::zeros({3, 4}, at::TensorOptions().dtype(at::kDouble));
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.numel(), 12);
-  EXPECT_EQ(result.dtype(), at::kDouble);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(static_cast<int>(result.scalar_type())) << " ";
   double* data = result.data_ptr<double>();
   for (int64_t i = 0; i < 12; ++i) {
-    EXPECT_DOUBLE_EQ(data[i], 0.0);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, OnesBasic) {
   at::Tensor result = at::ones({2, 2});
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.numel(), 4);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
   float* data = result.data_ptr<float>();
   for (int64_t i = 0; i < 4; ++i) {
-    EXPECT_FLOAT_EQ(data[i], 1.0f);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, OnesWithOptions) {
   at::Tensor result = at::ones({3}, at::TensorOptions().dtype(at::kInt));
-
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 3);
-  EXPECT_EQ(result.dtype(), at::kInt);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(static_cast<int>(result.scalar_type())) << " ";
   int* data = result.data_ptr<int>();
   for (int64_t i = 0; i < 3; ++i) {
-    EXPECT_EQ(data[i], 1);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, EmptyBasic) {
   at::Tensor result = at::empty({2, 3});
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.numel(), 6);
-  EXPECT_EQ(result.sizes()[0], 2);
-  EXPECT_EQ(result.sizes()[1], 3);
-  EXPECT_NE(result.data_ptr(), nullptr);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(result.sizes()[0]) << " ";
+  file << std::to_string(result.sizes()[1]) << " ";
+  file << std::to_string(result.data_ptr() != nullptr) << " ";
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, EmptyWithOptions) {
   at::Tensor result = at::empty({4}, at::TensorOptions().dtype(at::kFloat));
-
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 4);
-  EXPECT_EQ(result.dtype(), at::kFloat);
-  EXPECT_NE(result.data_ptr<float>(), nullptr);
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(static_cast<int>(result.scalar_type())) << " ";
+  file << std::to_string(result.data_ptr<float>() != nullptr) << " ";
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, FullBasic) {
   at::Tensor result = at::full({2, 2}, 5.0f);
-
-  EXPECT_EQ(result.dim(), 2);
-  EXPECT_EQ(result.numel(), 4);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
   float* data = result.data_ptr<float>();
   for (int64_t i = 0; i < 4; ++i) {
-    EXPECT_FLOAT_EQ(data[i], 5.0f);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 TEST_F(CreationOpsTest, FullWithOptions) {
   at::Tensor result = at::full({3}, 10, at::TensorOptions().dtype(at::kLong));
-
-  EXPECT_EQ(result.dim(), 1);
-  EXPECT_EQ(result.numel(), 3);
-  EXPECT_EQ(result.dtype(), at::kLong);
-
+  auto file_name = g_custom_param.get();
+  FileManerger file(file_name);
+  file.createFile();
+  file << std::to_string(result.dim()) << " ";
+  file << std::to_string(result.numel()) << " ";
+  file << std::to_string(static_cast<int>(result.scalar_type())) << " ";
   int64_t* data = result.data_ptr<int64_t>();
   for (int64_t i = 0; i < 3; ++i) {
-    EXPECT_EQ(data[i], 10);
+    file << std::to_string(data[i]) << " ";
   }
+  file.saveFile();
 }
 
 }  // namespace test