leavelet/fmt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Follow standard naming conventions

Browse Source
This commit is contained in:
Victor Zverovich
2017-02-19 08:41:38 -08:00
parent 6a2ff287b2
commit c333dca065
13 changed files with 180 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/format-test.cc
View File

@@ -1314,7 +1314,7 @@ TEST(FormatterTest, FormatExamples) {
EXPECT_SYSTEM_ERROR({
FILE *f = safe_fopen(filename, "r");
if (!f)
throw fmt::SystemError(errno, "Cannot open file '{}'", filename);
throw fmt::system_error(errno, "Cannot open file '{}'", filename);
fclose(f);
}, error_code, "Cannot open file 'nonexistent'");
}
@@ -1514,16 +1514,16 @@ TEST(FormatTest, Enum) {
EXPECT_EQ("0", fmt::format("{}", A));
}
class MockArgFormatter : public fmt::internal::ArgFormatterBase<char> {
class MockArgFormatter : public fmt::internal::arg_formatter_base<char> {
private:
MOCK_METHOD1(call, void (int value));
public:
typedef fmt::internal::ArgFormatterBase<char> Base;
typedef fmt::internal::arg_formatter_base<char> Base;
MockArgFormatter(fmt::buffer &b, fmt::context &ctx,
fmt::format_specs &s)
: fmt::internal::ArgFormatterBase<char>(b, s) {
: fmt::internal::arg_formatter_base<char>(b, s) {
EXPECT_CALL(*this, call(42));
}

6
test/gtest-extra-test.cc
View File

@@ -78,7 +78,7 @@ void throw_exception() {
}
void throw_system_error() {
throw fmt::SystemError(EDOM, "test");
throw fmt::system_error(EDOM, "test");
}
// Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument
@@ -207,11 +207,11 @@ TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
// EXPECT_SYSTEM_ERROR macro.
TEST(ExpectSystemErrorTest, DoesNotGenerateUnreachableCodeWarning) {
int n = 0;
EXPECT_SYSTEM_ERROR(throw fmt::SystemError(EDOM, "test"), EDOM, "test");
EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "test"), EDOM, "test");
EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(n++, EDOM, ""), "");
EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw 1, EDOM, ""), "");
EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
throw fmt::SystemError(EDOM, "aaa"), EDOM, "bbb"), "");
throw fmt::system_error(EDOM, "aaa"), EDOM, "bbb"), "");
}
TEST(AssertionSyntaxTest, ExceptionAssertionBehavesLikeSingleStatement) {

2
test/gtest-extra.cc
View File

@@ -38,7 +38,7 @@ void OutputRedirect::flush() {
int result = 0;
FMT_RETRY(result, fflush(file_));
if (result != 0)
throw fmt::SystemError(errno, "cannot flush stream");
throw fmt::system_error(errno, "cannot flush stream");
}
void OutputRedirect::restore() {

2
test/ostream-test.cc
View File

@@ -53,7 +53,7 @@ std::ostream &operator<<(std::ostream &os, TestEnum) {
enum TestEnum2 {A};
TEST(OStreamTest, Enum) {
EXPECT_FALSE(fmt::internal::ConvertToInt<TestEnum>::value);
EXPECT_FALSE(fmt::internal::convert_to_int<TestEnum>::value);
EXPECT_EQ("TestEnum", fmt::format("{}", TestEnum()));
EXPECT_EQ("0", fmt::format("{}", A));
}

2
test/posix-mock-test.cc
View File

@@ -415,7 +415,7 @@ TEST(BufferedFileTest, OpenRetry) {
#ifndef _WIN32
char c = 0;
if (fread(&c, 1, 1, f->get()) < 1)
throw fmt::SystemError(errno, "fread failed");
throw fmt::system_error(errno, "fread failed");
#endif
}

2
test/posix-test.cc
View File

@@ -173,7 +173,7 @@ TEST(BufferedFileTest, Fileno) {
EXPECT_DEATH_IF_SUPPORTED({
try {
f.fileno();
} catch (fmt::SystemError) {
} catch (fmt::system_error) {
std::exit(1);
}
}, "");

26
test/util-test.cc
View File

@@ -652,7 +652,7 @@ TEST(UtilTest, CountDigits) {
#ifdef _WIN32
TEST(UtilTest, UTF16ToUTF8) {
std::string s = "ёжик";
fmt::internal::UTF16ToUTF8 u(L"\x0451\x0436\x0438\x043A");
fmt::internal::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
EXPECT_EQ(s, u.str());
EXPECT_EQ(s.size(), u.size());
}
@@ -681,7 +681,7 @@ void check_utf_conversion_error(
}
TEST(UtilTest, UTF16ToUTF8Error) {
check_utf_conversion_error<fmt::internal::UTF16ToUTF8, wchar_t>(
check_utf_conversion_error<fmt::internal::utf16_to_utf8, wchar_t>(
"cannot convert string from UTF-16 to UTF-8");
}
@@ -693,7 +693,7 @@ TEST(UtilTest, UTF8ToUTF16Error) {
}
TEST(UtilTest, UTF16ToUTF8Convert) {
fmt::internal::UTF16ToUTF8 u;
fmt::internal::utf16_to_utf8 u;
EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::wstring_view(0, 0)));
EXPECT_EQ(ERROR_INVALID_PARAMETER,
u.convert(fmt::wstring_view(L"foo", INT_MAX + 1u)));
@@ -705,10 +705,10 @@ typedef void (*FormatErrorMessage)(
template <typename Error>
void check_throw_error(int error_code, FormatErrorMessage format) {
fmt::SystemError error(0, "");
fmt::system_error error(0, "");
try {
throw Error(error_code, "test {}", "error");
} catch (const fmt::SystemError &e) {
} catch (const fmt::system_error &e) {
error = e;
}
fmt::memory_buffer message;
@@ -729,10 +729,10 @@ TEST(UtilTest, FormatSystemError) {
}
TEST(UtilTest, SystemError) {
fmt::SystemError e(EDOM, "test");
fmt::system_error e(EDOM, "test");
EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
EXPECT_EQ(EDOM, e.error_code());
check_throw_error<fmt::SystemError>(EDOM, fmt::format_system_error);
check_throw_error<fmt::system_error>(EDOM, fmt::format_system_error);
}
TEST(UtilTest, ReportSystemError) {
@@ -751,7 +751,7 @@ TEST(UtilTest, FormatWindowsError) {
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPWSTR>(&message), 0, 0);
fmt::internal::UTF16ToUTF8 utf8_message(message);
fmt::internal::utf16_to_utf8 utf8_message(message);
LocalFree(message);
fmt::memory_buffer actual_message;
fmt::internal::format_windows_error(
@@ -778,7 +778,7 @@ TEST(UtilTest, FormatLongWindowsError) {
reinterpret_cast<LPWSTR>(&message), 0, 0) == 0) {
return;
}
fmt::internal::UTF16ToUTF8 utf8_message(message);
fmt::internal::utf16_to_utf8 utf8_message(message);
LocalFree(message);
fmt::memory_buffer actual_message;
fmt::internal::format_windows_error(
@@ -806,15 +806,15 @@ TEST(UtilTest, ReportWindowsError) {
enum TestEnum2 {};
TEST(UtilTest, ConvertToInt) {
EXPECT_TRUE(fmt::internal::ConvertToInt<char>::enable_conversion);
EXPECT_FALSE(fmt::internal::ConvertToInt<const char *>::enable_conversion);
EXPECT_TRUE(fmt::internal::ConvertToInt<TestEnum2>::value);
EXPECT_TRUE(fmt::internal::convert_to_int<char>::enable_conversion);
EXPECT_FALSE(fmt::internal::convert_to_int<const char *>::enable_conversion);
EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum2>::value);
}
#if FMT_USE_ENUM_BASE
enum TestEnum : char {TestValue};
TEST(UtilTest, IsEnumConvertibleToInt) {
EXPECT_TRUE(fmt::internal::ConvertToInt<TestEnum>::enable_conversion);
EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum>::enable_conversion);
}
#endif