Release `ABSL_EXPECT_OK` and `ABSL_ASSERT_OK`.

These are convenience macros for `EXPECT_THAT(..., IsOk())` and
`ASSERT_THAT(..., IsOk())`, which can sometimes be more convenient to write.

This also documents a `#define` flag that defines the unqualified (i.e.
`EXPECT_OK` and `ASSERT_OK` versions of these macros, though they're
not preferred.

PiperOrigin-RevId: 825052892
Change-Id: Ib699709fbda3bc4885f57fc2842fb852c6243a2f

absl/status/BUILD.bazel

diff --git a/absl/status/BUILD.bazel b/absl/status/BUILD.bazel
index 7537797..394222f 100644
--- a/absl/status/BUILD.bazel
+++ b/absl/status/BUILD.bazel
@@ -192,3 +192,20 @@
         "@googletest//:gtest_main",
     ],
 )
+
+cc_test(
+    name = "status_matchers_with_unqualified_macros_test",
+    size = "small",
+    srcs = ["status_matchers_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    local_defines = ["ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS"],
+    deps = [
+        ":status",
+        ":status_matchers",
+        ":statusor",
+        "//absl/strings",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)

absl/status/CMakeLists.txt

diff --git a/absl/status/CMakeLists.txt b/absl/status/CMakeLists.txt
index e140365..d0d134c 100644
--- a/absl/status/CMakeLists.txt
+++ b/absl/status/CMakeLists.txt
@@ -141,3 +141,19 @@
     absl::status_matchers
     GTest::gmock_main
 )
+
+absl_cc_test(
+  NAME
+    status_matchers_with_unqualified_macros_test
+  SRCS
+   "status_matchers_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEFINES
+    "ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS"
+  DEPS
+    absl::status
+    absl::statusor
+    absl::status_matchers
+    GTest::gmock_main
+)

absl/status/status_matchers.h

diff --git a/absl/status/status_matchers.h b/absl/status/status_matchers.h
index 837660e..6db7355 100644
--- a/absl/status/status_matchers.h
+++ b/absl/status/status_matchers.h
@@ -20,6 +20,24 @@
 //
 // Defines the following utilities:
 //
+//   =================
+//   ABSL_EXPECT_OK(s)
+//
+//   ABSL_ASSERT_OK(s)
+//   =================
+//   Convenience macros for `EXPECT_THAT(s, IsOk())`, where `s` is either
+//   a `Status` or a `StatusOr<T>` or a `StatusProto`.
+//
+//   There are no EXPECT_NOT_OK/ASSERT_NOT_OK macros since they would not
+//   provide much value (when they fail, they would just print the OK status
+//   which conveys no more information than `EXPECT_FALSE(s.ok())`. You can
+//   of course use `EXPECT_THAT(s, Not(IsOk()))` if you prefer _THAT style.
+//
+//   If you want to check for particular errors, better alternatives are:
+//   EXPECT_THAT(s, StatusIs(expected_error));
+//   EXPECT_THAT(s, StatusIs(_, _, HasSubstr("expected error")));
+//
+//
 //   ===============
 //   `IsOkAndHolds(m)`
 //   ===============
@@ -76,6 +94,13 @@
 namespace absl_testing {
 ABSL_NAMESPACE_BEGIN
 
+// Macros for testing the results of functions that return absl::Status or
+// absl::StatusOr<T> (for any type T).
+#define ABSL_EXPECT_OK(expression) \
+  EXPECT_THAT(expression, ::absl_testing::IsOk())
+#define ABSL_ASSERT_OK(expression) \
+  ASSERT_THAT(expression, ::absl_testing::IsOk())
+
 // Returns a gMock matcher that matches a StatusOr<> whose status is
 // OK and whose value matches the inner matcher.
 template <typename InnerMatcherT>
@@ -112,6 +137,29 @@
   return status_internal::IsOkMatcher();
 }
 
+// By defining ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS, this library also
+// provides unqualified versions of macros
+//
+// Unqualified macro names are likely to collide with those other projects, and
+// so are not recommended.  Further, this is true of any transitive dependency
+// of Abseil; it is impossible to be confident no downstream library will not
+// also define these macros itself nor depend on a different library that also
+// defines them.
+//
+// To enable this, define `ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS`
+// preferably at the command line, e.g.
+// `-DABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS` or
+// `local_defines = ["ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS"]` if using
+// Bazel.
+//
+// These are turned on by default inside Google's internal codebase where their
+// use is historically ubiquitous.  Other OSS Google projects should use the
+// qualified versions or the `EXPECT_THAT(..., IsOk())` form.
+#ifdef ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+#define EXPECT_OK(expression) ABSL_EXPECT_OK(expression)
+#define ASSERT_OK(expression) ABSL_ASSERT_OK(expression)
+#endif  // ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+
 ABSL_NAMESPACE_END
 }  // namespace absl_testing
 

absl/status/status_matchers_test.cc

diff --git a/absl/status/status_matchers_test.cc b/absl/status/status_matchers_test.cc
index 51a5f27..8656b2d 100644
--- a/absl/status/status_matchers_test.cc
+++ b/absl/status/status_matchers_test.cc
@@ -39,6 +39,33 @@
 using ::testing::Not;
 using ::testing::Ref;
 
+TEST(StatusMatcherTest, AbslExpectAssertOk) {
+  ABSL_EXPECT_OK(absl::OkStatus());
+  ABSL_ASSERT_OK(absl::OkStatus());
+  EXPECT_NONFATAL_FAILURE(ABSL_EXPECT_OK(absl::InternalError("Smigla error")),
+                          "Smigla error");
+  EXPECT_FATAL_FAILURE(ABSL_ASSERT_OK(absl::InternalError("Smigla error")),
+                       "Smigla error");
+}
+
+TEST(StatusMatcherTest, ExpectAssertOk) {
+#ifdef ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+  EXPECT_OK(absl::OkStatus());
+  ASSERT_OK(absl::OkStatus());
+  EXPECT_NONFATAL_FAILURE(EXPECT_OK(absl::InternalError("Smigla error")),
+                          "Smigla error");
+  EXPECT_FATAL_FAILURE(ASSERT_OK(absl::InternalError("Smigla error")),
+                       "Smigla error");
+#else
+#ifdef EXPECT_OK
+  static_assert(false, "EXPECT_OK defined despite being turned off.");
+#endif  // EXPECT_OK
+#ifdef ASSERT_OK
+  static_assert(false, "ASSERT_OK defined despite being turned off.");
+#endif  // ASSERT_OK
+#endif  // ABSL_DEFINE_UNQUALIFIED_STATUS_TESTING_MACROS
+}
+
 TEST(StatusMatcherTest, StatusIsOk) { EXPECT_THAT(absl::OkStatus(), IsOk()); }
 
 TEST(StatusMatcherTest, StatusOrIsOk) {