1 // Formatting library for C++ - scanning API test
2 //
3 // Copyright (c) 2019 - present, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7
8 #include "scan.h"
9
10 #include <time.h>
11
12 #include <climits>
13 #include <thread>
14
15 #include "fmt/os.h"
16 #include "gmock/gmock.h"
17 #include "gtest-extra.h"
18
TEST(scan_test,read_text)19 TEST(scan_test, read_text) {
20 fmt::string_view s = "foo";
21 auto end = fmt::scan_to(s, "foo");
22 EXPECT_EQ(end, s.end());
23 EXPECT_THROW_MSG(fmt::scan<int>("fob", "foo"), fmt::format_error,
24 "invalid input");
25 }
26
TEST(scan_test,read_int)27 TEST(scan_test, read_int) {
28 EXPECT_EQ(fmt::scan<int>("42", "{}")->value(), 42);
29 EXPECT_EQ(fmt::scan<int>("-42", "{}")->value(), -42);
30 EXPECT_EQ(fmt::scan<int>("42", "{:}")->value(), 42);
31 EXPECT_THROW_MSG(fmt::scan<int>(std::to_string(INT_MAX + 1u), "{}"),
32 fmt::format_error, "number is too big");
33 }
34
TEST(scan_test,read_long_long)35 TEST(scan_test, read_long_long) {
36 EXPECT_EQ(fmt::scan<long long>("42", "{}")->value(), 42);
37 EXPECT_EQ(fmt::scan<long long>("-42", "{}")->value(), -42);
38 }
39
TEST(scan_test,read_uint)40 TEST(scan_test, read_uint) {
41 EXPECT_EQ(fmt::scan<unsigned>("42", "{}")->value(), 42);
42 EXPECT_THROW_MSG(fmt::scan<unsigned>("-42", "{}"), fmt::format_error,
43 "invalid input");
44 }
45
TEST(scan_test,read_ulong_long)46 TEST(scan_test, read_ulong_long) {
47 EXPECT_EQ(fmt::scan<unsigned long long>("42", "{}")->value(), 42);
48 EXPECT_THROW_MSG(fmt::scan<unsigned long long>("-42", "{}")->value(),
49 fmt::format_error, "invalid input");
50 }
51
TEST(scan_test,read_hex)52 TEST(scan_test, read_hex) {
53 EXPECT_EQ(fmt::scan<unsigned>("2a", "{:x}")->value(), 42);
54 auto num_digits = std::numeric_limits<unsigned>::digits / 4;
55 EXPECT_THROW_MSG(
56 fmt::scan<unsigned>(fmt::format("1{:0{}}", 0, num_digits), "{:x}")
57 ->value(),
58 fmt::format_error, "number is too big");
59 }
60
TEST(scan_test,read_string)61 TEST(scan_test, read_string) {
62 EXPECT_EQ(fmt::scan<std::string>("foo", "{}")->value(), "foo");
63 }
64
TEST(scan_test,read_string_view)65 TEST(scan_test, read_string_view) {
66 EXPECT_EQ(fmt::scan<fmt::string_view>("foo", "{}")->value(), "foo");
67 }
68
TEST(scan_test,separator)69 TEST(scan_test, separator) {
70 int n1 = 0, n2 = 0;
71 fmt::scan_to("10 20", "{} {}", n1, n2);
72 EXPECT_EQ(n1, 10);
73 EXPECT_EQ(n2, 20);
74 }
75
76 struct num {
77 int value;
78 };
79
80 namespace fmt {
81 template <> struct scanner<num> {
82 bool hex = false;
83
parsefmt::scanner84 auto parse(scan_parse_context& ctx) -> scan_parse_context::iterator {
85 auto it = ctx.begin(), end = ctx.end();
86 if (it != end && *it == 'x') {
87 hex = true;
88 ++it;
89 }
90 if (it != end && *it != '}') report_error("invalid format");
91 return it;
92 }
93
94 template <class ScanContext>
scanfmt::scanner95 auto scan(num& n, ScanContext& ctx) const -> typename ScanContext::iterator {
96 return hex ? scan_to(ctx, "{:x}", n.value) : scan_to(ctx, "{}", n.value);
97 }
98 };
99 } // namespace fmt
100
TEST(scan_test,read_custom)101 TEST(scan_test, read_custom) {
102 EXPECT_EQ(fmt::scan<num>("42", "{}")->value().value, 42);
103 EXPECT_EQ(fmt::scan<num>("2a", "{:x}")->value().value, 42);
104 }
105
TEST(scan_test,invalid_format)106 TEST(scan_test, invalid_format) {
107 EXPECT_THROW_MSG(fmt::scan_to("", "{}"), fmt::format_error,
108 "argument index out of range");
109 EXPECT_THROW_MSG(fmt::scan_to("", "{"), fmt::format_error,
110 "invalid format string");
111 }
112
113 namespace std {
114 using fmt::scan;
115 using fmt::scan_error;
116 } // namespace std
117
TEST(scan_test,example)118 TEST(scan_test, example) {
119 // Example from https://wg21.link/p1729r3.
120 if (auto result = std::scan<std::string, int>("answer = 42", "{} = {}")) {
121 auto range = result->range();
122 EXPECT_EQ(range.begin(), range.end());
123 EXPECT_EQ(result->begin(), result->end());
124 #ifdef __cpp_structured_bindings
125 const auto& [key, value] = result->values();
126 EXPECT_EQ(key, "answer");
127 EXPECT_EQ(value, 42);
128 #endif
129 } else {
130 std::scan_error error = result.error();
131 (void)error;
132 FAIL();
133 }
134 }
135
TEST(scan_test,end_of_input)136 TEST(scan_test, end_of_input) { fmt::scan<int>("", "{}"); }
137
138 #if FMT_USE_FCNTL
TEST(scan_test,file)139 TEST(scan_test, file) {
140 auto pipe = fmt::pipe();
141
142 fmt::string_view input = "10 20";
143 pipe.write_end.write(input.data(), input.size());
144 pipe.write_end.close();
145
146 int n1 = 0, n2 = 0;
147 fmt::buffered_file f = pipe.read_end.fdopen("r");
148 fmt::scan_to(f.get(), "{} {}", n1, n2);
149 EXPECT_EQ(n1, 10);
150 EXPECT_EQ(n2, 20);
151 }
152
TEST(scan_test,lock)153 TEST(scan_test, lock) {
154 auto pipe = fmt::pipe();
155
156 std::thread producer([&]() {
157 fmt::string_view input = "42 ";
158 for (int i = 0; i < 1000; ++i)
159 pipe.write_end.write(input.data(), input.size());
160 pipe.write_end.close();
161 });
162
163 std::atomic<int> count(0);
164 fmt::buffered_file f = pipe.read_end.fdopen("r");
165 auto fun = [&]() {
166 int value = 0;
167 while (fmt::scan_to(f.get(), "{}", value)) {
168 if (value != 42) {
169 pipe.read_end.close();
170 EXPECT_EQ(value, 42);
171 break;
172 }
173 ++count;
174 }
175 };
176 std::thread consumer1(fun);
177 std::thread consumer2(fun);
178
179 producer.join();
180 consumer1.join();
181 consumer2.join();
182 EXPECT_EQ(count, 1000);
183 }
184 #endif // FMT_USE_FCNTL
185