1 // Copyright 2019 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "absl/status/status.h"
16
17 #include <errno.h>
18
19 #include "gmock/gmock.h"
20 #include "gtest/gtest.h"
21 #include "absl/strings/str_cat.h"
22
23 namespace {
24
25 using ::testing::Eq;
26 using ::testing::HasSubstr;
27 using ::testing::Optional;
28 using ::testing::UnorderedElementsAreArray;
29
TEST(StatusCode,InsertionOperator)30 TEST(StatusCode, InsertionOperator) {
31 const absl::StatusCode code = absl::StatusCode::kUnknown;
32 std::ostringstream oss;
33 oss << code;
34 EXPECT_EQ(oss.str(), absl::StatusCodeToString(code));
35 }
36
37 // This structure holds the details for testing a single error code,
38 // its creator, and its classifier.
39 struct ErrorTest {
40 absl::StatusCode code;
41 using Creator = absl::Status (*)(
42 absl::string_view
43 );
44 using Classifier = bool (*)(const absl::Status&);
45 Creator creator;
46 Classifier classifier;
47 };
48
49 constexpr ErrorTest kErrorTests[]{
50 {absl::StatusCode::kCancelled, absl::CancelledError, absl::IsCancelled},
51 {absl::StatusCode::kUnknown, absl::UnknownError, absl::IsUnknown},
52 {absl::StatusCode::kInvalidArgument, absl::InvalidArgumentError,
53 absl::IsInvalidArgument},
54 {absl::StatusCode::kDeadlineExceeded, absl::DeadlineExceededError,
55 absl::IsDeadlineExceeded},
56 {absl::StatusCode::kNotFound, absl::NotFoundError, absl::IsNotFound},
57 {absl::StatusCode::kAlreadyExists, absl::AlreadyExistsError,
58 absl::IsAlreadyExists},
59 {absl::StatusCode::kPermissionDenied, absl::PermissionDeniedError,
60 absl::IsPermissionDenied},
61 {absl::StatusCode::kResourceExhausted, absl::ResourceExhaustedError,
62 absl::IsResourceExhausted},
63 {absl::StatusCode::kFailedPrecondition, absl::FailedPreconditionError,
64 absl::IsFailedPrecondition},
65 {absl::StatusCode::kAborted, absl::AbortedError, absl::IsAborted},
66 {absl::StatusCode::kOutOfRange, absl::OutOfRangeError, absl::IsOutOfRange},
67 {absl::StatusCode::kUnimplemented, absl::UnimplementedError,
68 absl::IsUnimplemented},
69 {absl::StatusCode::kInternal, absl::InternalError, absl::IsInternal},
70 {absl::StatusCode::kUnavailable, absl::UnavailableError,
71 absl::IsUnavailable},
72 {absl::StatusCode::kDataLoss, absl::DataLossError, absl::IsDataLoss},
73 {absl::StatusCode::kUnauthenticated, absl::UnauthenticatedError,
74 absl::IsUnauthenticated},
75 };
76
TEST(Status,CreateAndClassify)77 TEST(Status, CreateAndClassify) {
78 for (const auto& test : kErrorTests) {
79 SCOPED_TRACE(absl::StatusCodeToString(test.code));
80
81 // Ensure that the creator does, in fact, create status objects with the
82 // expected error code and message.
83 std::string message =
84 absl::StrCat("error code ", test.code, " test message");
85 absl::Status status = test.creator(
86 message
87 );
88 EXPECT_EQ(test.code, status.code());
89 EXPECT_EQ(message, status.message());
90
91 // Ensure that the classifier returns true for a status produced by the
92 // creator.
93 EXPECT_TRUE(test.classifier(status));
94
95 // Ensure that the classifier returns false for status with a different
96 // code.
97 for (const auto& other : kErrorTests) {
98 if (other.code != test.code) {
99 EXPECT_FALSE(test.classifier(absl::Status(other.code, "")))
100 << " other.code = " << other.code;
101 }
102 }
103 }
104 }
105
TEST(Status,DefaultConstructor)106 TEST(Status, DefaultConstructor) {
107 absl::Status status;
108 EXPECT_TRUE(status.ok());
109 EXPECT_EQ(absl::StatusCode::kOk, status.code());
110 EXPECT_EQ("", status.message());
111 }
112
TEST(Status,OkStatus)113 TEST(Status, OkStatus) {
114 absl::Status status = absl::OkStatus();
115 EXPECT_TRUE(status.ok());
116 EXPECT_EQ(absl::StatusCode::kOk, status.code());
117 EXPECT_EQ("", status.message());
118 }
119
TEST(Status,ConstructorWithCodeMessage)120 TEST(Status, ConstructorWithCodeMessage) {
121 {
122 absl::Status status(absl::StatusCode::kCancelled, "");
123 EXPECT_FALSE(status.ok());
124 EXPECT_EQ(absl::StatusCode::kCancelled, status.code());
125 EXPECT_EQ("", status.message());
126 }
127 {
128 absl::Status status(absl::StatusCode::kInternal, "message");
129 EXPECT_FALSE(status.ok());
130 EXPECT_EQ(absl::StatusCode::kInternal, status.code());
131 EXPECT_EQ("message", status.message());
132 }
133 }
134
TEST(Status,ConstructOutOfRangeCode)135 TEST(Status, ConstructOutOfRangeCode) {
136 const int kRawCode = 9999;
137 absl::Status status(static_cast<absl::StatusCode>(kRawCode), "");
138 EXPECT_EQ(absl::StatusCode::kUnknown, status.code());
139 EXPECT_EQ(kRawCode, status.raw_code());
140 }
141
142 constexpr char kUrl1[] = "url.payload.1";
143 constexpr char kUrl2[] = "url.payload.2";
144 constexpr char kUrl3[] = "url.payload.3";
145 constexpr char kUrl4[] = "url.payload.xx";
146
147 constexpr char kPayload1[] = "aaaaa";
148 constexpr char kPayload2[] = "bbbbb";
149 constexpr char kPayload3[] = "ccccc";
150
151 using PayloadsVec = std::vector<std::pair<std::string, absl::Cord>>;
152
TEST(Status,TestGetSetPayload)153 TEST(Status, TestGetSetPayload) {
154 absl::Status ok_status = absl::OkStatus();
155 ok_status.SetPayload(kUrl1, absl::Cord(kPayload1));
156 ok_status.SetPayload(kUrl2, absl::Cord(kPayload2));
157
158 EXPECT_FALSE(ok_status.GetPayload(kUrl1));
159 EXPECT_FALSE(ok_status.GetPayload(kUrl2));
160
161 absl::Status bad_status(absl::StatusCode::kInternal, "fail");
162 bad_status.SetPayload(kUrl1, absl::Cord(kPayload1));
163 bad_status.SetPayload(kUrl2, absl::Cord(kPayload2));
164
165 EXPECT_THAT(bad_status.GetPayload(kUrl1), Optional(Eq(kPayload1)));
166 EXPECT_THAT(bad_status.GetPayload(kUrl2), Optional(Eq(kPayload2)));
167
168 EXPECT_FALSE(bad_status.GetPayload(kUrl3));
169
170 bad_status.SetPayload(kUrl1, absl::Cord(kPayload3));
171 EXPECT_THAT(bad_status.GetPayload(kUrl1), Optional(Eq(kPayload3)));
172
173 // Testing dynamically generated type_url
174 bad_status.SetPayload(absl::StrCat(kUrl1, ".1"), absl::Cord(kPayload1));
175 EXPECT_THAT(bad_status.GetPayload(absl::StrCat(kUrl1, ".1")),
176 Optional(Eq(kPayload1)));
177 }
178
TEST(Status,TestErasePayload)179 TEST(Status, TestErasePayload) {
180 absl::Status bad_status(absl::StatusCode::kInternal, "fail");
181 bad_status.SetPayload(kUrl1, absl::Cord(kPayload1));
182 bad_status.SetPayload(kUrl2, absl::Cord(kPayload2));
183 bad_status.SetPayload(kUrl3, absl::Cord(kPayload3));
184
185 EXPECT_FALSE(bad_status.ErasePayload(kUrl4));
186
187 EXPECT_TRUE(bad_status.GetPayload(kUrl2));
188 EXPECT_TRUE(bad_status.ErasePayload(kUrl2));
189 EXPECT_FALSE(bad_status.GetPayload(kUrl2));
190 EXPECT_FALSE(bad_status.ErasePayload(kUrl2));
191
192 EXPECT_TRUE(bad_status.ErasePayload(kUrl1));
193 EXPECT_TRUE(bad_status.ErasePayload(kUrl3));
194
195 bad_status.SetPayload(kUrl1, absl::Cord(kPayload1));
196 EXPECT_TRUE(bad_status.ErasePayload(kUrl1));
197 }
198
TEST(Status,TestComparePayloads)199 TEST(Status, TestComparePayloads) {
200 absl::Status bad_status1(absl::StatusCode::kInternal, "fail");
201 bad_status1.SetPayload(kUrl1, absl::Cord(kPayload1));
202 bad_status1.SetPayload(kUrl2, absl::Cord(kPayload2));
203 bad_status1.SetPayload(kUrl3, absl::Cord(kPayload3));
204
205 absl::Status bad_status2(absl::StatusCode::kInternal, "fail");
206 bad_status2.SetPayload(kUrl2, absl::Cord(kPayload2));
207 bad_status2.SetPayload(kUrl3, absl::Cord(kPayload3));
208 bad_status2.SetPayload(kUrl1, absl::Cord(kPayload1));
209
210 EXPECT_EQ(bad_status1, bad_status2);
211 }
212
TEST(Status,TestComparePayloadsAfterErase)213 TEST(Status, TestComparePayloadsAfterErase) {
214 absl::Status payload_status(absl::StatusCode::kInternal, "");
215 payload_status.SetPayload(kUrl1, absl::Cord(kPayload1));
216 payload_status.SetPayload(kUrl2, absl::Cord(kPayload2));
217
218 absl::Status empty_status(absl::StatusCode::kInternal, "");
219
220 // Different payloads, not equal
221 EXPECT_NE(payload_status, empty_status);
222 EXPECT_TRUE(payload_status.ErasePayload(kUrl1));
223
224 // Still Different payloads, still not equal.
225 EXPECT_NE(payload_status, empty_status);
226 EXPECT_TRUE(payload_status.ErasePayload(kUrl2));
227
228 // Both empty payloads, should be equal
229 EXPECT_EQ(payload_status, empty_status);
230 }
231
AllVisitedPayloads(const absl::Status & s)232 PayloadsVec AllVisitedPayloads(const absl::Status& s) {
233 PayloadsVec result;
234
235 s.ForEachPayload([&](absl::string_view type_url, const absl::Cord& payload) {
236 result.push_back(std::make_pair(std::string(type_url), payload));
237 });
238
239 return result;
240 }
241
TEST(Status,TestForEachPayload)242 TEST(Status, TestForEachPayload) {
243 absl::Status bad_status(absl::StatusCode::kInternal, "fail");
244 bad_status.SetPayload(kUrl1, absl::Cord(kPayload1));
245 bad_status.SetPayload(kUrl2, absl::Cord(kPayload2));
246 bad_status.SetPayload(kUrl3, absl::Cord(kPayload3));
247
248 int count = 0;
249
250 bad_status.ForEachPayload(
251 [&count](absl::string_view, const absl::Cord&) { ++count; });
252
253 EXPECT_EQ(count, 3);
254
255 PayloadsVec expected_payloads = {{kUrl1, absl::Cord(kPayload1)},
256 {kUrl2, absl::Cord(kPayload2)},
257 {kUrl3, absl::Cord(kPayload3)}};
258
259 // Test that we visit all the payloads in the status.
260 PayloadsVec visited_payloads = AllVisitedPayloads(bad_status);
261 EXPECT_THAT(visited_payloads, UnorderedElementsAreArray(expected_payloads));
262
263 // Test that visitation order is not consistent between run.
264 std::vector<absl::Status> scratch;
265 while (true) {
266 scratch.emplace_back(absl::StatusCode::kInternal, "fail");
267
268 scratch.back().SetPayload(kUrl1, absl::Cord(kPayload1));
269 scratch.back().SetPayload(kUrl2, absl::Cord(kPayload2));
270 scratch.back().SetPayload(kUrl3, absl::Cord(kPayload3));
271
272 if (AllVisitedPayloads(scratch.back()) != visited_payloads) {
273 break;
274 }
275 }
276 }
277
TEST(Status,ToString)278 TEST(Status, ToString) {
279 absl::Status s(absl::StatusCode::kInternal, "fail");
280 EXPECT_EQ("INTERNAL: fail", s.ToString());
281 s.SetPayload("foo", absl::Cord("bar"));
282 EXPECT_EQ("INTERNAL: fail [foo='bar']", s.ToString());
283 s.SetPayload("bar", absl::Cord("\377"));
284 EXPECT_THAT(s.ToString(),
285 AllOf(HasSubstr("INTERNAL: fail"), HasSubstr("[foo='bar']"),
286 HasSubstr("[bar='\\xff']")));
287 }
288
TEST(Status,ToStringMode)289 TEST(Status, ToStringMode) {
290 absl::Status s(absl::StatusCode::kInternal, "fail");
291 s.SetPayload("foo", absl::Cord("bar"));
292 s.SetPayload("bar", absl::Cord("\377"));
293
294 EXPECT_EQ("INTERNAL: fail",
295 s.ToString(absl::StatusToStringMode::kWithNoExtraData));
296
297 EXPECT_THAT(s.ToString(absl::StatusToStringMode::kWithPayload),
298 AllOf(HasSubstr("INTERNAL: fail"), HasSubstr("[foo='bar']"),
299 HasSubstr("[bar='\\xff']")));
300
301 EXPECT_THAT(s.ToString(absl::StatusToStringMode::kWithEverything),
302 AllOf(HasSubstr("INTERNAL: fail"), HasSubstr("[foo='bar']"),
303 HasSubstr("[bar='\\xff']")));
304
305 EXPECT_THAT(s.ToString(~absl::StatusToStringMode::kWithPayload),
306 AllOf(HasSubstr("INTERNAL: fail"), Not(HasSubstr("[foo='bar']")),
307 Not(HasSubstr("[bar='\\xff']"))));
308 }
309
EraseAndReturn(const absl::Status & base)310 absl::Status EraseAndReturn(const absl::Status& base) {
311 absl::Status copy = base;
312 EXPECT_TRUE(copy.ErasePayload(kUrl1));
313 return copy;
314 }
315
TEST(Status,CopyOnWriteForErasePayload)316 TEST(Status, CopyOnWriteForErasePayload) {
317 {
318 absl::Status base(absl::StatusCode::kInvalidArgument, "fail");
319 base.SetPayload(kUrl1, absl::Cord(kPayload1));
320 EXPECT_TRUE(base.GetPayload(kUrl1).has_value());
321 absl::Status copy = EraseAndReturn(base);
322 EXPECT_TRUE(base.GetPayload(kUrl1).has_value());
323 EXPECT_FALSE(copy.GetPayload(kUrl1).has_value());
324 }
325 {
326 absl::Status base(absl::StatusCode::kInvalidArgument, "fail");
327 base.SetPayload(kUrl1, absl::Cord(kPayload1));
328 absl::Status copy = base;
329
330 EXPECT_TRUE(base.GetPayload(kUrl1).has_value());
331 EXPECT_TRUE(copy.GetPayload(kUrl1).has_value());
332
333 EXPECT_TRUE(base.ErasePayload(kUrl1));
334
335 EXPECT_FALSE(base.GetPayload(kUrl1).has_value());
336 EXPECT_TRUE(copy.GetPayload(kUrl1).has_value());
337 }
338 }
339
TEST(Status,CopyConstructor)340 TEST(Status, CopyConstructor) {
341 {
342 absl::Status status;
343 absl::Status copy(status);
344 EXPECT_EQ(copy, status);
345 }
346 {
347 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
348 absl::Status copy(status);
349 EXPECT_EQ(copy, status);
350 }
351 {
352 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
353 status.SetPayload(kUrl1, absl::Cord(kPayload1));
354 absl::Status copy(status);
355 EXPECT_EQ(copy, status);
356 }
357 }
358
TEST(Status,CopyAssignment)359 TEST(Status, CopyAssignment) {
360 absl::Status assignee;
361 {
362 absl::Status status;
363 assignee = status;
364 EXPECT_EQ(assignee, status);
365 }
366 {
367 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
368 assignee = status;
369 EXPECT_EQ(assignee, status);
370 }
371 {
372 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
373 status.SetPayload(kUrl1, absl::Cord(kPayload1));
374 assignee = status;
375 EXPECT_EQ(assignee, status);
376 }
377 }
378
TEST(Status,CopyAssignmentIsNotRef)379 TEST(Status, CopyAssignmentIsNotRef) {
380 const absl::Status status_orig(absl::StatusCode::kInvalidArgument, "message");
381 absl::Status status_copy = status_orig;
382 EXPECT_EQ(status_orig, status_copy);
383 status_copy.SetPayload(kUrl1, absl::Cord(kPayload1));
384 EXPECT_NE(status_orig, status_copy);
385 }
386
TEST(Status,MoveConstructor)387 TEST(Status, MoveConstructor) {
388 {
389 absl::Status status;
390 absl::Status copy(absl::Status{});
391 EXPECT_EQ(copy, status);
392 }
393 {
394 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
395 absl::Status copy(
396 absl::Status(absl::StatusCode::kInvalidArgument, "message"));
397 EXPECT_EQ(copy, status);
398 }
399 {
400 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
401 status.SetPayload(kUrl1, absl::Cord(kPayload1));
402 absl::Status copy1(status);
403 absl::Status copy2(std::move(status));
404 EXPECT_EQ(copy1, copy2);
405 }
406 }
407
TEST(Status,MoveAssignment)408 TEST(Status, MoveAssignment) {
409 absl::Status assignee;
410 {
411 absl::Status status;
412 assignee = absl::Status();
413 EXPECT_EQ(assignee, status);
414 }
415 {
416 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
417 assignee = absl::Status(absl::StatusCode::kInvalidArgument, "message");
418 EXPECT_EQ(assignee, status);
419 }
420 {
421 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
422 status.SetPayload(kUrl1, absl::Cord(kPayload1));
423 absl::Status copy(status);
424 assignee = std::move(status);
425 EXPECT_EQ(assignee, copy);
426 }
427 {
428 absl::Status status(absl::StatusCode::kInvalidArgument, "message");
429 absl::Status copy(status);
430 status = static_cast<absl::Status&&>(status);
431 EXPECT_EQ(status, copy);
432 }
433 }
434
TEST(Status,Update)435 TEST(Status, Update) {
436 absl::Status s;
437 s.Update(absl::OkStatus());
438 EXPECT_TRUE(s.ok());
439 const absl::Status a(absl::StatusCode::kCancelled, "message");
440 s.Update(a);
441 EXPECT_EQ(s, a);
442 const absl::Status b(absl::StatusCode::kInternal, "other message");
443 s.Update(b);
444 EXPECT_EQ(s, a);
445 s.Update(absl::OkStatus());
446 EXPECT_EQ(s, a);
447 EXPECT_FALSE(s.ok());
448 }
449
TEST(Status,Equality)450 TEST(Status, Equality) {
451 absl::Status ok;
452 absl::Status no_payload = absl::CancelledError("no payload");
453 absl::Status one_payload = absl::InvalidArgumentError("one payload");
454 one_payload.SetPayload(kUrl1, absl::Cord(kPayload1));
455 absl::Status two_payloads = one_payload;
456 two_payloads.SetPayload(kUrl2, absl::Cord(kPayload2));
457 const std::array<absl::Status, 4> status_arr = {ok, no_payload, one_payload,
458 two_payloads};
459 for (int i = 0; i < status_arr.size(); i++) {
460 for (int j = 0; j < status_arr.size(); j++) {
461 if (i == j) {
462 EXPECT_TRUE(status_arr[i] == status_arr[j]);
463 EXPECT_FALSE(status_arr[i] != status_arr[j]);
464 } else {
465 EXPECT_TRUE(status_arr[i] != status_arr[j]);
466 EXPECT_FALSE(status_arr[i] == status_arr[j]);
467 }
468 }
469 }
470 }
471
TEST(Status,Swap)472 TEST(Status, Swap) {
473 auto test_swap = [](const absl::Status& s1, const absl::Status& s2) {
474 absl::Status copy1 = s1, copy2 = s2;
475 swap(copy1, copy2);
476 EXPECT_EQ(copy1, s2);
477 EXPECT_EQ(copy2, s1);
478 };
479 const absl::Status ok;
480 const absl::Status no_payload(absl::StatusCode::kAlreadyExists, "no payload");
481 absl::Status with_payload(absl::StatusCode::kInternal, "with payload");
482 with_payload.SetPayload(kUrl1, absl::Cord(kPayload1));
483 test_swap(ok, no_payload);
484 test_swap(no_payload, ok);
485 test_swap(ok, with_payload);
486 test_swap(with_payload, ok);
487 test_swap(no_payload, with_payload);
488 test_swap(with_payload, no_payload);
489 }
490
TEST(StatusErrno,ErrnoToStatusCode)491 TEST(StatusErrno, ErrnoToStatusCode) {
492 EXPECT_EQ(absl::ErrnoToStatusCode(0), absl::StatusCode::kOk);
493
494 // Spot-check a few errno values.
495 EXPECT_EQ(absl::ErrnoToStatusCode(EINVAL),
496 absl::StatusCode::kInvalidArgument);
497 EXPECT_EQ(absl::ErrnoToStatusCode(ENOENT), absl::StatusCode::kNotFound);
498
499 // We'll pick a very large number so it hopefully doesn't collide to errno.
500 EXPECT_EQ(absl::ErrnoToStatusCode(19980927), absl::StatusCode::kUnknown);
501 }
502
TEST(StatusErrno,ErrnoToStatus)503 TEST(StatusErrno, ErrnoToStatus) {
504 absl::Status status = absl::ErrnoToStatus(ENOENT, "Cannot open 'path'");
505 EXPECT_EQ(status.code(), absl::StatusCode::kNotFound);
506 EXPECT_EQ(status.message(), "Cannot open 'path': No such file or directory");
507 }
508 } // namespace
509