mirror of
https://github.com/fmtlib/fmt.git
synced 2024-09-04 05:59:13 +00:00
185 lines
4.7 KiB
C++
185 lines
4.7 KiB
C++
// Formatting library for C++ - scanning API test
|
|
//
|
|
// Copyright (c) 2019 - present, Victor Zverovich
|
|
// All rights reserved.
|
|
//
|
|
// For the license information refer to format.h.
|
|
|
|
#include "scan.h"
|
|
|
|
#include <time.h>
|
|
|
|
#include <climits>
|
|
#include <thread>
|
|
|
|
#include "fmt/os.h"
|
|
#include "gmock/gmock.h"
|
|
#include "gtest-extra.h"
|
|
|
|
TEST(scan_test, read_text) {
|
|
fmt::string_view s = "foo";
|
|
auto end = fmt::scan_to(s, "foo");
|
|
EXPECT_EQ(end, s.end());
|
|
EXPECT_THROW_MSG(fmt::scan<int>("fob", "foo"), fmt::format_error,
|
|
"invalid input");
|
|
}
|
|
|
|
TEST(scan_test, read_int) {
|
|
EXPECT_EQ(fmt::scan<int>("42", "{}")->value(), 42);
|
|
EXPECT_EQ(fmt::scan<int>("-42", "{}")->value(), -42);
|
|
EXPECT_EQ(fmt::scan<int>("42", "{:}")->value(), 42);
|
|
EXPECT_THROW_MSG(fmt::scan<int>(std::to_string(INT_MAX + 1u), "{}"),
|
|
fmt::format_error, "number is too big");
|
|
}
|
|
|
|
TEST(scan_test, read_long_long) {
|
|
EXPECT_EQ(fmt::scan<long long>("42", "{}")->value(), 42);
|
|
EXPECT_EQ(fmt::scan<long long>("-42", "{}")->value(), -42);
|
|
}
|
|
|
|
TEST(scan_test, read_uint) {
|
|
EXPECT_EQ(fmt::scan<unsigned>("42", "{}")->value(), 42);
|
|
EXPECT_THROW_MSG(fmt::scan<unsigned>("-42", "{}"), fmt::format_error,
|
|
"invalid input");
|
|
}
|
|
|
|
TEST(scan_test, read_ulong_long) {
|
|
EXPECT_EQ(fmt::scan<unsigned long long>("42", "{}")->value(), 42);
|
|
EXPECT_THROW_MSG(fmt::scan<unsigned long long>("-42", "{}")->value(),
|
|
fmt::format_error, "invalid input");
|
|
}
|
|
|
|
TEST(scan_test, read_hex) {
|
|
EXPECT_EQ(fmt::scan<unsigned>("2a", "{:x}")->value(), 42);
|
|
auto num_digits = std::numeric_limits<unsigned>::digits / 4;
|
|
EXPECT_THROW_MSG(
|
|
fmt::scan<unsigned>(fmt::format("1{:0{}}", 0, num_digits), "{:x}")
|
|
->value(),
|
|
fmt::format_error, "number is too big");
|
|
}
|
|
|
|
TEST(scan_test, read_string) {
|
|
EXPECT_EQ(fmt::scan<std::string>("foo", "{}")->value(), "foo");
|
|
}
|
|
|
|
TEST(scan_test, read_string_view) {
|
|
EXPECT_EQ(fmt::scan<fmt::string_view>("foo", "{}")->value(), "foo");
|
|
}
|
|
|
|
TEST(scan_test, separator) {
|
|
int n1 = 0, n2 = 0;
|
|
fmt::scan_to("10 20", "{} {}", n1, n2);
|
|
EXPECT_EQ(n1, 10);
|
|
EXPECT_EQ(n2, 20);
|
|
}
|
|
|
|
struct num {
|
|
int value;
|
|
};
|
|
|
|
namespace fmt {
|
|
template <> struct scanner<num> {
|
|
bool hex = false;
|
|
|
|
auto parse(scan_parse_context& ctx) -> scan_parse_context::iterator {
|
|
auto it = ctx.begin(), end = ctx.end();
|
|
if (it != end && *it == 'x') {
|
|
hex = true;
|
|
++it;
|
|
}
|
|
if (it != end && *it != '}') report_error("invalid format");
|
|
return it;
|
|
}
|
|
|
|
template <class ScanContext>
|
|
auto scan(num& n, ScanContext& ctx) const -> typename ScanContext::iterator {
|
|
return hex ? scan_to(ctx, "{:x}", n.value) : scan_to(ctx, "{}", n.value);
|
|
}
|
|
};
|
|
} // namespace fmt
|
|
|
|
TEST(scan_test, read_custom) {
|
|
EXPECT_EQ(fmt::scan<num>("42", "{}")->value().value, 42);
|
|
EXPECT_EQ(fmt::scan<num>("2a", "{:x}")->value().value, 42);
|
|
}
|
|
|
|
TEST(scan_test, invalid_format) {
|
|
EXPECT_THROW_MSG(fmt::scan_to("", "{}"), fmt::format_error,
|
|
"argument index out of range");
|
|
EXPECT_THROW_MSG(fmt::scan_to("", "{"), fmt::format_error,
|
|
"invalid format string");
|
|
}
|
|
|
|
namespace std {
|
|
using fmt::scan;
|
|
using fmt::scan_error;
|
|
}
|
|
|
|
TEST(scan_test, example) {
|
|
// Example from https://wg21.link/p1729r3.
|
|
if (auto result = std::scan<std::string, int>("answer = 42", "{} = {}")) {
|
|
auto range = result->range();
|
|
EXPECT_EQ(range.begin(), range.end());
|
|
EXPECT_EQ(result->begin(), result->end());
|
|
#ifdef __cpp_structured_bindings
|
|
const auto& [key, value] = result->values();
|
|
EXPECT_EQ(key, "answer");
|
|
EXPECT_EQ(value, 42);
|
|
#endif
|
|
} else {
|
|
std::scan_error error = result.error();
|
|
(void)error;
|
|
FAIL();
|
|
}
|
|
}
|
|
|
|
TEST(scan_test, end_of_input) { fmt::scan<int>("", "{}"); }
|
|
|
|
#if FMT_USE_FCNTL
|
|
TEST(scan_test, file) {
|
|
auto pipe = fmt::pipe();
|
|
|
|
fmt::string_view input = "10 20";
|
|
pipe.write_end.write(input.data(), input.size());
|
|
pipe.write_end.close();
|
|
|
|
int n1 = 0, n2 = 0;
|
|
fmt::buffered_file f = pipe.read_end.fdopen("r");
|
|
fmt::scan_to(f.get(), "{} {}", n1, n2);
|
|
EXPECT_EQ(n1, 10);
|
|
EXPECT_EQ(n2, 20);
|
|
}
|
|
|
|
TEST(scan_test, lock) {
|
|
auto pipe = fmt::pipe();
|
|
|
|
std::thread producer([&]() {
|
|
fmt::string_view input = "42 ";
|
|
for (int i = 0; i < 1000; ++i)
|
|
pipe.write_end.write(input.data(), input.size());
|
|
pipe.write_end.close();
|
|
});
|
|
|
|
std::atomic<int> count(0);
|
|
fmt::buffered_file f = pipe.read_end.fdopen("r");
|
|
auto fun = [&]() {
|
|
int value = 0;
|
|
while (fmt::scan_to(f.get(), "{}", value)) {
|
|
if (value != 42) {
|
|
pipe.read_end.close();
|
|
EXPECT_EQ(value, 42);
|
|
break;
|
|
}
|
|
++count;
|
|
}
|
|
};
|
|
std::thread consumer1(fun);
|
|
std::thread consumer2(fun);
|
|
|
|
producer.join();
|
|
consumer1.join();
|
|
consumer2.join();
|
|
EXPECT_EQ(count, 1000);
|
|
}
|
|
#endif // FMT_USE_FCNTL
|