blob: 16393583ffe6acb88d4e327232183f88ae36fcea [file]
// Copyright 2026 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// raw_ptr_unittest.cpp: Tests for raw_ptr.
//
// These tests are run against both the no-op implementation and
// PartitionAlloc's one, so that the two do not diverge.
#include "common/partition_alloc/raw_ptr.h"
#include "common/angleutils.h"
#include "common/platform.h"
#include "common/unsafe_buffers.h"
#include <gtest/gtest.h>
#include <cstddef>
#include <memory>
#include <set>
#include <tuple>
#include <type_traits>
#include <unordered_set>
#include <utility>
#if defined(ANGLE_USE_PARTITION_ALLOC)
# include <partition_alloc/buildflags.h>
# if PA_BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS) && PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
# include <partition_alloc/dangling_raw_ptr_checks.h>
# endif
#endif
namespace
{
struct Base
{
virtual ~Base() = default;
int baseValue = 1;
};
struct Derived : public Base
{
int derivedValue = 2;
};
// Tests that default construction initializes to nullptr.
TEST(RawPtrTest, DefaultConstruction)
{
raw_ptr<int> p;
EXPECT_EQ(p.get(), nullptr);
EXPECT_FALSE(p);
}
// Tests that construction from nullptr works.
TEST(RawPtrTest, NullptrConstruction)
{
raw_ptr<int> p = nullptr;
EXPECT_EQ(p.get(), nullptr);
EXPECT_FALSE(p);
}
// Tests that construction from a raw pointer works.
TEST(RawPtrTest, RawPointerConstruction)
{
int value = 42;
raw_ptr<int> p = &value;
EXPECT_EQ(p.get(), &value);
EXPECT_TRUE(p);
EXPECT_EQ(*p, 42);
}
// Tests copy and move construction. Both the no-op implementation and
// PartitionAlloc's one zero the moved-from pointer.
TEST(RawPtrTest, CopyAndMoveConstruction)
{
int value = 42;
raw_ptr<int> p1 = &value;
raw_ptr<int> p2 = p1;
EXPECT_EQ(p2.get(), &value);
EXPECT_EQ(p1.get(), &value);
raw_ptr<int> p3 = std::move(p2);
EXPECT_EQ(p3.get(), &value);
EXPECT_EQ(p2.get(), nullptr); // NOLINT(bugprone-use-after-move)
}
// Tests assignment from raw_ptr, raw pointer and nullptr.
TEST(RawPtrTest, Assignment)
{
int value1 = 42;
int value2 = 84;
raw_ptr<int> p1 = &value1;
raw_ptr<int> p2 = &value2;
p1 = p2;
EXPECT_EQ(p1.get(), &value2);
p1 = nullptr;
EXPECT_EQ(p1.get(), nullptr);
p1 = &value1;
EXPECT_EQ(p1.get(), &value1);
raw_ptr<int> p3;
p3 = std::move(p1);
EXPECT_EQ(p3.get(), &value1);
EXPECT_EQ(p1.get(), nullptr); // NOLINT(bugprone-use-after-move)
}
// Tests that self assignment does not clobber the pointer.
TEST(RawPtrTest, SelfAssignment)
{
int value = 42;
raw_ptr<int> p = &value;
// Going through a pointer avoids the compiler's self-assignment warning.
raw_ptr<int> *alias = &p;
p = *alias;
EXPECT_EQ(p.get(), &value);
p = std::move(*alias);
EXPECT_EQ(p.get(), &value);
}
// Tests implicit conversion from raw_ptr<Derived> to raw_ptr<Base>.
TEST(RawPtrTest, Upcasting)
{
Derived derived;
raw_ptr<Derived> pDerived = &derived;
raw_ptr<Base> pBase(pDerived);
EXPECT_EQ(pBase.get(), &derived);
EXPECT_EQ(pBase->baseValue, 1);
raw_ptr<Base> pBaseAssigned;
pBaseAssigned = pDerived;
EXPECT_EQ(pBaseAssigned.get(), &derived);
raw_ptr<Derived> pDerivedMoved = &derived;
raw_ptr<Base> pBaseMoved(std::move(pDerivedMoved));
EXPECT_EQ(pBaseMoved.get(), &derived);
EXPECT_EQ(pDerivedMoved.get(), nullptr); // NOLINT(bugprone-use-after-move)
raw_ptr<Derived> pDerivedMoved2 = &derived;
raw_ptr<Base> pBaseMoveAssigned;
pBaseMoveAssigned = std::move(pDerivedMoved2);
EXPECT_EQ(pBaseMoveAssigned.get(), &derived);
EXPECT_EQ(pDerivedMoved2.get(), nullptr); // NOLINT(bugprone-use-after-move)
}
// Tests dereferencing and member access.
TEST(RawPtrTest, DereferenceAndMemberAccess)
{
struct S
{
int x = 42;
};
S s = {};
raw_ptr<S> p = &s;
EXPECT_EQ(p->x, 42);
EXPECT_EQ((*p).x, 42);
EXPECT_EQ(&*p, &s);
}
// Tests pointer arithmetic, which requires the AllowPtrArithmetic trait.
TEST(RawPtrTest, PointerArithmetic)
{
// SAFETY: Exercising pointer arithmetic is the point of this test. Every access below stays
// within the bounds of `values`.
ANGLE_UNSAFE_BUFFERS({
int values[3] = {10, 20, 30};
raw_ptr<int, AllowPtrArithmetic> p = &values[0];
EXPECT_EQ(p, &values[0]);
// Pre-increment returns a reference to the incremented pointer.
raw_ptr<int, AllowPtrArithmetic> &preIncremented = ++p;
EXPECT_EQ(&preIncremented, &p);
EXPECT_EQ(p, &values[1]);
// Post-increment returns the value from before the increment.
raw_ptr<int, AllowPtrArithmetic> previous = p++;
EXPECT_EQ(previous, &values[1]);
EXPECT_EQ(p, &values[2]);
// Pre-decrement returns a reference to the decremented pointer.
raw_ptr<int, AllowPtrArithmetic> &preDecremented = --p;
EXPECT_EQ(&preDecremented, &p);
EXPECT_EQ(p, &values[1]);
// Post-decrement returns the value from before the decrement.
previous = p--;
EXPECT_EQ(previous, &values[1]);
EXPECT_EQ(p, &values[0]);
static_assert(std::is_same_v<decltype(p + 1), raw_ptr<int, AllowPtrArithmetic>>);
static_assert(std::is_same_v<decltype(1 + p), raw_ptr<int, AllowPtrArithmetic>>);
static_assert(std::is_same_v<decltype(p - 1), raw_ptr<int, AllowPtrArithmetic>>);
static_assert(std::is_same_v<decltype(p - p), ptrdiff_t>);
EXPECT_EQ(p + 1, &values[1]);
EXPECT_EQ(1 + p, &values[1]);
EXPECT_EQ(p + 2, &values[2]);
raw_ptr<int, AllowPtrArithmetic> last = &values[2];
EXPECT_EQ(last - 1, &values[1]);
EXPECT_EQ(last - 2, &values[0]);
// Difference between two raw_ptr.
EXPECT_EQ(last - p, 2);
p += 2;
EXPECT_EQ(p, &values[2]);
p -= 2;
EXPECT_EQ(p, &values[0]);
EXPECT_EQ(p[1], 20);
});
}
// Tests equality comparisons against raw_ptr, raw pointers and nullptr, in both
// operand orders.
TEST(RawPtrTest, EqualityComparisons)
{
int value1 = 42;
int value2 = 84;
raw_ptr<int> p1 = &value1;
raw_ptr<int> p2 = &value2;
raw_ptr<int> null = nullptr;
EXPECT_TRUE(p1 == p1);
EXPECT_FALSE(p1 == p2);
EXPECT_TRUE(p1 != p2);
EXPECT_TRUE(p1 == &value1);
EXPECT_TRUE(&value1 == p1);
EXPECT_FALSE(p1 == &value2);
EXPECT_FALSE(&value2 == p1);
EXPECT_TRUE(null == nullptr);
EXPECT_TRUE(nullptr == null);
EXPECT_FALSE(p1 == nullptr);
EXPECT_FALSE(nullptr == p1);
}
// Tests relational comparisons (<, <=, >, >=) in both operand orders.
TEST(RawPtrTest, RelationalComparisons)
{
int values[2] = {42, 84};
raw_ptr<int> p0 = &values[0];
raw_ptr<int> p1 = &values[1];
EXPECT_TRUE(p0 < p1);
EXPECT_TRUE(p0 <= p1);
EXPECT_TRUE(p1 > p0);
EXPECT_TRUE(p1 >= p0);
EXPECT_FALSE(p1 < p0);
EXPECT_FALSE(p1 <= p0);
EXPECT_FALSE(p0 > p1);
EXPECT_FALSE(p0 >= p1);
EXPECT_TRUE(p0 <= p0);
EXPECT_TRUE(p0 >= p0);
EXPECT_TRUE(p0 < &values[1]);
EXPECT_TRUE(p0 <= &values[1]);
EXPECT_TRUE(&values[1] > p0);
EXPECT_TRUE(&values[1] >= p0);
}
// Tests const pointee types.
TEST(RawPtrTest, ConstPointee)
{
const int value = 100;
raw_ptr<const int> p = &value;
EXPECT_EQ(p.get(), &value);
EXPECT_EQ(*p, 100);
}
// Tests void pointee types, which do not support dereferencing.
TEST(RawPtrTest, Void)
{
int value = 42;
raw_ptr<void> p = &value;
EXPECT_EQ(p.get(), &value);
EXPECT_TRUE(p);
raw_ptr<const void> constPointer = &value;
EXPECT_EQ(constPointer.get(), &value);
}
// Tests interoperability with the standard library: std::less (through
// std::set), std::hash (through std::unordered_set) and std::to_address.
TEST(RawPtrTest, StandardLibrary)
{
int value1 = 1;
int value2 = 2;
raw_ptr<int> p1 = &value1;
raw_ptr<int> p2 = &value2;
std::set<raw_ptr<int>> set;
set.insert(p1);
set.insert(p2);
EXPECT_EQ(set.size(), 2u);
EXPECT_NE(set.find(p1), set.end());
// std::less is transparent, so lookup with a raw pointer creates no
// temporary raw_ptr.
EXPECT_NE(set.find(&value1), set.end());
std::unordered_set<raw_ptr<int>> unorderedSet;
unorderedSet.insert(p1);
unorderedSet.insert(p2);
EXPECT_EQ(unorderedSet.size(), 2u);
EXPECT_NE(unorderedSet.find(p1), unorderedSet.end());
EXPECT_EQ(std::to_address(p1), &value1);
}
// Tests that a raw_ptr marked with DisableDanglingPtrDetection is allowed to
// dangle.
TEST(RawPtrTest, DisableDanglingPtrDetection)
{
std::unique_ptr<int> owner = std::make_unique<int>(42);
raw_ptr<int, DisableDanglingPtrDetection> danger = owner.get();
std::ignore = danger;
owner.reset();
}
// Tests ExtractAsDangling, which clears the pointer and returns a raw_ptr
// allowed to dangle.
TEST(RawPtrTest, ExtractAsDangling)
{
int value = 42;
raw_ptr<int> p = &value;
raw_ptr<int, DisableDanglingPtrDetection> dangling = p.ExtractAsDangling();
EXPECT_EQ(dangling.get(), &value);
EXPECT_EQ(p.get(), nullptr);
}
#if defined(ANGLE_USE_PARTITION_ALLOC)
# if PA_BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS) && PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
class ScopedDanglingPointerTracker : angle::NonCopyable
{
public:
ScopedDanglingPointerTracker()
: mOldDetectedFn(partition_alloc::GetDanglingRawPtrDetectedFn()),
mOldReleasedFn(partition_alloc::GetDanglingRawPtrReleasedFn())
{
sDetected = false;
sReleased = false;
partition_alloc::SetDanglingRawPtrDetectedFn([](uintptr_t) { sDetected = true; });
partition_alloc::SetDanglingRawPtrReleasedFn([](uintptr_t) { sReleased = true; });
}
~ScopedDanglingPointerTracker()
{
partition_alloc::SetDanglingRawPtrDetectedFn(mOldDetectedFn);
partition_alloc::SetDanglingRawPtrReleasedFn(mOldReleasedFn);
}
bool detected() const { return sDetected; }
bool released() const { return sReleased; }
private:
static inline bool sDetected = false;
static inline bool sReleased = false;
partition_alloc::DanglingRawPtrDetectedFn *mOldDetectedFn;
partition_alloc::DanglingRawPtrReleasedFn *mOldReleasedFn;
};
// Tests that dangling raw_ptr instances are detected and reported when
// ENABLE_DANGLING_RAW_PTR_CHECKS is enabled.
TEST(RawPtrTest, DanglingPointerDetected)
{
ScopedDanglingPointerTracker tracker;
std::unique_ptr<int> owner = std::make_unique<int>(42);
raw_ptr<int> ptr = owner.get();
EXPECT_FALSE(tracker.detected());
EXPECT_FALSE(tracker.released());
owner.reset();
EXPECT_TRUE(tracker.detected());
EXPECT_FALSE(tracker.released());
ptr = nullptr;
EXPECT_TRUE(tracker.detected());
EXPECT_TRUE(tracker.released());
}
# if defined(GTEST_HAS_DEATH_TEST)
// Tests that releasing a dangling raw_ptr triggers FATAL crash when
// ENABLE_DANGLING_RAW_PTR_CHECKS is enabled.
TEST(RawPtrTest, DanglingPointerDetectedDeathTest)
{
// PartitionAlloc-as-malloc is currently only enabled on Linux in ANGLE
// standalone CQ, whereas it is also enabled on other platforms when
// angle_unittests is built inside Chromium (where this test fails on macOS
// and Windows). Suspected causes:
// - On Apple, FATAL() logs via os_log_with_type() rather than stderr.
// - On Windows, EXPECT_DEATH re-spawns the test binary, which may conflict
// with angle::TestSuite's --test-launcher-bot-mode flag on bots.
// - On Android, stderr is buffered to a file and may not be flushed on
// trap.
//
// TODO(b/503180635): Investigate and enable this test on additional
// platforms once we can run it on them in ANGLE standalone.
# if !defined(ANGLE_PLATFORM_LINUX)
GTEST_SKIP() << "Only supported on Linux for now.";
# else
EXPECT_DEATH(
{
std::unique_ptr<int> owner = std::make_unique<int>(42);
raw_ptr<int> ptr = owner.get();
owner.reset();
ptr = nullptr;
},
"DanglingPointerDetector: A pointer was dangling!");
# endif
}
# endif
# endif // PA_BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS) &&
// PA_BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC)
#endif // defined(ANGLE_USE_PARTITION_ALLOC)
} // namespace