From 59503a875820465f213a812c03b612efb829829d Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Tue, 30 Dec 2025 17:32:18 +0800 Subject: [PATCH 1/9] add cpu's test --- test/TensorTest.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index 5868349..9a2c853 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -144,6 +144,16 @@ TEST_F(TensorTest, IsCpu) { EXPECT_TRUE(tensor.is_cpu()); } +// 测试 cpu +TEST_F(TensorTest, Cpu) { + at::Tensor cpu_tensor = tensor.cpu(); + + EXPECT_TRUE(cpu_tensor.is_cpu()); + EXPECT_EQ(cpu_tensor.device().type(), c10::DeviceType::CPU); + EXPECT_EQ(cpu_tensor.numel(), tensor.numel()); + EXPECT_FLOAT_EQ(cpu_tensor.data_ptr()[0], tensor.data_ptr()[0]); +} + // 测试 is_cuda (在 CPU tensor 上应该返回 false) TEST_F(TensorTest, IsCuda) { // Tensor tensor(paddle_tensor_); From da62e82542ed8faec0f65ff9dcd6b142282996fd Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Sun, 4 Jan 2026 14:13:09 +0800 Subject: [PATCH 2/9] =?UTF-8?q?add=20test:=20toBackend=E3=80=81item?= =?UTF-8?q?=E3=80=81data=E3=80=81meta=E3=80=81to=E3=80=81cpu?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/TensorTest.cpp | 214 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 214 insertions(+) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index 9a2c853..408a1e9 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -180,5 +180,219 @@ TEST_F(TensorTest, Transpose) { EXPECT_EQ(transposed.sizes()[2], 2); } +// 测试 toBackend +TEST_F(TensorTest, ToBackend) { + // 测试转换到 CPU backend + at::Tensor cpu_tensor = tensor.toBackend(c10::Backend::CPU); + EXPECT_TRUE(cpu_tensor.is_cpu()); + EXPECT_EQ(cpu_tensor.device().type(), c10::DeviceType::CPU); + EXPECT_EQ(cpu_tensor.numel(), tensor.numel()); + + // 测试多次调用 toBackend(CPU) - 应该返回相同的 tensor + at::Tensor cpu_tensor2 = cpu_tensor.toBackend(c10::Backend::CPU); + EXPECT_EQ(cpu_tensor.data_ptr(), cpu_tensor2.data_ptr()); + + // 验证数据内容 + EXPECT_FLOAT_EQ(cpu_tensor.data_ptr()[0], 1.0f); +} + +// 测试 item +TEST_F(TensorTest, Item) { + // 创建一个单元素 tensor + std::vector single_data = {3.14f}; + paddle::Tensor single_paddle_tensor(std::make_shared( + std::make_shared(single_data.data(), + single_data.size() * sizeof(float), + phi::CPUPlace{}), + phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1})))); + at::Tensor single_tensor(single_paddle_tensor); + + at::Scalar scalar_value = single_tensor.item(); + EXPECT_FLOAT_EQ(scalar_value.to(), 3.14f); + + // 测试多元素 tensor 应该抛出异常 + EXPECT_THROW(tensor.item(), std::exception); + + // 测试不同数据类型 - int32 + at::Tensor int_tensor = at::ones({1}, at::kInt); + at::Scalar int_scalar = int_tensor.item(); + EXPECT_EQ(int_scalar.to(), 1); + + // 测试不同数据类型 - int64 + at::Tensor long_tensor = at::ones({1}, at::kLong); + at::Scalar long_scalar = long_tensor.item(); + EXPECT_EQ(long_scalar.to(), 1); + + // 测试不同数据类型 - double + at::Tensor double_tensor = at::ones({1}, at::kDouble); + at::Scalar double_scalar = double_tensor.item(); + EXPECT_DOUBLE_EQ(double_scalar.to(), 1.0); + + // 测试不同数据类型 - bool + at::Tensor bool_tensor = at::ones({1}, at::kBool); + at::Scalar bool_scalar = bool_tensor.item(); + EXPECT_TRUE(bool_scalar.to()); + + // 测试更多数据类型 - int32 自定义值 + std::vector int32_data = {42}; + paddle::Tensor int32_paddle_tensor(std::make_shared( + std::make_shared(int32_data.data(), + int32_data.size() * sizeof(int32_t), + phi::CPUPlace{}), + phi::DenseTensorMeta(phi::DataType::INT32, phi::make_ddim({1})))); + at::Tensor int32_tensor(int32_paddle_tensor); + EXPECT_EQ(int32_tensor.item().to(), 42); + + // 测试更多数据类型 - int64 大数值 + std::vector int64_data = {123456789L}; + paddle::Tensor int64_paddle_tensor(std::make_shared( + std::make_shared(int64_data.data(), + int64_data.size() * sizeof(int64_t), + phi::CPUPlace{}), + phi::DenseTensorMeta(phi::DataType::INT64, phi::make_ddim({1})))); + at::Tensor int64_tensor(int64_paddle_tensor); + EXPECT_EQ(int64_tensor.item().to(), 123456789L); + + // 测试更多数据类型 - float64 + std::vector float64_data = {2.71828}; + paddle::Tensor float64_paddle_tensor(std::make_shared( + std::make_shared(float64_data.data(), + float64_data.size() * sizeof(double), + phi::CPUPlace{}), + phi::DenseTensorMeta(phi::DataType::FLOAT64, phi::make_ddim({1})))); + at::Tensor float64_tensor(float64_paddle_tensor); + EXPECT_DOUBLE_EQ(float64_tensor.item().to(), 2.71828); + + // 测试更多数据类型 - bool false + bool bool_false_data = false; + paddle::Tensor bool_false_paddle_tensor(std::make_shared( + std::make_shared( + &bool_false_data, sizeof(bool), phi::CPUPlace{}), + phi::DenseTensorMeta(phi::DataType::BOOL, phi::make_ddim({1})))); + at::Tensor bool_false_tensor(bool_false_paddle_tensor); + EXPECT_FALSE(bool_false_tensor.item().to()); + + // 测试多元素 tensor 二维 + at::Tensor multi_elem_2d = at::ones({2, 1}, at::kFloat); + EXPECT_THROW(multi_elem_2d.item(), std::exception); +} + +// 测试 data 方法 +TEST_F(TensorTest, Data) { + // Tensor tensor(paddle_tensor_); + + void* float_data = tensor.data_ptr(); + EXPECT_NE(float_data, nullptr); + + // 验证数据内容 + float* data_as_float = static_cast(float_data); + EXPECT_FLOAT_EQ(data_as_float[0], 1.0f); + + // 测试不同类型的 tensor + at::Tensor int_tensor = at::ones({2, 3}, at::kInt); + void* int_data = int_tensor.data_ptr(); + EXPECT_NE(int_data, nullptr); + + int* data_as_int = static_cast(int_data); + EXPECT_EQ(data_as_int[0], 1); +} + +// 测试 meta 方法 +TEST_F(TensorTest, Meta) { + // Tensor tensor(paddle_tensor_); + + // meta() 应该抛出异常，因为 Paddle 不支持 + EXPECT_THROW(tensor.meta(), std::exception); +} + +// 测试 to 方法 (TensorOptions 版本) +TEST_F(TensorTest, ToWithOptions) { + // Tensor tensor(paddle_tensor_); + + // 测试转换到不同的数据类型 + at::Tensor double_tensor = tensor.to(at::TensorOptions().dtype(at::kDouble)); + EXPECT_EQ(double_tensor.dtype(), at::kDouble); + EXPECT_EQ(double_tensor.numel(), tensor.numel()); + + // 测试 copy 参数 + at::Tensor copied_tensor = + tensor.to(at::TensorOptions().dtype(at::kFloat), false, true); + EXPECT_EQ(copied_tensor.dtype(), at::kFloat); + EXPECT_EQ(copied_tensor.numel(), tensor.numel()); + // 验证是复制而不是引用 + EXPECT_NE(copied_tensor.data_ptr(), tensor.data_ptr()); +} + +// 测试 to 方法 (ScalarType 版本) +TEST_F(TensorTest, ToWithScalarType) { + // Tensor tensor(paddle_tensor_); + + // 测试转换到 double + at::Tensor double_tensor = tensor.to(at::kDouble); + EXPECT_EQ(double_tensor.dtype(), at::kDouble); + EXPECT_EQ(double_tensor.numel(), tensor.numel()); + + // 测试转换到 int + at::Tensor int_tensor = tensor.to(at::kInt); + EXPECT_EQ(int_tensor.dtype(), at::kInt); + EXPECT_EQ(int_tensor.numel(), tensor.numel()); + + // 测试转换到 long + at::Tensor long_tensor = tensor.to(at::kLong); + EXPECT_EQ(long_tensor.dtype(), at::kLong); + EXPECT_EQ(long_tensor.numel(), tensor.numel()); + + // 验证数据内容 (float 1.0 -> int 1) + int_tensor.fill_(5.7); // 5.7 should be truncated to 5 + int* int_data = int_tensor.data_ptr(); + EXPECT_EQ(int_data[0], 5); +} + +// 测试 toBackend 行为 +TEST_F(TensorTest, ToBackendBehavior) { + // Tensor tensor(paddle_tensor_); + + // toBackend 总是会复制 tensor（当前实现） + at::Tensor cpu_tensor1 = tensor.toBackend(c10::Backend::CPU); + at::Tensor cpu_tensor2 = cpu_tensor1.toBackend(c10::Backend::CPU); + + // 验证都在 CPU 上 + EXPECT_TRUE(cpu_tensor1.is_cpu()); + EXPECT_TRUE(cpu_tensor2.is_cpu()); + EXPECT_EQ(cpu_tensor1.device().type(), c10::DeviceType::CPU); + EXPECT_EQ(cpu_tensor2.device().type(), c10::DeviceType::CPU); + + // 验证数据内容相同（即使是不同的副本） + EXPECT_FLOAT_EQ(cpu_tensor1.data_ptr()[0], 1.0f); + EXPECT_FLOAT_EQ(cpu_tensor2.data_ptr()[0], 1.0f); + + // 验证形状和元素数量相同 + EXPECT_EQ(cpu_tensor1.numel(), tensor.numel()); + EXPECT_EQ(cpu_tensor2.numel(), tensor.numel()); +} + +// 测试 cpu 行为 +TEST_F(TensorTest, CpuBehavior) { + // Tensor tensor(paddle_tensor_); + + // 第一次调用 cpu() + at::Tensor cpu_tensor1 = tensor.cpu(); + EXPECT_TRUE(cpu_tensor1.is_cpu()); + EXPECT_EQ(cpu_tensor1.device().type(), c10::DeviceType::CPU); + + // 再次调用 cpu()，当前实现会创建新的副本 + at::Tensor cpu_tensor2 = cpu_tensor1.cpu(); + EXPECT_TRUE(cpu_tensor2.is_cpu()); + + // 验证数据内容 + EXPECT_FLOAT_EQ(cpu_tensor1.data_ptr()[0], 1.0f); + EXPECT_FLOAT_EQ(cpu_tensor2.data_ptr()[0], 1.0f); + + // 验证是有效的 tensor + EXPECT_EQ(cpu_tensor1.numel(), tensor.numel()); + EXPECT_EQ(cpu_tensor2.numel(), tensor.numel()); + EXPECT_EQ(cpu_tensor1.dim(), tensor.dim()); +} + } // namespace test } // namespace at From b9425cf523a14214270dcf9adcb1a4c0bfdce39e Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Tue, 20 Jan 2026 09:28:46 +0800 Subject: [PATCH 3/9] add test --- test/TensorTest.cpp | 168 ++++++++++++++++++++------------------------ 1 file changed, 77 insertions(+), 91 deletions(-) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index 408a1e9..77f55f7 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -2,9 +2,22 @@ #include #include #include +#if !USE_PADDLE_API #include +#endif #include +#if USE_PADDLE_API +#include "paddle/phi/api/include/tensor.h" +#include "paddle/phi/common/place.h" +#include "paddle/phi/core/dense_tensor.h" +#include "paddle/phi/core/memory/malloc.h" +namespace phi { +inline std::ostream& operator<<(std::ostream& os, AllocationType type) { + return os << static_cast(type); +} +} // namespace phi +#endif namespace at { namespace test { @@ -188,95 +201,16 @@ TEST_F(TensorTest, ToBackend) { EXPECT_EQ(cpu_tensor.device().type(), c10::DeviceType::CPU); EXPECT_EQ(cpu_tensor.numel(), tensor.numel()); - // 测试多次调用 toBackend(CPU) - 应该返回相同的 tensor + // 测试多次调用 toBackend(CPU) - 当前实现会创建新的副本 at::Tensor cpu_tensor2 = cpu_tensor.toBackend(c10::Backend::CPU); - EXPECT_EQ(cpu_tensor.data_ptr(), cpu_tensor2.data_ptr()); + // 验证都在 CPU 上且数据内容相同 + EXPECT_TRUE(cpu_tensor2.is_cpu()); + EXPECT_FLOAT_EQ(cpu_tensor2.data_ptr()[0], 1.0f); // 验证数据内容 EXPECT_FLOAT_EQ(cpu_tensor.data_ptr()[0], 1.0f); } -// 测试 item -TEST_F(TensorTest, Item) { - // 创建一个单元素 tensor - std::vector single_data = {3.14f}; - paddle::Tensor single_paddle_tensor(std::make_shared( - std::make_shared(single_data.data(), - single_data.size() * sizeof(float), - phi::CPUPlace{}), - phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1})))); - at::Tensor single_tensor(single_paddle_tensor); - - at::Scalar scalar_value = single_tensor.item(); - EXPECT_FLOAT_EQ(scalar_value.to(), 3.14f); - - // 测试多元素 tensor 应该抛出异常 - EXPECT_THROW(tensor.item(), std::exception); - - // 测试不同数据类型 - int32 - at::Tensor int_tensor = at::ones({1}, at::kInt); - at::Scalar int_scalar = int_tensor.item(); - EXPECT_EQ(int_scalar.to(), 1); - - // 测试不同数据类型 - int64 - at::Tensor long_tensor = at::ones({1}, at::kLong); - at::Scalar long_scalar = long_tensor.item(); - EXPECT_EQ(long_scalar.to(), 1); - - // 测试不同数据类型 - double - at::Tensor double_tensor = at::ones({1}, at::kDouble); - at::Scalar double_scalar = double_tensor.item(); - EXPECT_DOUBLE_EQ(double_scalar.to(), 1.0); - - // 测试不同数据类型 - bool - at::Tensor bool_tensor = at::ones({1}, at::kBool); - at::Scalar bool_scalar = bool_tensor.item(); - EXPECT_TRUE(bool_scalar.to()); - - // 测试更多数据类型 - int32 自定义值 - std::vector int32_data = {42}; - paddle::Tensor int32_paddle_tensor(std::make_shared( - std::make_shared(int32_data.data(), - int32_data.size() * sizeof(int32_t), - phi::CPUPlace{}), - phi::DenseTensorMeta(phi::DataType::INT32, phi::make_ddim({1})))); - at::Tensor int32_tensor(int32_paddle_tensor); - EXPECT_EQ(int32_tensor.item().to(), 42); - - // 测试更多数据类型 - int64 大数值 - std::vector int64_data = {123456789L}; - paddle::Tensor int64_paddle_tensor(std::make_shared( - std::make_shared(int64_data.data(), - int64_data.size() * sizeof(int64_t), - phi::CPUPlace{}), - phi::DenseTensorMeta(phi::DataType::INT64, phi::make_ddim({1})))); - at::Tensor int64_tensor(int64_paddle_tensor); - EXPECT_EQ(int64_tensor.item().to(), 123456789L); - - // 测试更多数据类型 - float64 - std::vector float64_data = {2.71828}; - paddle::Tensor float64_paddle_tensor(std::make_shared( - std::make_shared(float64_data.data(), - float64_data.size() * sizeof(double), - phi::CPUPlace{}), - phi::DenseTensorMeta(phi::DataType::FLOAT64, phi::make_ddim({1})))); - at::Tensor float64_tensor(float64_paddle_tensor); - EXPECT_DOUBLE_EQ(float64_tensor.item().to(), 2.71828); - - // 测试更多数据类型 - bool false - bool bool_false_data = false; - paddle::Tensor bool_false_paddle_tensor(std::make_shared( - std::make_shared( - &bool_false_data, sizeof(bool), phi::CPUPlace{}), - phi::DenseTensorMeta(phi::DataType::BOOL, phi::make_ddim({1})))); - at::Tensor bool_false_tensor(bool_false_paddle_tensor); - EXPECT_FALSE(bool_false_tensor.item().to()); - - // 测试多元素 tensor 二维 - at::Tensor multi_elem_2d = at::ones({2, 1}, at::kFloat); - EXPECT_THROW(multi_elem_2d.item(), std::exception); -} - // 测试 data 方法 TEST_F(TensorTest, Data) { // Tensor tensor(paddle_tensor_); @@ -297,14 +231,6 @@ TEST_F(TensorTest, Data) { EXPECT_EQ(data_as_int[0], 1); } -// 测试 meta 方法 -TEST_F(TensorTest, Meta) { - // Tensor tensor(paddle_tensor_); - - // meta() 应该抛出异常，因为 Paddle 不支持 - EXPECT_THROW(tensor.meta(), std::exception); -} - // 测试 to 方法 (TensorOptions 版本) TEST_F(TensorTest, ToWithOptions) { // Tensor tensor(paddle_tensor_); @@ -394,5 +320,65 @@ TEST_F(TensorTest, CpuBehavior) { EXPECT_EQ(cpu_tensor1.dim(), tensor.dim()); } +// 测试 cuda 方法 +TEST_F(TensorTest, Cuda) { + try { + at::Tensor cuda_tensor = tensor.cuda(); + + EXPECT_TRUE(cuda_tensor.is_cuda()); + EXPECT_EQ(cuda_tensor.device().type(), c10::DeviceType::CUDA); + EXPECT_EQ(cuda_tensor.numel(), tensor.numel()); + + at::Tensor cpu_check = cuda_tensor.cpu(); + EXPECT_FLOAT_EQ(cpu_check.data_ptr()[0], 1.0f); + + at::Tensor cuda_tensor2 = cuda_tensor.cuda(); + EXPECT_TRUE(cuda_tensor2.is_cuda()); + EXPECT_EQ(cuda_tensor2.device().type(), c10::DeviceType::CUDA); + EXPECT_EQ(cuda_tensor2.numel(), cuda_tensor.numel()); + } catch (const std::exception& e) { + GTEST_SKIP() << "CUDA not available: " << e.what(); + } catch (...) { + GTEST_SKIP() << "CUDA test failed with unknown error"; + } +} + +// 测试 is_pinned 方法 +TEST_F(TensorTest, IsPinned) { + EXPECT_FALSE(tensor.is_pinned()); + +#ifdef PADDLE_WITH_CUDA + + at::Tensor pinned_tensor = tensor.pin_memory(); + EXPECT_TRUE(pinned_tensor.is_pinned()); + + at::Tensor cuda_tensor = tensor.cuda(); + EXPECT_FALSE(cuda_tensor.is_pinned()); +#endif +} + +// 测试 pin_memory 方法 +TEST_F(TensorTest, PinMemory) { + try { + at::Tensor pinned_tensor = tensor.pin_memory(); + EXPECT_TRUE(pinned_tensor.is_pinned()); + EXPECT_FALSE(pinned_tensor.is_cuda()); + EXPECT_EQ(pinned_tensor.numel(), tensor.numel()); + + EXPECT_FLOAT_EQ(pinned_tensor.data_ptr()[0], 1.0f); + + at::Tensor pinned_tensor2 = pinned_tensor.pin_memory(); + EXPECT_TRUE(pinned_tensor2.is_pinned()); + + try { + at::Tensor cuda_tensor = tensor.cuda(); + } catch (...) { + // CUDA 不可用时跳过此测试 + } + } catch (const std::exception& e) { + GTEST_SKIP() << "Pinned memory not available: " << e.what(); + } +} + } // namespace test } // namespace at From 4db69fcbd1e6f0d4dcc1f63f5133a317d7c86407 Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Mon, 2 Feb 2026 21:18:24 +0800 Subject: [PATCH 4/9] add test --- test/TensorTest.cpp | 222 ++++++++++---------------------------------- 1 file changed, 49 insertions(+), 173 deletions(-) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index cb7e8cb..73e22c8 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -236,191 +236,67 @@ TEST_F(TensorTest, Transpose) { file.saveFile(); } -// 测试 toBackend -TEST_F(TensorTest, ToBackend) { - // 测试转换到 CPU backend - at::Tensor cpu_tensor = tensor.toBackend(c10::Backend::CPU); - EXPECT_TRUE(cpu_tensor.is_cpu()); - EXPECT_EQ(cpu_tensor.device().type(), c10::DeviceType::CPU); - EXPECT_EQ(cpu_tensor.numel(), tensor.numel()); - - // 测试多次调用 toBackend(CPU) - 当前实现会创建新的副本 - at::Tensor cpu_tensor2 = cpu_tensor.toBackend(c10::Backend::CPU); - // 验证都在 CPU 上且数据内容相同 - EXPECT_TRUE(cpu_tensor2.is_cpu()); - EXPECT_FLOAT_EQ(cpu_tensor2.data_ptr()[0], 1.0f); - - // 验证数据内容 - EXPECT_FLOAT_EQ(cpu_tensor.data_ptr()[0], 1.0f); -} - -// 测试 data 方法 -TEST_F(TensorTest, Data) { - // Tensor tensor(paddle_tensor_); - - void* float_data = tensor.data_ptr(); - EXPECT_NE(float_data, nullptr); - - // 验证数据内容 - float* data_as_float = static_cast(float_data); - EXPECT_FLOAT_EQ(data_as_float[0], 1.0f); - - // 测试不同类型的 tensor - at::Tensor int_tensor = at::ones({2, 3}, at::kInt); - void* int_data = int_tensor.data_ptr(); - EXPECT_NE(int_data, nullptr); - - int* data_as_int = static_cast(int_data); - EXPECT_EQ(data_as_int[0], 1); -} - -// 测试 to 方法 (TensorOptions 版本) -TEST_F(TensorTest, ToWithOptions) { - // Tensor tensor(paddle_tensor_); - - // 测试转换到不同的数据类型 - at::Tensor double_tensor = tensor.to(at::TensorOptions().dtype(at::kDouble)); - EXPECT_EQ(double_tensor.dtype(), at::kDouble); - EXPECT_EQ(double_tensor.numel(), tensor.numel()); - - // 测试 copy 参数 - at::Tensor copied_tensor = - tensor.to(at::TensorOptions().dtype(at::kFloat), false, true); - EXPECT_EQ(copied_tensor.dtype(), at::kFloat); - EXPECT_EQ(copied_tensor.numel(), tensor.numel()); - // 验证是复制而不是引用 - EXPECT_NE(copied_tensor.data_ptr(), tensor.data_ptr()); -} - -// 测试 to 方法 (ScalarType 版本) -TEST_F(TensorTest, ToWithScalarType) { - // Tensor tensor(paddle_tensor_); - - // 测试转换到 double - at::Tensor double_tensor = tensor.to(at::kDouble); - EXPECT_EQ(double_tensor.dtype(), at::kDouble); - EXPECT_EQ(double_tensor.numel(), tensor.numel()); - - // 测试转换到 int - at::Tensor int_tensor = tensor.to(at::kInt); - EXPECT_EQ(int_tensor.dtype(), at::kInt); - EXPECT_EQ(int_tensor.numel(), tensor.numel()); - - // 测试转换到 long - at::Tensor long_tensor = tensor.to(at::kLong); - EXPECT_EQ(long_tensor.dtype(), at::kLong); - EXPECT_EQ(long_tensor.numel(), tensor.numel()); - - // 验证数据内容 (float 1.0 -> int 1) - int_tensor.fill_(5.7); // 5.7 should be truncated to 5 - int* int_data = int_tensor.data_ptr(); - EXPECT_EQ(int_data[0], 5); -} - -// 测试 toBackend 行为 -TEST_F(TensorTest, ToBackendBehavior) { - // Tensor tensor(paddle_tensor_); - - // toBackend 总是会复制 tensor（当前实现） - at::Tensor cpu_tensor1 = tensor.toBackend(c10::Backend::CPU); - at::Tensor cpu_tensor2 = cpu_tensor1.toBackend(c10::Backend::CPU); - - // 验证都在 CPU 上 - EXPECT_TRUE(cpu_tensor1.is_cpu()); - EXPECT_TRUE(cpu_tensor2.is_cpu()); - EXPECT_EQ(cpu_tensor1.device().type(), c10::DeviceType::CPU); - EXPECT_EQ(cpu_tensor2.device().type(), c10::DeviceType::CPU); - - // 验证数据内容相同（即使是不同的副本） - EXPECT_FLOAT_EQ(cpu_tensor1.data_ptr()[0], 1.0f); - EXPECT_FLOAT_EQ(cpu_tensor2.data_ptr()[0], 1.0f); - - // 验证形状和元素数量相同 - EXPECT_EQ(cpu_tensor1.numel(), tensor.numel()); - EXPECT_EQ(cpu_tensor2.numel(), tensor.numel()); -} - -// 测试 cpu 行为 -TEST_F(TensorTest, CpuBehavior) { - // Tensor tensor(paddle_tensor_); - - // 第一次调用 cpu() - at::Tensor cpu_tensor1 = tensor.cpu(); - EXPECT_TRUE(cpu_tensor1.is_cpu()); - EXPECT_EQ(cpu_tensor1.device().type(), c10::DeviceType::CPU); - - // 再次调用 cpu()，当前实现会创建新的副本 - at::Tensor cpu_tensor2 = cpu_tensor1.cpu(); - EXPECT_TRUE(cpu_tensor2.is_cpu()); - - // 验证数据内容 - EXPECT_FLOAT_EQ(cpu_tensor1.data_ptr()[0], 1.0f); - EXPECT_FLOAT_EQ(cpu_tensor2.data_ptr()[0], 1.0f); - - // 验证是有效的 tensor - EXPECT_EQ(cpu_tensor1.numel(), tensor.numel()); - EXPECT_EQ(cpu_tensor2.numel(), tensor.numel()); - EXPECT_EQ(cpu_tensor1.dim(), tensor.dim()); +// 返回当前用例的结果文件名（用于逐个用例对比） +static std::string GetTestCaseResultFileName() { + std::string base = g_custom_param.get(); + std::string test_name = + ::testing::UnitTest::GetInstance()->current_test_info()->name(); + if (base.size() >= 4 && base.substr(base.size() - 4) == ".txt") { + base.resize(base.size() - 4); + } + return base + "_" + test_name + ".txt"; } -// 测试 cuda 方法 -TEST_F(TensorTest, Cuda) { +// 测试 cuda +TEST_F(TensorTest, CudaResult) { + FileManerger file(GetTestCaseResultFileName()); + file.createFile(); try { at::Tensor cuda_tensor = tensor.cuda(); - - EXPECT_TRUE(cuda_tensor.is_cuda()); - EXPECT_EQ(cuda_tensor.device().type(), c10::DeviceType::CUDA); - EXPECT_EQ(cuda_tensor.numel(), tensor.numel()); - - at::Tensor cpu_check = cuda_tensor.cpu(); - EXPECT_FLOAT_EQ(cpu_check.data_ptr()[0], 1.0f); - - at::Tensor cuda_tensor2 = cuda_tensor.cuda(); - EXPECT_TRUE(cuda_tensor2.is_cuda()); - EXPECT_EQ(cuda_tensor2.device().type(), c10::DeviceType::CUDA); - EXPECT_EQ(cuda_tensor2.numel(), cuda_tensor.numel()); - } catch (const std::exception& e) { - GTEST_SKIP() << "CUDA not available: " << e.what(); + file << "1 "; + file << std::to_string(static_cast(cuda_tensor.device().type())) + << " "; + file << std::to_string(cuda_tensor.is_cuda() ? 1 : 0) << " "; + file << std::to_string(cuda_tensor.numel()) << " "; + } catch (const std::exception&) { + file << "0 "; } catch (...) { - GTEST_SKIP() << "CUDA test failed with unknown error"; + file << "0 "; } + file.saveFile(); } -// 测试 is_pinned 方法 -TEST_F(TensorTest, IsPinned) { - EXPECT_FALSE(tensor.is_pinned()); - -#ifdef PADDLE_WITH_CUDA - - at::Tensor pinned_tensor = tensor.pin_memory(); - EXPECT_TRUE(pinned_tensor.is_pinned()); - - at::Tensor cuda_tensor = tensor.cuda(); - EXPECT_FALSE(cuda_tensor.is_pinned()); -#endif +// 测试 is_pinned +TEST_F(TensorTest, IsPinnedResult) { + FileManerger file(GetTestCaseResultFileName()); + file.createFile(); + file << std::to_string(tensor.is_pinned() ? 1 : 0) << " "; + int pinned_after_cuda = 0; + try { + at::Tensor cuda_tensor = tensor.cuda(); + at::Tensor pinned_tensor = cuda_tensor.pin_memory(); + pinned_after_cuda = pinned_tensor.is_pinned() ? 1 : 0; + } catch (...) { + pinned_after_cuda = 0; + } + file << std::to_string(pinned_after_cuda) << " "; + file.saveFile(); } -// 测试 pin_memory 方法 -TEST_F(TensorTest, PinMemory) { +// 测试 pin_memory +TEST_F(TensorTest, PinMemoryResult) { + FileManerger file(GetTestCaseResultFileName()); + file.createFile(); + int gpu_pin_ok = 0; try { - at::Tensor pinned_tensor = tensor.pin_memory(); - EXPECT_TRUE(pinned_tensor.is_pinned()); - EXPECT_FALSE(pinned_tensor.is_cuda()); - EXPECT_EQ(pinned_tensor.numel(), tensor.numel()); - - EXPECT_FLOAT_EQ(pinned_tensor.data_ptr()[0], 1.0f); - - at::Tensor pinned_tensor2 = pinned_tensor.pin_memory(); - EXPECT_TRUE(pinned_tensor2.is_pinned()); - - try { - at::Tensor cuda_tensor = tensor.cuda(); - } catch (...) { - // CUDA 不可用时跳过此测试 - } - } catch (const std::exception& e) { - GTEST_SKIP() << "Pinned memory not available: " << e.what(); + at::Tensor cuda_tensor = tensor.cuda(); + at::Tensor pinned_tensor = cuda_tensor.pin_memory(); + gpu_pin_ok = pinned_tensor.is_pinned() ? 1 : 0; + } catch (...) { + gpu_pin_ok = 0; } + file << std::to_string(gpu_pin_ok) << " "; + file.saveFile(); } } // namespace test From 6007b1d54fc84b3ca2759f9f7e6a8cd8c7c74612 Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Mon, 2 Feb 2026 21:23:43 +0800 Subject: [PATCH 5/9] delete history error --- test/TensorTest.cpp | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index 73e22c8..57c8072 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -194,16 +194,6 @@ TEST_F(TensorTest, IsCpu) { file.saveFile(); } -// 测试 cpu -TEST_F(TensorTest, Cpu) { - at::Tensor cpu_tensor = tensor.cpu(); - - EXPECT_TRUE(cpu_tensor.is_cpu()); - EXPECT_EQ(cpu_tensor.device().type(), c10::DeviceType::CPU); - EXPECT_EQ(cpu_tensor.numel(), tensor.numel()); - EXPECT_FLOAT_EQ(cpu_tensor.data_ptr()[0], tensor.data_ptr()[0]); -} - // 测试 is_cuda (在 CPU tensor 上应该返回 false) TEST_F(TensorTest, IsCuda) { auto file_name = g_custom_param.get(); From 2f945f736ac092d03ffac460491f788cc5f3ebcd Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Fri, 6 Feb 2026 14:01:14 +0800 Subject: [PATCH 6/9] fix --- test/TensorTest.cpp | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index 57c8072..c8db45a 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -1,6 +1,4 @@ #include -#include -#include #include #if !USE_PADDLE_API #include @@ -8,17 +6,6 @@ #include #include -#if USE_PADDLE_API -#include "paddle/phi/api/include/tensor.h" -#include "paddle/phi/common/place.h" -#include "paddle/phi/core/dense_tensor.h" -#include "paddle/phi/core/memory/malloc.h" -namespace phi { -inline std::ostream& operator<<(std::ostream& os, AllocationType type) { - return os << static_cast(type); -} -} // namespace phi -#endif #include "../src/file_manager.h" From dc50cef2682a8780549eb301e0579d30b1429ea6 Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Fri, 6 Feb 2026 14:10:39 +0800 Subject: [PATCH 7/9] fix --- test/TensorTest.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index c8db45a..a49b3f2 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -1,8 +1,6 @@ #include #include -#if !USE_PADDLE_API #include -#endif #include #include From 464e4cb07f0b50988fc13ca154da9edbd7e1aa5d Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Fri, 6 Feb 2026 14:20:01 +0800 Subject: [PATCH 8/9] fix --- test/TensorTest.cpp | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index a61ece7..b76a79d 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -1,4 +1,6 @@ #include +#include +#include #include #include @@ -272,21 +274,22 @@ TEST_F(TensorTest, PinMemoryResult) { } file << std::to_string(gpu_pin_ok) << " "; file.saveFile(); -// 测试 sym_size -TEST_F(TensorTest, SymSize) { - // 获取符号化的单个维度大小 - c10::SymInt sym_size_0 = tensor.sym_size(0); - c10::SymInt sym_size_1 = tensor.sym_size(1); - c10::SymInt sym_size_2 = tensor.sym_size(2); - - // 验证符号化大小与实际大小一致 - EXPECT_EQ(sym_size_0, 2); - EXPECT_EQ(sym_size_1, 3); - EXPECT_EQ(sym_size_2, 4); - - // 测试负索引 - c10::SymInt sym_size_neg1 = tensor.sym_size(-1); - EXPECT_EQ(sym_size_neg1, 4); + // 测试 sym_size + TEST_F(TensorTest, SymSize) { + // 获取符号化的单个维度大小 + c10::SymInt sym_size_0 = tensor.sym_size(0); + c10::SymInt sym_size_1 = tensor.sym_size(1); + c10::SymInt sym_size_2 = tensor.sym_size(2); + + // 验证符号化大小与实际大小一致 + EXPECT_EQ(sym_size_0, 2); + EXPECT_EQ(sym_size_1, 3); + EXPECT_EQ(sym_size_2, 4); + + // 测试负索引 + c10::SymInt sym_size_neg1 = tensor.sym_size(-1); + EXPECT_EQ(sym_size_neg1, 4); + } } // 测试 sym_stride From 86267b43abd79b471ba33c68caf38f13d8c14742 Mon Sep 17 00:00:00 2001 From: Le-soleile <3516093767@qq.com> Date: Fri, 6 Feb 2026 14:45:14 +0800 Subject: [PATCH 9/9] fix --- test/TensorTest.cpp | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/test/TensorTest.cpp b/test/TensorTest.cpp index b76a79d..cb8fc44 100644 --- a/test/TensorTest.cpp +++ b/test/TensorTest.cpp @@ -292,6 +292,23 @@ TEST_F(TensorTest, PinMemoryResult) { } } +// 测试 sym_size +TEST_F(TensorTest, SymSize) { + // 获取符号化的单个维度大小 + c10::SymInt sym_size_0 = tensor.sym_size(0); + c10::SymInt sym_size_1 = tensor.sym_size(1); + c10::SymInt sym_size_2 = tensor.sym_size(2); + + // 验证符号化大小与实际大小一致 + EXPECT_EQ(sym_size_0, 2); + EXPECT_EQ(sym_size_1, 3); + EXPECT_EQ(sym_size_2, 4); + + // 测试负索引 + c10::SymInt sym_size_neg1 = tensor.sym_size(-1); + EXPECT_EQ(sym_size_neg1, 4); +} + // 测试 sym_stride TEST_F(TensorTest, SymStride) { // 获取符号化的单个维度步长