blob: a5de9993a9adfa4bd308327e5c1879fc8e5fb22d [file]
// Copyright 2018 The PDFium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "core/fxcrt/autorestorer.h"
#include <memory>
#include <utility>
#include "core/fxcrt/retain_ptr.h"
#include "core/fxcrt/unowned_ptr.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/pseudo_retainable.h"
TEST(fxcrt, AutoRestorer) {
int x = 5;
{
AutoRestorer<int> restorer(&x);
x = 6;
EXPECT_EQ(6, x);
}
EXPECT_EQ(5, x);
{
AutoRestorer<int> restorer(&x, 7);
EXPECT_EQ(7, x);
}
EXPECT_EQ(5, x);
}
TEST(fxcrt, AutoRestorerNoOp) {
int x = 5;
{
AutoRestorer<int> restorer(&x);
EXPECT_EQ(5, x);
}
EXPECT_EQ(5, x);
}
TEST(fxcrt, AutoRestorerAbandon) {
int x = 5;
{
AutoRestorer<int> restorer(&x, 6);
EXPECT_EQ(6, x);
restorer.AbandonRestoration();
}
EXPECT_EQ(6, x);
}
TEST(fxcrt, AutoRestorerUnownedPtr) {
int x = 5;
int y = 6;
UnownedPtr<int> ptr(&x);
{
AutoRestorer<UnownedPtr<int>> restorer(&ptr);
ptr = &y;
EXPECT_EQ(&y, ptr);
}
EXPECT_EQ(&x, ptr);
{
AutoRestorer<UnownedPtr<int>> restorer(&ptr, &y);
EXPECT_EQ(&y, ptr);
}
EXPECT_EQ(&x, ptr);
}
TEST(fxcrt, AutoRestorerUnownedNoOp) {
int x = 5;
UnownedPtr<int> ptr(&x);
{
AutoRestorer<UnownedPtr<int>> restorer(&ptr);
EXPECT_EQ(&x, ptr);
}
EXPECT_EQ(&x, ptr);
}
TEST(fxcrt, AutoRestorerUnownedPtrAbandon) {
int x = 5;
int y = 6;
UnownedPtr<int> ptr(&x);
{
AutoRestorer<UnownedPtr<int>> restorer(&ptr);
ptr = &y;
EXPECT_EQ(&y, ptr);
restorer.AbandonRestoration();
}
EXPECT_EQ(&y, ptr);
}
TEST(fxcrt, AutoRestorerRetainPtr) {
PseudoRetainable obj1;
PseudoRetainable obj2;
{
RetainPtr<PseudoRetainable> ptr(&obj1);
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
{
AutoRestorer<RetainPtr<PseudoRetainable>> restorer(&ptr);
// `obj1` is kept alive by restorer in case it need to be restored.
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
ptr.Reset(&obj2);
EXPECT_EQ(&obj2, ptr.Get());
// `obj1` released by `ptr` assignment, but kept alive by `AutoRestorer`'s
// `old_value_`.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(1, obj1.release_count());
// `obj2` now kept alive by `ptr`.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
}
EXPECT_EQ(&obj1, ptr.Get());
// Moving from `AutoRestorer`'s `old_value_` into `ptr` avoided ref churn.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(1, obj1.release_count());
// `obj2` dead.
EXPECT_FALSE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(1, obj2.release_count());
}
EXPECT_FALSE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(2, obj1.release_count());
EXPECT_FALSE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(1, obj2.release_count());
}
TEST(fxcrt, AutoRestorerRetainPtrCopy) {
PseudoRetainable obj1;
PseudoRetainable obj2;
{
RetainPtr<PseudoRetainable> ptr1(&obj1);
RetainPtr<PseudoRetainable> ptr2(&obj2);
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
{
AutoRestorer<RetainPtr<PseudoRetainable>> restorer(&ptr1, ptr2);
EXPECT_EQ(&obj2, ptr1.Get());
EXPECT_EQ(&obj2, ptr2.Get());
// `obj1` was moved into `restorer`'s `old_value_` without ref churn,
// where it is kept alive until restoration.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
// `obj2` was copied into `ptr1`, incrementing its retain count.
EXPECT_TRUE(obj2.alive());
EXPECT_EQ(2, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
}
EXPECT_EQ(&obj1, ptr1.Get());
EXPECT_EQ(&obj2, ptr2.Get());
// `obj1` moved back to `ptr1` on destruction, with zero ref churn.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
// `ptr1`'s copy of `obj2` was released when overwritten by restoration.
EXPECT_TRUE(obj2.alive());
EXPECT_EQ(2, obj2.retain_count());
EXPECT_EQ(1, obj2.release_count());
}
EXPECT_FALSE(obj1.alive());
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(1, obj1.release_count());
EXPECT_FALSE(obj2.alive());
EXPECT_EQ(2, obj2.retain_count());
EXPECT_EQ(2, obj2.release_count());
}
TEST(fxcrt, AutoRestorerRetainPtrMove) {
PseudoRetainable obj1;
PseudoRetainable obj2;
{
RetainPtr<PseudoRetainable> ptr1(&obj1);
RetainPtr<PseudoRetainable> ptr2(&obj2);
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
{
AutoRestorer<RetainPtr<PseudoRetainable>> restorer(&ptr1,
std::move(ptr2));
EXPECT_EQ(&obj2, ptr1.Get());
EXPECT_FALSE(ptr2);
// `obj1` was moved into `restorer`'s `old_value_` without ref churn,
// where it is kept alive until restoration.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
// `ptr2` was moved into `ptr1` without ref churn.
EXPECT_TRUE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
}
EXPECT_EQ(&obj1, ptr1.Get());
EXPECT_FALSE(ptr2);
// `obj1` moved back to `ptr1` on destruction, with zero ref churn.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
// `ptr1`'s sole reference to `obj2` was released on restoration, so `obj2`
// dies.
EXPECT_FALSE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(1, obj2.release_count());
}
EXPECT_FALSE(obj1.alive());
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(1, obj1.release_count());
EXPECT_FALSE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(1, obj2.release_count());
}
TEST(fxcrt, AutoRestorerRetainPtrNoOp) {
PseudoRetainable obj1;
{
RetainPtr<PseudoRetainable> ptr(&obj1);
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
{
AutoRestorer<RetainPtr<PseudoRetainable>> restorer(&ptr);
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
}
EXPECT_EQ(&obj1, ptr.Get());
// Self-reassignement avoided ref churn.
EXPECT_TRUE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(1, obj1.release_count());
}
EXPECT_FALSE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(2, obj1.release_count());
}
TEST(fxcrt, AutoRestorerRetainPtrAbandon) {
PseudoRetainable obj1;
PseudoRetainable obj2;
{
RetainPtr<PseudoRetainable> ptr(&obj1);
EXPECT_EQ(1, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
{
AutoRestorer<RetainPtr<PseudoRetainable>> restorer(&ptr);
// `obj1` is kept alive by restorer in case it need to be restored.
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(0, obj1.release_count());
ptr.Reset(&obj2);
EXPECT_EQ(&obj2, ptr.Get());
// `obj1` released by `ptr` assignment.
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(1, obj1.release_count());
// `obj2` now kept alive by `ptr`.
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
restorer.AbandonRestoration();
}
EXPECT_EQ(&obj2, ptr.Get());
// `obj1` now dead as a result of abandonment.
EXPECT_FALSE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(2, obj1.release_count());
// `obj2` kept alive by `ptr`.
EXPECT_TRUE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(0, obj2.release_count());
}
EXPECT_FALSE(obj1.alive());
EXPECT_EQ(2, obj1.retain_count());
EXPECT_EQ(2, obj1.release_count());
EXPECT_FALSE(obj2.alive());
EXPECT_EQ(1, obj2.retain_count());
EXPECT_EQ(1, obj2.release_count());
}
TEST(fxcrt, AutoRestorerMoveOnlyType) {
auto ptr1 = std::make_unique<int>(5);
auto ptr2 = std::make_unique<int>(6);
{
AutoRestorer<std::unique_ptr<int>> restorer(&ptr1, std::move(ptr2));
EXPECT_FALSE(ptr2);
EXPECT_EQ(6, *ptr1);
}
EXPECT_EQ(5, *ptr1);
}
TEST(fxcrt, AutoRestorerMoveOnlyTypeAbandon) {
auto ptr1 = std::make_unique<int>(5);
auto ptr2 = std::make_unique<int>(6);
{
AutoRestorer<std::unique_ptr<int>> restorer(&ptr1, std::move(ptr2));
EXPECT_FALSE(ptr2);
EXPECT_EQ(6, *ptr1);
restorer.AbandonRestoration();
}
EXPECT_EQ(6, *ptr1);
}