You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
465 lines
16 KiB
465 lines
16 KiB
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
|
|
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. */
|
|
|
|
#include <array>
|
|
#include <iostream>
|
|
#include <list>
|
|
#include <memory>
|
|
#include <set>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "paddle/fluid/framework/type_defs.h"
|
|
#include "paddle/fluid/platform/enforce.h"
|
|
|
|
TEST(ENFORCE, OK) {
|
|
PADDLE_ENFORCE(true, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE is ok %d now %f.", 123, 0.345));
|
|
size_t val = 1;
|
|
const size_t limit = 10;
|
|
PADDLE_ENFORCE(val < limit, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE tests failed."));
|
|
}
|
|
|
|
TEST(ENFORCE, FAILED) {
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE(false, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE won't work %d at all.", 123));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("PADDLE_ENFORCE won't work 123 at all.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
|
|
caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE(false, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE won't work at all."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("PADDLE_ENFORCE won't work at all.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
|
|
caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE(false, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE won't work at all."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
EXPECT_NE(std::string(error.what()).find(" at "), 0UL);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE, NO_ARG_OK) {
|
|
int a = 2;
|
|
int b = 2;
|
|
PADDLE_ENFORCE_EQ(a, b, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_EQ tests failed."));
|
|
// test enforce with extra message.
|
|
PADDLE_ENFORCE_EQ(a, b, paddle::platform::errors::Unavailable(
|
|
"Some %s wrong in PADDLE_ENFORCE_EQ.", "info"));
|
|
}
|
|
|
|
TEST(ENFORCE_EQ, NO_EXTRA_MSG_FAIL) {
|
|
int a = 2;
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_EQ(a, 1 + 3, paddle::platform::errors::InvalidArgument(
|
|
"The result is not equal correct result."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("Expected a == 1 + 3, but received a:2 != 1 "
|
|
"+ 3:4.") != std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_EQ, EXTRA_MSG_FAIL) {
|
|
int a = 2;
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_EQ(a, 1 + 3, paddle::platform::errors::InvalidArgument(
|
|
"The result is not equal correct result."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(
|
|
ex_msg.find("Expected a == 1 + 3, but received a:2 != 1 + 3:4.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_NE, OK) {
|
|
PADDLE_ENFORCE_NE(1, 2, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_NE tests failed."));
|
|
PADDLE_ENFORCE_NE(1.0, 2UL, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_NE tests failed."));
|
|
}
|
|
TEST(ENFORCE_NE, FAIL) {
|
|
bool caught_exception = false;
|
|
|
|
try {
|
|
// 2UL here to check data type compatible
|
|
PADDLE_ENFORCE_NE(1.0, 1UL,
|
|
paddle::platform::errors::Unavailable(
|
|
"Expected 1.0 != 1UL, but received 1.0:1 == 1UL:1."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("Expected 1.0 != 1UL, but "
|
|
"received 1.0:1 == 1UL:1.") != std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_GT, OK) {
|
|
PADDLE_ENFORCE_GT(2, 1, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_GT tests failed."));
|
|
}
|
|
TEST(ENFORCE_GT, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_GT(1, 2, paddle::platform::errors::InvalidArgument(
|
|
"Expected 1 > 2, but received 1:1 <= 2:2."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("Expected 1 > 2, but received 1:1 <= 2:2.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_GE, OK) {
|
|
PADDLE_ENFORCE_GE(2, 2, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_GE tests failed."));
|
|
PADDLE_ENFORCE_GE(3, 2, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_GE tests failed."));
|
|
PADDLE_ENFORCE_GE(3.21, 2.0, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_GE tests failed."));
|
|
}
|
|
TEST(ENFORCE_GE, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_GE(1, 2, paddle::platform::errors::InvalidArgument(
|
|
"Expected 1 >= 2, but received 1:1 < 2:2."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("Expected 1 >= 2, but received 1:1 < 2:2.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_LE, OK) {
|
|
PADDLE_ENFORCE_LE(1, 1, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LE tests failed."));
|
|
PADDLE_ENFORCE_LE(1UL, 1UL, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LE tests failed."));
|
|
PADDLE_ENFORCE_LE(2, 3, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LE tests failed."));
|
|
PADDLE_ENFORCE_LE(2UL, 3UL, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LE tests failed."));
|
|
PADDLE_ENFORCE_LE(2.0, 3.2, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LE tests failed."));
|
|
}
|
|
TEST(ENFORCE_LE, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_GT(1, 2, paddle::platform::errors::InvalidArgument(
|
|
"Expected 1 > 2, but received 1:1 <= 2:2."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("Expected 1 > 2, but received 1:1 <= 2:2.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_LT, OK) {
|
|
PADDLE_ENFORCE_LT(3, 10, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LT tests failed."));
|
|
PADDLE_ENFORCE_LT(2UL, 3UL, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LT tests failed."));
|
|
PADDLE_ENFORCE_LT(2, 3, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_LT tests failed."));
|
|
}
|
|
TEST(ENFORCE_LT, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_LT(
|
|
1UL, 0.12,
|
|
paddle::platform::errors::InvalidArgument(
|
|
"Expected 1UL < 0.12, but received 1UL:1 >= 0.12:0.12."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("Expected 1UL < 0.12, but "
|
|
"received 1UL:1 >= 0.12:0.12.") !=
|
|
std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(ENFORCE_NOT_NULL, OK) {
|
|
int* a = new int;
|
|
PADDLE_ENFORCE_NOT_NULL(a, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_NOT_NULL tests failed."));
|
|
delete a;
|
|
}
|
|
TEST(ENFORCE_NOT_NULL, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
int* a = nullptr;
|
|
PADDLE_ENFORCE_NOT_NULL(
|
|
a, paddle::platform::errors::Unavailable("The a should not be null."));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("The a should not be null.") != std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
struct Dims {
|
|
size_t dims_[4];
|
|
|
|
bool operator==(const Dims& o) const {
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
if (dims_[i] != o.dims_[i]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& os, const Dims& d) {
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
if (i == 0) {
|
|
os << "[";
|
|
}
|
|
os << d.dims_[i];
|
|
if (i == 4 - 1) {
|
|
os << "]";
|
|
} else {
|
|
os << ", ";
|
|
}
|
|
}
|
|
return os;
|
|
}
|
|
|
|
TEST(ENFORCE_USER_DEFINED_CLASS, EQ) {
|
|
Dims a{{1, 2, 3, 4}}, b{{1, 2, 3, 4}};
|
|
PADDLE_ENFORCE_EQ(a, b, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_EQ tests failed."));
|
|
}
|
|
|
|
TEST(ENFORCE_USER_DEFINED_CLASS, NE) {
|
|
Dims a{{1, 2, 3, 4}}, b{{5, 6, 7, 8}};
|
|
bool caught_exception = false;
|
|
try {
|
|
PADDLE_ENFORCE_EQ(a, b, paddle::platform::errors::Unavailable(
|
|
"PADDLE_ENFORCE_EQ tests failed."));
|
|
} catch (paddle::platform::EnforceNotMet&) {
|
|
caught_exception = true;
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(EOF_EXCEPTION, THROW_EOF) {
|
|
bool caught_eof = false;
|
|
try {
|
|
PADDLE_THROW_EOF();
|
|
} catch (paddle::platform::EOFException& error) {
|
|
caught_eof = true;
|
|
std::string ex_msg = error.what();
|
|
EXPECT_TRUE(ex_msg.find("There is no next data.") != std::string::npos);
|
|
}
|
|
EXPECT_TRUE(caught_eof);
|
|
}
|
|
|
|
#ifdef PADDLE_WITH_CUDA
|
|
template <typename T>
|
|
bool CheckCudaStatusSuccess(T value, const std::string& msg = "success") {
|
|
PADDLE_ENFORCE_CUDA_SUCCESS(value);
|
|
return true;
|
|
}
|
|
|
|
template <typename T>
|
|
bool CheckCudaStatusFailure(T value, const std::string& msg) {
|
|
try {
|
|
PADDLE_ENFORCE_CUDA_SUCCESS(value);
|
|
return false;
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
std::string ex_msg = error.what();
|
|
return ex_msg.find(msg) != std::string::npos;
|
|
}
|
|
}
|
|
|
|
TEST(enforce, cuda_success) {
|
|
EXPECT_TRUE(CheckCudaStatusSuccess(cudaSuccess));
|
|
EXPECT_TRUE(CheckCudaStatusFailure(cudaErrorInvalidValue, "Cuda error"));
|
|
EXPECT_TRUE(CheckCudaStatusFailure(cudaErrorMemoryAllocation, "Cuda error"));
|
|
|
|
EXPECT_TRUE(CheckCudaStatusSuccess(CURAND_STATUS_SUCCESS));
|
|
EXPECT_TRUE(
|
|
CheckCudaStatusFailure(CURAND_STATUS_VERSION_MISMATCH, "Curand error"));
|
|
EXPECT_TRUE(
|
|
CheckCudaStatusFailure(CURAND_STATUS_NOT_INITIALIZED, "Curand error"));
|
|
|
|
EXPECT_TRUE(CheckCudaStatusSuccess(CUDNN_STATUS_SUCCESS));
|
|
EXPECT_TRUE(
|
|
CheckCudaStatusFailure(CUDNN_STATUS_NOT_INITIALIZED, "Cudnn error"));
|
|
EXPECT_TRUE(CheckCudaStatusFailure(CUDNN_STATUS_ALLOC_FAILED, "Cudnn error"));
|
|
|
|
EXPECT_TRUE(CheckCudaStatusSuccess(CUBLAS_STATUS_SUCCESS));
|
|
EXPECT_TRUE(
|
|
CheckCudaStatusFailure(CUBLAS_STATUS_NOT_INITIALIZED, "Cublas error"));
|
|
EXPECT_TRUE(
|
|
CheckCudaStatusFailure(CUBLAS_STATUS_INVALID_VALUE, "Cublas error"));
|
|
#if !defined(__APPLE__) && defined(PADDLE_WITH_NCCL)
|
|
EXPECT_TRUE(CheckCudaStatusSuccess(ncclSuccess));
|
|
EXPECT_TRUE(CheckCudaStatusFailure(ncclUnhandledCudaError, "Nccl error"));
|
|
EXPECT_TRUE(CheckCudaStatusFailure(ncclSystemError, "Nccl error"));
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
struct CannotToStringType {
|
|
explicit CannotToStringType(int num) : num_(num) {}
|
|
|
|
bool operator==(const CannotToStringType& other) const {
|
|
return num_ == other.num_;
|
|
}
|
|
|
|
bool operator!=(const CannotToStringType& other) const {
|
|
return num_ != other.num_;
|
|
}
|
|
|
|
private:
|
|
int num_;
|
|
};
|
|
|
|
TEST(enforce, cannot_to_string_type) {
|
|
static_assert(
|
|
!paddle::platform::details::CanToString<CannotToStringType>::kValue,
|
|
"CannotToStringType must not be converted to string");
|
|
static_assert(paddle::platform::details::CanToString<int>::kValue,
|
|
"int can be converted to string");
|
|
CannotToStringType obj1(3), obj2(4), obj3(3);
|
|
|
|
PADDLE_ENFORCE_NE(obj1, obj2, paddle::platform::errors::InvalidArgument(
|
|
"Object 1 is not equal to Object 2"));
|
|
PADDLE_ENFORCE_EQ(obj1, obj3, paddle::platform::errors::InvalidArgument(
|
|
"Object 1 is equal to Object 3"));
|
|
|
|
std::string msg = "Compare obj1 with obj2";
|
|
try {
|
|
PADDLE_ENFORCE_EQ(obj1, obj2,
|
|
paddle::platform::errors::InvalidArgument(msg));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
std::string ex_msg = error.what();
|
|
LOG(INFO) << ex_msg;
|
|
EXPECT_TRUE(ex_msg.find(msg) != std::string::npos);
|
|
EXPECT_TRUE(
|
|
ex_msg.find("Expected obj1 == obj2, but received obj1 != obj2") !=
|
|
std::string::npos);
|
|
}
|
|
|
|
msg = "Compare x with y";
|
|
try {
|
|
int x = 3, y = 2;
|
|
PADDLE_ENFORCE_EQ(x, y, paddle::platform::errors::InvalidArgument(msg));
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
std::string ex_msg = error.what();
|
|
LOG(INFO) << ex_msg;
|
|
EXPECT_TRUE(ex_msg.find(msg) != std::string::npos);
|
|
EXPECT_TRUE(ex_msg.find("Expected x == y, but received x:3 != y:2") !=
|
|
std::string::npos);
|
|
}
|
|
|
|
std::set<int> set;
|
|
PADDLE_ENFORCE_EQ(set.begin(), set.end(),
|
|
paddle::platform::errors::InvalidArgument(
|
|
"The begin and end of set is not equal."));
|
|
set.insert(3);
|
|
PADDLE_ENFORCE_NE(set.begin(), set.end(),
|
|
paddle::platform::errors::InvalidArgument(
|
|
"The begin and end of set is equal."));
|
|
|
|
std::list<float> list;
|
|
PADDLE_ENFORCE_EQ(list.begin(), list.end(),
|
|
paddle::platform::errors::InvalidArgument(
|
|
"The begin and end of list is not equal."));
|
|
list.push_back(4);
|
|
PADDLE_ENFORCE_NE(list.begin(), list.end(),
|
|
paddle::platform::errors::InvalidArgument(
|
|
"The begin and end of list is equal."));
|
|
}
|
|
|
|
TEST(GET_DATA_SAFELY_MACRO, SUCCESS) {
|
|
int* a = new int(10);
|
|
GET_DATA_SAFELY(a, "Input", "X", "dummy");
|
|
}
|
|
|
|
TEST(GET_DATA_SAFELY_MACRO, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
int* a = nullptr;
|
|
GET_DATA_SAFELY(a, "Input", "X", "dummy");
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(OP_INOUT_CHECK_MACRO, SUCCESS) {
|
|
OP_INOUT_CHECK(true, "Input", "X", "dummy");
|
|
}
|
|
|
|
TEST(OP_INOUT_CHECK_MACRO, FAIL) {
|
|
bool caught_exception = false;
|
|
try {
|
|
OP_INOUT_CHECK(false, "Input", "X", "dummy");
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|
|
|
|
TEST(BOOST_GET_SAFELY, SUCCESS) {
|
|
paddle::framework::Attribute attr;
|
|
attr = true;
|
|
bool rlt = BOOST_GET(bool, attr);
|
|
EXPECT_EQ(rlt, true);
|
|
}
|
|
|
|
TEST(BOOST_GET_SAFELY, FAIL) {
|
|
paddle::framework::Attribute attr;
|
|
attr = true;
|
|
bool caught_exception = false;
|
|
try {
|
|
BOOST_GET(int, attr);
|
|
} catch (paddle::platform::EnforceNotMet& error) {
|
|
caught_exception = true;
|
|
}
|
|
EXPECT_TRUE(caught_exception);
|
|
}
|