No-op changes for internal experiment

PiperOrigin-RevId: 925032057
Change-Id: I8f3a4f5bb4f079211a6e1cc5dfc8c9683d11e53e

Author: Abseil Team

CMake/AbseilDll.cmake

@@ -22,6 +22,7 @@ set(ABSL_INTERNAL_DLL_FILES
   "base/internal/dynamic_annotations.h"
   "base/internal/endian.h"
   "base/internal/errno_saver.h"
+  "base/internal/hardening.cc"
   "base/internal/hardening.h"
   "base/internal/hide_ptr.h"
   "base/internal/iterator_traits.h"

absl/base/BUILD.bazel

@@ -80,6 +80,7 @@ cc_library(
 
 cc_library(
     name = "hardening",
+    srcs = ["internal/hardening.cc"],
     hdrs = [
         "internal/hardening.h",
     ],

absl/base/CMakeLists.txt

@@ -61,6 +61,8 @@ absl_cc_library(
     hardening
   HDRS
     "internal/hardening.h"
+  SRCS
+    "internal/hardening.cc"
   DEPS
     absl::config
     absl::core_headers

absl/base/internal/hardening.cc

@@ -0,0 +1,34 @@
+//
+// 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/base/internal/hardening.h"
+
+#include <atomic>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace base_internal {
+
+void SetAbslHardeningEnabled([[maybe_unused]] bool enabled) {
+}
+
+}  // namespace base_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl

absl/base/internal/hardening.h

@@ -32,6 +32,8 @@ ABSL_NAMESPACE_BEGIN
 
 namespace base_internal {
 
+void SetAbslHardeningEnabled(bool enabled);
+
 // `HardeningAssert` performs runtime checks when Abseil Hardening is enabled,
 // even if `NDEBUG` is defined.
 //

absl/base/internal/hardening_test.cc

@@ -42,14 +42,28 @@ bool IsHardenedSlow() {
   return hardened;
 }
 
-TEST(HardeningTest, HardeningAssertSlow) {
+class HardeningTest : public testing::Test {
+ public:
+  ~HardeningTest() override {
+    absl::base_internal::SetAbslHardeningEnabled(true);
+  }
+};
+
+class HardeningDeathTest : public testing::Test {
+ public:
+  ~HardeningDeathTest() override {
+    absl::base_internal::SetAbslHardeningEnabled(true);
+  }
+};
+
+TEST_F(HardeningTest, HardeningAssertSlow) {
   absl::base_internal::HardeningAssertSlow(true);
   if (!IsHardenedSlow()) {
     absl::base_internal::HardeningAssertSlow(false);
   }
 }
 
-TEST(HardeningDeathTest, HardeningAssertSlow) {
+TEST_F(HardeningDeathTest, HardeningAssertSlow) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardenedSlow()) {
     // The underlying mechanism of termination varies, and may include SIGILL
@@ -59,107 +73,114 @@ TEST(HardeningDeathTest, HardeningAssertSlow) {
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertGT) {
+TEST_F(HardeningTest, HardeningAssertGT) {
   absl::base_internal::HardeningAssertGT(1, 0);
 }
 
-TEST(HardeningDeathTest, HardeningAssertGT) {
+TEST_F(HardeningDeathTest, HardeningAssertGT) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertGT(1, 1), "");
     EXPECT_DEATH(absl::base_internal::HardeningAssertGT(0, 1), "");
   }
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertGE) {
+TEST_F(HardeningTest, HardeningAssertGE) {
   absl::base_internal::HardeningAssertGE(1, 0);
   absl::base_internal::HardeningAssertGE(1, 1);
 }
 
-TEST(HardeningDeathTest, HardeningAssertGE) {
+TEST_F(HardeningDeathTest, HardeningAssertGE) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertGE(0, 1), "");
   }
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertLT) {
+TEST_F(HardeningTest, HardeningAssertLT) {
   absl::base_internal::HardeningAssertLT(0, 1);
 }
 
-TEST(HardeningDeathTest, HardeningAssertLT) {
+TEST_F(HardeningDeathTest, HardeningAssertLT) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertLT(1, 1), "");
     EXPECT_DEATH(absl::base_internal::HardeningAssertLT(1, 0), "");
   }
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertLE) {
+TEST_F(HardeningTest, HardeningAssertLE) {
   absl::base_internal::HardeningAssertLE(0, 1);
   absl::base_internal::HardeningAssertLE(1, 1);
 }
 
-TEST(HardeningDeathTest, HardeningAssertLE) {
+TEST_F(HardeningDeathTest, HardeningAssertLE) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertLE(1, 0), "");
   }
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertInBounds) {
+TEST_F(HardeningTest, HardeningAssertInBounds) {
   absl::base_internal::HardeningAssertInBounds(0, 10);
 }
 
-TEST(HardeningDeathTest, HardeningAssertInBounds) {
+TEST_F(HardeningDeathTest, HardeningAssertInBounds) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertInBounds(10, 10), "");
   }
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertNonEmpty) {
+TEST_F(HardeningTest, HardeningAssertNonEmpty) {
   std::vector<int> v = {1};
   absl::base_internal::HardeningAssertNonEmpty(v);
 }
 
-TEST(HardeningDeathTest, HardeningAssertNonEmpty) {
+TEST_F(HardeningDeathTest, HardeningAssertNonEmpty) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
     std::vector<int> v = {};
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertNonEmpty(v), "");
   }
 #endif
 }
 
-TEST(HardeningTest, HardeningAssertNonNull) {
+TEST_F(HardeningTest, HardeningAssertNonNull) {
   int x = 1;
   absl::base_internal::HardeningAssertNonNull(&x);
 }
 
-TEST(HardeningDeathTest, HardeningAssertNonNull) {
+TEST_F(HardeningDeathTest, HardeningAssertNonNull) {
 #if GTEST_HAS_DEATH_TEST
   if (IsHardened()) {
     // The underlying mechanism of termination varies, and may include SIGILL
     // or SIGABRT.
     int *x = nullptr;
+    absl::base_internal::SetAbslHardeningEnabled(true);
     EXPECT_DEATH(absl::base_internal::HardeningAssertNonNull(x), "");
   }
 #endif

absl/base/macros.h

@@ -28,6 +28,7 @@
 #ifndef ABSL_BASE_MACROS_H_
 #define ABSL_BASE_MACROS_H_
 
+#include <atomic>
 #include <cassert>
 #include <cstddef>
 
@@ -157,12 +158,12 @@ ABSL_NAMESPACE_END
 // See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
 // hardened mode.
 #if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
-#define ABSL_HARDENING_ASSERT(expr)    \
-  do {                                 \
-    if (!ABSL_PREDICT_TRUE((expr))) {  \
-      ABSL_INTERNAL_HARDENING_ABORT(); \
-    }                                  \
-  } while (false)
+ #define ABSL_HARDENING_ASSERT(expr)    \
+   do {                                 \
+     if (!ABSL_PREDICT_TRUE((expr))) {  \
+       ABSL_INTERNAL_HARDENING_ABORT(); \
+     }                                  \
+   } while (false)
 #else
 #define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
 #endif