Rewrite C++ API tests in gtest (#11953)

Summary:
This PR is a large codemod to rewrite all C++ API tests with GoogleTest (gtest) instead of Catch.

You can largely trust me to have correctly code-modded the tests, so it's not required to review every of the 2000+ changed lines. However, additional things I changed were:

1. Moved the cmake parts for these tests into their own `CMakeLists.txt` under `test/cpp/api` and calling `add_subdirectory` from `torch/CMakeLists.txt`
2. Fixing DataParallel tests which weren't being compiled because `USE_CUDA` wasn't correctly being set at all.
3. Updated README

ezyang ebetica
Pull Request resolved: https://github.com/pytorch/pytorch/pull/11953

Differential Revision: D9998883

Pulled By: goldsborough

fbshipit-source-id: affe3f320b0ca63e7e0019926a59076bb943db80
This commit is contained in:
Peter Goldsborough
2018-09-21 21:12:37 -07:00
committed by Facebook Github Bot
parent d0db23e95a
commit 825181ea9d
27 changed files with 2154 additions and 2182 deletions
+98 -96
View File
@@ -1,4 +1,4 @@
#include "catch_utils.hpp"
#include <gtest/gtest.h>
#include <torch/tensor.h>
@@ -18,13 +18,15 @@ bool almost_equal(at::Tensor left, T right, T tolerance = 1e-4) {
return std::abs(at::_local_scalar(left).to<T>() - right) < tolerance;
}
#define REQUIRE_TENSOR_OPTIONS(device_, index_, type_, layout_) \
CATCH_REQUIRE(tensor.device().type() == at::Device((device_), (index_)).type()); \
CATCH_REQUIRE(tensor.device().index() == at::Device((device_), (index_)).index()); \
CATCH_REQUIRE(tensor.dtype() == (type_)); \
CATCH_REQUIRE(tensor.layout() == (layout_))
#define REQUIRE_TENSOR_OPTIONS(device_, index_, type_, layout_) \
ASSERT_TRUE( \
tensor.device().type() == at::Device((device_), (index_)).type()); \
ASSERT_TRUE( \
tensor.device().index() == at::Device((device_), (index_)).index()); \
ASSERT_EQ(tensor.dtype(), (type_)); \
ASSERT_TRUE(tensor.layout() == (layout_))
CATCH_TEST_CASE("Tensor/ToDtype") {
TEST(TensorTest, ToDtype) {
auto tensor = at::empty({3, 4});
REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
@@ -39,7 +41,7 @@ CATCH_TEST_CASE("Tensor/ToDtype") {
}
// Not currently supported.
// CATCH_TEST_CASE("Tensor/ToLayout") {
// TEST(TensorTest, ToLayout) {
// auto tensor = at::empty({3, 4});
// REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
//
@@ -50,144 +52,144 @@ CATCH_TEST_CASE("Tensor/ToDtype") {
// REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
// }
CATCH_TEST_CASE("Tensor/ToDevice", "[cuda]") {
auto tensor = at::empty({3, 4});
REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
// TEST(TensorTest, ToDevice ", "[cuda]) {
// auto tensor = at::empty({3, 4});
// REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
//
// tensor = tensor.to({at::kCUDA, 1});
// REQUIRE_TENSOR_OPTIONS(at::kCUDA, 1, at::kFloat, at::kStrided);
//
// tensor = tensor.to({at::kCUDA, 0});
// REQUIRE_TENSOR_OPTIONS(at::kCUDA, 0, at::kFloat, at::kStrided);
//
// tensor = tensor.to({at::kCUDA, 1});
// REQUIRE_TENSOR_OPTIONS(at::kCUDA, 1, at::kFloat, at::kStrided);
//
// tensor = tensor.to(at::Device(at::kCPU));
// REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
// }
//
// TEST(TensorTest, ToDeviceAndDtype ", "[cuda]) {
// auto tensor = at::empty({3, 4});
// REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
//
// tensor = tensor.to({at::kCUDA, 1}, at::kInt);
// REQUIRE_TENSOR_OPTIONS(at::kCUDA, 1, at::kInt, at::kStrided);
// }
tensor = tensor.to({at::kCUDA, 1});
REQUIRE_TENSOR_OPTIONS(at::kCUDA, 1, at::kFloat, at::kStrided);
tensor = tensor.to({at::kCUDA, 0});
REQUIRE_TENSOR_OPTIONS(at::kCUDA, 0, at::kFloat, at::kStrided);
tensor = tensor.to({at::kCUDA, 1});
REQUIRE_TENSOR_OPTIONS(at::kCUDA, 1, at::kFloat, at::kStrided);
tensor = tensor.to(at::Device(at::kCPU));
REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
}
CATCH_TEST_CASE("Tensor/ToDeviceAndDtype", "[cuda]") {
auto tensor = at::empty({3, 4});
REQUIRE_TENSOR_OPTIONS(at::kCPU, -1, at::kFloat, at::kStrided);
tensor = tensor.to({at::kCUDA, 1}, at::kInt);
REQUIRE_TENSOR_OPTIONS(at::kCUDA, 1, at::kInt, at::kStrided);
}
CATCH_TEST_CASE("Tensor/ToOptionsRespectsRequiresGrad") {
TEST(TensorTest, ToOptionsRespectsRequiresGrad) {
{
auto tensor = torch::empty({3, 4}, at::requires_grad());
CATCH_REQUIRE(tensor.requires_grad());
ASSERT_TRUE(tensor.requires_grad());
tensor = tensor.to(at::kDouble);
CATCH_REQUIRE(tensor.requires_grad());
ASSERT_TRUE(tensor.requires_grad());
}
{
auto tensor = torch::empty({3, 4});
CATCH_REQUIRE(!tensor.requires_grad());
ASSERT_FALSE(tensor.requires_grad());
tensor = tensor.to(at::kDouble);
CATCH_REQUIRE(!tensor.requires_grad());
ASSERT_FALSE(tensor.requires_grad());
}
}
CATCH_TEST_CASE("Tensor/ToDoesNotCopyWhenOptionsAreAllTheSame") {
TEST(TensorTest, ToDoesNotCopyWhenOptionsAreAllTheSame) {
auto tensor = at::empty({3, 4}, at::kFloat);
auto hopefully_not_copy = tensor.to(at::kFloat);
CATCH_REQUIRE(hopefully_not_copy.data<float>() == tensor.data<float>());
ASSERT_EQ(hopefully_not_copy.data<float>(), tensor.data<float>());
}
CATCH_TEST_CASE("Tensor/ContainsCorrectValueForSingleValue") {
TEST(TensorTest, ContainsCorrectValueForSingleValue) {
auto tensor = at::tensor(123);
CATCH_REQUIRE(tensor.numel() == 1);
CATCH_REQUIRE(tensor.dtype() == at::kInt);
CATCH_REQUIRE(tensor[0].toCInt() == 123);
ASSERT_EQ(tensor.numel(), 1);
ASSERT_EQ(tensor.dtype(), at::kInt);
ASSERT_EQ(tensor[0].toCInt(), 123);
tensor = at::tensor(123.456f);
CATCH_REQUIRE(tensor.numel() == 1);
CATCH_REQUIRE(tensor.dtype() == at::kFloat);
CATCH_REQUIRE(almost_equal(tensor[0], 123.456f));
ASSERT_EQ(tensor.numel(), 1);
ASSERT_EQ(tensor.dtype(), at::kFloat);
ASSERT_TRUE(almost_equal(tensor[0], 123.456f));
tensor = at::tensor(123.456);
CATCH_REQUIRE(tensor.numel() == 1);
CATCH_REQUIRE(tensor.dtype() == at::kDouble);
CATCH_REQUIRE(almost_equal(tensor[0], 123.456));
ASSERT_EQ(tensor.numel(), 1);
ASSERT_EQ(tensor.dtype(), at::kDouble);
ASSERT_TRUE(almost_equal(tensor[0], 123.456));
}
CATCH_TEST_CASE("Tensor/ContainsCorrectValuesForManyValues") {
TEST(TensorTest, ContainsCorrectValuesForManyValues) {
auto tensor = at::tensor({1, 2, 3});
CATCH_REQUIRE(tensor.numel() == 3);
CATCH_REQUIRE(tensor.dtype() == at::kInt);
CATCH_REQUIRE(exactly_equal(tensor[0], 1));
CATCH_REQUIRE(exactly_equal(tensor[1], 2));
CATCH_REQUIRE(exactly_equal(tensor[2], 3));
ASSERT_EQ(tensor.numel(), 3);
ASSERT_EQ(tensor.dtype(), at::kInt);
ASSERT_TRUE(exactly_equal(tensor[0], 1));
ASSERT_TRUE(exactly_equal(tensor[1], 2));
ASSERT_TRUE(exactly_equal(tensor[2], 3));
tensor = at::tensor({1.5, 2.25, 3.125});
CATCH_REQUIRE(tensor.numel() == 3);
CATCH_REQUIRE(tensor.dtype() == at::kDouble);
CATCH_REQUIRE(almost_equal(tensor[0], 1.5));
CATCH_REQUIRE(almost_equal(tensor[1], 2.25));
CATCH_REQUIRE(almost_equal(tensor[2], 3.125));
ASSERT_EQ(tensor.numel(), 3);
ASSERT_EQ(tensor.dtype(), at::kDouble);
ASSERT_TRUE(almost_equal(tensor[0], 1.5));
ASSERT_TRUE(almost_equal(tensor[1], 2.25));
ASSERT_TRUE(almost_equal(tensor[2], 3.125));
}
CATCH_TEST_CASE("Tensor/ContainsCorrectValuesForManyValuesVariable") {
TEST(TensorTest, ContainsCorrectValuesForManyValuesVariable) {
auto tensor = torch::tensor({1, 2, 3});
CATCH_REQUIRE(tensor.is_variable());
CATCH_REQUIRE(tensor.numel() == 3);
CATCH_REQUIRE(tensor.dtype() == at::kInt);
CATCH_REQUIRE(exactly_equal(tensor[0], 1));
CATCH_REQUIRE(exactly_equal(tensor[1], 2));
CATCH_REQUIRE(exactly_equal(tensor[2], 3));
ASSERT_TRUE(tensor.is_variable());
ASSERT_EQ(tensor.numel(), 3);
ASSERT_EQ(tensor.dtype(), at::kInt);
ASSERT_TRUE(exactly_equal(tensor[0], 1));
ASSERT_TRUE(exactly_equal(tensor[1], 2));
ASSERT_TRUE(exactly_equal(tensor[2], 3));
tensor = torch::tensor({1.5, 2.25, 3.125});
CATCH_REQUIRE(tensor.is_variable());
CATCH_REQUIRE(tensor.numel() == 3);
CATCH_REQUIRE(tensor.dtype() == at::kDouble);
CATCH_REQUIRE(almost_equal(tensor[0], 1.5));
CATCH_REQUIRE(almost_equal(tensor[1], 2.25));
CATCH_REQUIRE(almost_equal(tensor[2], 3.125));
ASSERT_TRUE(tensor.is_variable());
ASSERT_EQ(tensor.numel(), 3);
ASSERT_EQ(tensor.dtype(), at::kDouble);
ASSERT_TRUE(almost_equal(tensor[0], 1.5));
ASSERT_TRUE(almost_equal(tensor[1], 2.25));
ASSERT_TRUE(almost_equal(tensor[2], 3.125));
}
CATCH_TEST_CASE("Tensor/ContainsCorrectValuesWhenConstructedFromVector") {
TEST(TensorTest, ContainsCorrectValuesWhenConstructedFromVector) {
std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto tensor = at::tensor(v);
CATCH_REQUIRE(tensor.numel() == v.size());
CATCH_REQUIRE(tensor.dtype() == at::kInt);
ASSERT_EQ(tensor.numel(), v.size());
ASSERT_EQ(tensor.dtype(), at::kInt);
for (size_t i = 0; i < v.size(); ++i) {
CATCH_REQUIRE(exactly_equal(tensor[i], v.at(i)));
ASSERT_TRUE(exactly_equal(tensor[i], v.at(i)));
}
std::vector<float> w = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0};
tensor = at::tensor(w);
CATCH_REQUIRE(tensor.numel() == w.size());
CATCH_REQUIRE(tensor.dtype() == at::kFloat);
ASSERT_EQ(tensor.numel(), w.size());
ASSERT_EQ(tensor.dtype(), at::kFloat);
for (size_t i = 0; i < w.size(); ++i) {
CATCH_REQUIRE(almost_equal(tensor[i], w.at(i)));
ASSERT_TRUE(almost_equal(tensor[i], w.at(i)));
}
}
CATCH_TEST_CASE("Tensor/UsesOptionsThatAreSupplied") {
TEST(TensorTest, UsesOptionsThatAreSupplied) {
auto tensor = at::tensor(123, dtype(at::kFloat)) + 0.5;
CATCH_REQUIRE(tensor.numel() == 1);
CATCH_REQUIRE(tensor.dtype() == at::kFloat);
CATCH_REQUIRE(almost_equal(tensor[0], 123.5));
ASSERT_EQ(tensor.numel(), 1);
ASSERT_EQ(tensor.dtype(), at::kFloat);
ASSERT_TRUE(almost_equal(tensor[0], 123.5));
tensor = at::tensor({1.1, 2.2, 3.3}, dtype(at::kInt));
CATCH_REQUIRE(tensor.numel() == 3);
CATCH_REQUIRE(tensor.dtype() == at::kInt);
CATCH_REQUIRE(tensor.layout() == at::kStrided);
CATCH_REQUIRE(exactly_equal(tensor[0], 1));
CATCH_REQUIRE(exactly_equal(tensor[1], 2));
CATCH_REQUIRE(exactly_equal(tensor[2], 3));
ASSERT_EQ(tensor.numel(), 3);
ASSERT_EQ(tensor.dtype(), at::kInt);
ASSERT_EQ(tensor.layout(), at::kStrided);
ASSERT_TRUE(exactly_equal(tensor[0], 1));
ASSERT_TRUE(exactly_equal(tensor[1], 2));
ASSERT_TRUE(exactly_equal(tensor[2], 3));
}
CATCH_TEST_CASE("FromBlob") {
TEST(TensorTest, FromBlob) {
std::vector<int32_t> v = {1, 2, 3};
auto tensor = torch::from_blob(v.data(), v.size(), torch::kInt32);
CATCH_REQUIRE(tensor.is_variable());
CATCH_REQUIRE(tensor.numel() == 3);
CATCH_REQUIRE(tensor[0].toCInt() == 1);
CATCH_REQUIRE(tensor[1].toCInt() == 2);
CATCH_REQUIRE(tensor[2].toCInt() == 3);
ASSERT_TRUE(tensor.is_variable());
ASSERT_EQ(tensor.numel(), 3);
ASSERT_EQ(tensor[0].toCInt(), 1);
ASSERT_EQ(tensor[1].toCInt(), 2);
ASSERT_EQ(tensor[2].toCInt(), 3);
}