re2 1.24.1 → 1.25.0

package/vendor/abseil-cpp/absl/status/status_builder_test.cc

@@ -0,0 +1,380 @@
+// Copyright 2026 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/status/status_builder.h"
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/log/log.h"
+#include "absl/log/log_entry.h"
+#include "absl/log/log_sink.h"
+#include "absl/status/status.h"
+#include "absl/status/status_matchers.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/source_location.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace {
+
+using ::absl_testing::StatusIs;
+using ::testing::AllOf;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::IsEmpty;
+using ::testing::Pointee;
+using ::testing::Property;
+
+// Converts a StatusBuilder to a Status.
+absl::Status ToStatus(const StatusBuilder& s) { return s; }
+
+// Converts a StatusBuilder to a StatusOr<T>.
+template <typename T>
+absl::StatusOr<T> ToStatusOr(const StatusBuilder& s) {
+  return s;
+}
+
+void CheckSourceLocation(
+    const absl::Status& status, std::vector<int> lines = {},
+    absl::SourceLocation loc = absl::SourceLocation::current()) {
+  ASSERT_EQ(status.GetSourceLocations().size(), lines.size())
+      << "Size check failed at " << loc.line();
+  for (size_t i = 0; i < lines.size(); ++i) {
+    EXPECT_EQ(absl::string_view(status.GetSourceLocations()[i].file_name()),
+              absl::string_view(loc.file_name()))
+        << "File name check failed at " << loc.line();
+    EXPECT_EQ(status.GetSourceLocations()[i].line(), lines[i])
+        << "Line check failed at " << loc.line();
+  }
+}
+
+class StatusBuilderTest : public ::testing::Test {};
+
+TEST_F(StatusBuilderTest, Size) {
+  EXPECT_LE(sizeof(StatusBuilder), 40)
+      << "Relax this test with caution and thorough testing. If StatusBuilder "
+         "is too large it can potentially blow stacks, especially in debug "
+         "builds. See the comments for StatusBuilder::Rep.";
+}
+
+TEST_F(StatusBuilderTest, ExplicitSourceLocation) {
+  const absl::SourceLocation kLocation = absl::SourceLocation::current();
+
+  {
+    const StatusBuilder builder(absl::OkStatus(), kLocation);
+    EXPECT_THAT(builder.source_location().file_name(),
+                Eq(kLocation.file_name()));
+    EXPECT_THAT(builder.source_location().line(), Eq(kLocation.line()));
+  }
+}
+
+TEST_F(StatusBuilderTest, ImplicitSourceLocation) {
+  const StatusBuilder builder(absl::OkStatus());
+  auto loc = absl::SourceLocation::current();
+  EXPECT_THAT(builder.source_location().file_name(),
+              AnyOf(Eq(absl::string_view(loc.file_name())),
+                    Eq(absl::string_view("<source_location>"))));
+  EXPECT_THAT(builder.source_location().line(),
+              AnyOf(Eq(1), Eq(loc.line() - 1)));
+}
+
+testing::Matcher<absl::SourceLocation> SourceLocationIs(
+    absl::SourceLocation loc) {
+  return AnyOf(
+      AllOf(Property(&absl::SourceLocation::file_name, Eq(loc.file_name())),
+            Property(&absl::SourceLocation::line, Eq(loc.line()))),
+      // Fallback for platforms that don't support source locations.
+      AllOf(Property(&absl::SourceLocation::file_name, Eq("<source_location>")),
+            Property(&absl::SourceLocation::line, Eq(1))));
+}
+
+TEST_F(StatusBuilderTest, GetPreviousSourceLocations) {
+  const absl::SourceLocation loc0 = absl::SourceLocation::current();
+  absl::Status status = absl::InvalidArgumentError("hi", loc0);
+  const absl::SourceLocation loc1 = absl::SourceLocation::current();
+  status.AddSourceLocation(loc1);
+  const absl::SourceLocation loc2 = absl::SourceLocation::current();
+  status.AddSourceLocation(loc2);
+
+  // The builder's location is not included.
+  const StatusBuilder builder(status);
+  EXPECT_THAT(builder.GetPreviousSourceLocations(),
+              ElementsAre(SourceLocationIs(loc0), SourceLocationIs(loc1),
+                          SourceLocationIs(loc2)));
+}
+
+TEST_F(StatusBuilderTest, EmptyGetPreviousSourceLocationsForNewFromStatusCode) {
+  const StatusBuilder builder(absl::StatusCode::kInvalidArgument);
+  EXPECT_THAT(builder.GetPreviousSourceLocations(), IsEmpty());
+}
+
+TEST_F(StatusBuilderTest, StatusCode) {
+  // OK
+  {
+    const StatusBuilder builder(absl::StatusCode::kOk);
+    EXPECT_TRUE(builder.ok());
+    EXPECT_THAT(builder.code(), Eq(absl::StatusCode::kOk));
+  }
+  // Non-OK code
+  {
+    const StatusBuilder builder(absl::StatusCode::kInvalidArgument);
+    EXPECT_FALSE(builder.ok());
+    EXPECT_THAT(builder.code(), Eq(absl::StatusCode::kInvalidArgument));
+  }
+}
+
+TEST_F(StatusBuilderTest, OkIgnoresStuff) {
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::OkStatus(), absl::SourceLocation())
+                       << "booyah"),
+              Eq(absl::OkStatus()));
+}
+
+TEST_F(StatusBuilderTest, Streaming) {
+  EXPECT_THAT(
+      ToStatus(StatusBuilder(absl::CancelledError(), absl::SourceLocation())
+               << "booyah"),
+      Eq(absl::CancelledError("booyah")));
+  EXPECT_THAT(
+      ToStatus(
+          StatusBuilder(absl::AbortedError("hello"), absl::SourceLocation())
+          << "world"),
+      Eq(absl::AbortedError("hello; world")));
+}
+
+TEST_F(StatusBuilderTest, PrependLvalue) {
+  {
+    StatusBuilder builder(absl::CancelledError(), absl::SourceLocation());
+    EXPECT_THAT(ToStatus(builder.SetPrepend() << "booyah"),
+                Eq(absl::CancelledError("booyah")));
+  }
+  {
+    StatusBuilder builder(absl::AbortedError(" hello"), absl::SourceLocation());
+    EXPECT_THAT(ToStatus(builder.SetPrepend() << "world"),
+                Eq(absl::AbortedError("world hello")));
+  }
+}
+
+TEST_F(StatusBuilderTest, PrependRvalue) {
+  EXPECT_THAT(
+      ToStatus(StatusBuilder(absl::CancelledError(), absl::SourceLocation())
+                   .SetPrepend()
+               << "booyah"),
+      Eq(absl::CancelledError("booyah")));
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError(" hello"),
+                                     absl::SourceLocation())
+                           .SetPrepend()
+                       << "world"),
+              Eq(absl::AbortedError("world hello")));
+}
+
+TEST_F(StatusBuilderTest, AppendLvalue) {
+  {
+    StatusBuilder builder(absl::CancelledError(), absl::SourceLocation());
+    EXPECT_THAT(ToStatus(builder.SetAppend() << "booyah"),
+                Eq(absl::CancelledError("booyah")));
+  }
+  {
+    StatusBuilder builder(absl::AbortedError("hello"), absl::SourceLocation());
+    EXPECT_THAT(ToStatus(builder.SetAppend() << " world"),
+                Eq(absl::AbortedError("hello world")));
+  }
+}
+
+TEST_F(StatusBuilderTest, AppendRvalue) {
+  EXPECT_THAT(
+      ToStatus(StatusBuilder(absl::CancelledError(), absl::SourceLocation())
+                   .SetAppend()
+               << "booyah"),
+      Eq(absl::CancelledError("booyah")));
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .SetAppend()
+                       << " world"),
+              Eq(absl::AbortedError("hello world")));
+}
+
+TEST_F(StatusBuilderTest, WithRvalueRef) {
+  auto policy = [](StatusBuilder sb) { return sb << "policy"; };
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .With(policy)),
+              Eq(absl::AbortedError("hello; policy")));
+}
+
+TEST_F(StatusBuilderTest, WithRef) {
+  auto policy = [](StatusBuilder sb) { return sb << "policy"; };
+  StatusBuilder sb(absl::AbortedError("zomg"), absl::SourceLocation());
+  EXPECT_THAT(ToStatus(sb.With(policy)),
+              Eq(absl::AbortedError("zomg; policy")));
+}
+
+TEST_F(StatusBuilderTest, WithTypeChange) {
+  auto policy = [](StatusBuilder sb) -> std::string {
+    return sb.ok() ? "true" : "false";
+  };
+  EXPECT_EQ(StatusBuilder(absl::CancelledError(), absl::SourceLocation())
+                .With(policy),
+            "false");
+  EXPECT_EQ(
+      StatusBuilder(absl::OkStatus(), absl::SourceLocation()).With(policy),
+      "true");
+}
+
+struct MoveOnlyAdaptor {
+  std::unique_ptr<int> value;
+  std::unique_ptr<int> operator()(const absl::Status&) && {
+    return std::move(value);
+  }
+};
+
+TEST_F(StatusBuilderTest, WithMoveOnlyAdaptor) {
+  StatusBuilder sb(absl::AbortedError("zomg"), absl::SourceLocation());
+  EXPECT_THAT(sb.With(MoveOnlyAdaptor{std::make_unique<int>(100)}),
+              Pointee(100));
+  EXPECT_THAT(StatusBuilder(absl::AbortedError("zomg"), absl::SourceLocation())
+                  .With(MoveOnlyAdaptor{std::make_unique<int>(100)}),
+              Pointee(100));
+}
+
+struct StringifiableType {
+  absl::string_view message;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const StringifiableType& o) {
+    sink.Append(o.message);
+  }
+};
+
+class MockLogSink : public absl::LogSink {
+ public:
+  MOCK_METHOD(void, Send, (const absl::LogEntry&), (override));
+};
+
+TEST(WithExtraMessagePolicyTest, AppendsToExtraMessage) {
+  // The policy simply calls operator<< on the builder; the following examples
+  // demonstrate that, without duplicating all of the above tests.
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .With(ExtraMessage("world"))),
+              Eq(absl::AbortedError("hello; world")));
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .With(ExtraMessage() << "world")),
+              Eq(absl::AbortedError("hello; world")));
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .With(ExtraMessage("world"))
+                           .With(ExtraMessage("!"))),
+              Eq(absl::AbortedError("hello; world!")));
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .With(ExtraMessage("world, "))
+                           .SetPrepend()),
+              Eq(absl::AbortedError("world, hello")));
+  EXPECT_THAT(ToStatus(StatusBuilder(absl::AbortedError("hello"),
+                                     absl::SourceLocation())
+                           .With(ExtraMessage() << StringifiableType{"world"})),
+              Eq(absl::AbortedError("hello; world")));
+
+  // The above examples use temporary StatusBuilder rvalues; verify things also
+  // work fine when StatusBuilder is an lvalue.
+  StatusBuilder builder(absl::AbortedError("hello"), absl::SourceLocation());
+  EXPECT_THAT(
+      ToStatus(builder.With(ExtraMessage("world")).With(ExtraMessage("!"))),
+      Eq(absl::AbortedError("hello; world!")));
+}
+
+TEST(WithExtraMessagePolicyTest,
+     ExtraMessageStreamOperatorPreservesRvalueness) {
+  static_assert(
+      std::is_same_v<ExtraMessage&&, decltype(ExtraMessage() << "foo")>);
+}
+
+TEST_F(StatusBuilderTest, StatusSourceLocationChaining) {
+  {
+    absl::Status src = absl::OkStatus();
+    CheckSourceLocation(src);
+    CheckSourceLocation(ToStatus(StatusBuilder(src, absl::SourceLocation())));
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current())));
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current()) << "hmm"));
+  }
+  {
+    absl::Status src = absl::Status(absl::StatusCode::kCancelled, "");
+    CheckSourceLocation(src);
+    CheckSourceLocation(ToStatus(StatusBuilder(src, absl::SourceLocation())));
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current())));
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current()) << ""));
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current()) << "hmm"),
+        {__builtin_LINE() - 1});
+  }
+  {
+    absl::Status src = absl::Status(absl::StatusCode::kCancelled, "msg",
+                                    absl::SourceLocation());
+    CheckSourceLocation(src);
+    CheckSourceLocation(ToStatus(StatusBuilder(src, absl::SourceLocation())));
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current())),
+        {__builtin_LINE() - 1});
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current()) << "hmm"),
+        {__builtin_LINE() - 1});
+  }
+  {
+    absl::Status src = absl::Status(absl::StatusCode::kCancelled, "msg");
+    int src_line = __builtin_LINE() - 1;
+    CheckSourceLocation(src, {src_line});
+    CheckSourceLocation(ToStatus(StatusBuilder(src, absl::SourceLocation())),
+                        {src_line});
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current())),
+        {src_line, __builtin_LINE() - 1});
+    CheckSourceLocation(
+        ToStatus(StatusBuilder(src, absl::SourceLocation::current()) << "hmm"),
+        {src_line, __builtin_LINE() - 1});
+  }
+}
+
+TEST_F(StatusBuilderTest, SetErrorCode) {
+  StatusBuilder builder;
+  builder.SetCode(absl::StatusCode::kResourceExhausted);
+  LOG(INFO) << "Builder code: " << builder;
+  EXPECT_FALSE(builder.ok());
+  EXPECT_EQ(builder.code(), absl::StatusCode::kResourceExhausted);
+}
+
+TEST_F(StatusBuilderTest, BuilderToStatusOrStatusShouldGiveErrorStatusOr) {
+  absl::StatusOr<absl::Status> value = StatusBuilder(absl::CancelledError());
+  ASSERT_FALSE(value.ok());
+  EXPECT_THAT(value.status(), StatusIs(absl::StatusCode::kCancelled));
+}
+
+}  // namespace
+ABSL_NAMESPACE_END
+}  // namespace absl