status_matchers_test.cc (6323B)
1 // Copyright 2024 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 // ----------------------------------------------------------------------------- 16 // File: status_matchers_test.cc 17 // ----------------------------------------------------------------------------- 18 #include "absl/status/status_matchers.h" 19 20 #include <string> 21 22 #include "gmock/gmock.h" 23 #include "gtest/gtest-spi.h" 24 #include "gtest/gtest.h" 25 #include "absl/status/status.h" 26 #include "absl/status/statusor.h" 27 #include "absl/strings/string_view.h" 28 29 namespace { 30 31 using ::absl_testing::IsOk; 32 using ::absl_testing::IsOkAndHolds; 33 using ::absl_testing::StatusIs; 34 using ::testing::Eq; 35 using ::testing::Gt; 36 using ::testing::MatchesRegex; 37 38 TEST(StatusMatcherTest, StatusIsOk) { EXPECT_THAT(absl::OkStatus(), IsOk()); } 39 40 TEST(StatusMatcherTest, StatusOrIsOk) { 41 absl::StatusOr<int> ok_int = {0}; 42 EXPECT_THAT(ok_int, IsOk()); 43 } 44 45 TEST(StatusMatcherTest, StatusIsNotOk) { 46 absl::Status error = absl::UnknownError("Smigla"); 47 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(error, IsOk()), "Smigla"); 48 } 49 50 TEST(StatusMatcherTest, StatusOrIsNotOk) { 51 absl::StatusOr<int> error = absl::UnknownError("Smigla"); 52 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(error, IsOk()), "Smigla"); 53 } 54 55 TEST(StatusMatcherTest, IsOkAndHolds) { 56 absl::StatusOr<int> ok_int = {4}; 57 absl::StatusOr<absl::string_view> ok_str = {"text"}; 58 EXPECT_THAT(ok_int, IsOkAndHolds(4)); 59 EXPECT_THAT(ok_int, IsOkAndHolds(Gt(0))); 60 EXPECT_THAT(ok_str, IsOkAndHolds("text")); 61 } 62 63 TEST(StatusMatcherTest, IsOkAndHoldsFailure) { 64 absl::StatusOr<int> ok_int = {502}; 65 absl::StatusOr<int> error = absl::UnknownError("Smigla"); 66 absl::StatusOr<absl::string_view> ok_str = {"actual"}; 67 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(ok_int, IsOkAndHolds(0)), "502"); 68 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(error, IsOkAndHolds(0)), "Smigla"); 69 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(ok_str, IsOkAndHolds("expected")), 70 "actual"); 71 } 72 73 template <typename MatcherType, typename Value> 74 std::string Explain(const MatcherType& m, const Value& x) { 75 ::testing::StringMatchResultListener listener; 76 ExplainMatchResult(m, x, &listener); 77 return listener.str(); 78 } 79 80 TEST(StatusMatcherTest, StatusIs) { 81 absl::Status unknown = absl::UnknownError("unbekannt"); 82 absl::Status invalid = absl::InvalidArgumentError("ungueltig"); 83 EXPECT_THAT(absl::OkStatus(), StatusIs(absl::StatusCode::kOk)); 84 EXPECT_THAT(absl::OkStatus(), StatusIs(0)); 85 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown)); 86 EXPECT_THAT(unknown, StatusIs(2)); 87 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown, "unbekannt")); 88 EXPECT_THAT(invalid, StatusIs(absl::StatusCode::kInvalidArgument)); 89 EXPECT_THAT(invalid, StatusIs(3)); 90 EXPECT_THAT(invalid, 91 StatusIs(absl::StatusCode::kInvalidArgument, "ungueltig")); 92 93 auto m = StatusIs(absl::StatusCode::kInternal, "internal error"); 94 EXPECT_THAT( 95 ::testing::DescribeMatcher<absl::Status>(m), 96 MatchesRegex( 97 "has a status code that .*, and has an error message that .*")); 98 EXPECT_THAT( 99 ::testing::DescribeMatcher<absl::Status>(m, /*negation=*/true), 100 MatchesRegex( 101 "either has a status code that .*, or has an error message that .*")); 102 EXPECT_THAT(Explain(m, absl::InvalidArgumentError("internal error")), 103 Eq("whose status code is wrong")); 104 EXPECT_THAT(Explain(m, absl::InternalError("unexpected error")), 105 Eq("whose error message is wrong")); 106 } 107 108 TEST(StatusMatcherTest, StatusOrIs) { 109 absl::StatusOr<int> ok = {42}; 110 absl::StatusOr<int> unknown = absl::UnknownError("unbekannt"); 111 absl::StatusOr<absl::string_view> invalid = 112 absl::InvalidArgumentError("ungueltig"); 113 EXPECT_THAT(ok, StatusIs(absl::StatusCode::kOk)); 114 EXPECT_THAT(ok, StatusIs(0)); 115 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown)); 116 EXPECT_THAT(unknown, StatusIs(2)); 117 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown, "unbekannt")); 118 EXPECT_THAT(invalid, StatusIs(absl::StatusCode::kInvalidArgument)); 119 EXPECT_THAT(invalid, StatusIs(3)); 120 EXPECT_THAT(invalid, 121 StatusIs(absl::StatusCode::kInvalidArgument, "ungueltig")); 122 123 auto m = StatusIs(absl::StatusCode::kInternal, "internal error"); 124 EXPECT_THAT( 125 ::testing::DescribeMatcher<absl::StatusOr<int>>(m), 126 MatchesRegex( 127 "has a status code that .*, and has an error message that .*")); 128 EXPECT_THAT( 129 ::testing::DescribeMatcher<absl::StatusOr<int>>(m, /*negation=*/true), 130 MatchesRegex( 131 "either has a status code that .*, or has an error message that .*")); 132 EXPECT_THAT(Explain(m, absl::StatusOr<int>(57)), Eq("which is OK")); 133 EXPECT_THAT(Explain(m, absl::StatusOr<int>( 134 absl::InvalidArgumentError("internal error"))), 135 Eq("whose status code is wrong")); 136 EXPECT_THAT( 137 Explain(m, absl::StatusOr<int>(absl::InternalError("unexpected error"))), 138 Eq("whose error message is wrong")); 139 } 140 141 TEST(StatusMatcherTest, StatusIsFailure) { 142 absl::Status unknown = absl::UnknownError("unbekannt"); 143 absl::Status invalid = absl::InvalidArgumentError("ungueltig"); 144 EXPECT_NONFATAL_FAILURE( 145 EXPECT_THAT(absl::OkStatus(), 146 StatusIs(absl::StatusCode::kInvalidArgument)), 147 "OK"); 148 EXPECT_NONFATAL_FAILURE( 149 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kCancelled)), "UNKNOWN"); 150 EXPECT_NONFATAL_FAILURE( 151 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown, "inconnu")), 152 "unbekannt"); 153 EXPECT_NONFATAL_FAILURE( 154 EXPECT_THAT(invalid, StatusIs(absl::StatusCode::kOutOfRange)), "INVALID"); 155 EXPECT_NONFATAL_FAILURE( 156 EXPECT_THAT(invalid, 157 StatusIs(absl::StatusCode::kInvalidArgument, "invalide")), 158 "ungueltig"); 159 } 160 161 } // namespace