Index: third_party/base/nonstd_unique_ptr_unittest.cpp |
diff --git a/third_party/base/nonstd_unique_ptr_unittest.cpp b/third_party/base/nonstd_unique_ptr_unittest.cpp |
deleted file mode 100644 |
index 1dcfe48b022aa19012c7569d76b00f6abb391944..0000000000000000000000000000000000000000 |
--- a/third_party/base/nonstd_unique_ptr_unittest.cpp |
+++ /dev/null |
@@ -1,391 +0,0 @@ |
-// Copyright 2015 PDFium Authors. All rights reserved. |
-// Use of this source code is governed by a BSD-style license that can be |
-// found in the LICENSE file. |
- |
-#include <sstream> |
-#include <utility> |
- |
-#include "testing/gtest/include/gtest/gtest.h" |
-#include "macros.h" |
-#include "nonstd_unique_ptr.h" |
- |
-using nonstd::unique_ptr; |
- |
-namespace { |
- |
-// Used to test depth subtyping. |
-class CtorDtorLoggerParent { |
- public: |
- virtual ~CtorDtorLoggerParent() {} |
- |
- virtual void SetPtr(int* ptr) = 0; |
- |
- virtual int SomeMeth(int x) const = 0; |
-}; |
- |
-class CtorDtorLogger : public CtorDtorLoggerParent { |
- public: |
- CtorDtorLogger() : ptr_(nullptr) {} |
- explicit CtorDtorLogger(int* ptr) { SetPtr(ptr); } |
- ~CtorDtorLogger() override { --*ptr_; } |
- |
- void SetPtr(int* ptr) override { |
- ptr_ = ptr; |
- ++*ptr_; |
- } |
- |
- int SomeMeth(int x) const override { return x; } |
- |
- private: |
- int* ptr_; |
- |
- // Disallow evil constructors. |
- CtorDtorLogger(const CtorDtorLogger&) = delete; |
- void operator=(const CtorDtorLogger&) = delete; |
-}; |
- |
-struct CountingDeleter { |
- explicit CountingDeleter(int* count) : count_(count) {} |
- inline void operator()(double* ptr) const { (*count_)++; } |
- int* count_; |
-}; |
- |
-// Do not delete this function! It's existence is to test that you can |
-// return a temporarily constructed version of the scoper. |
-unique_ptr<CtorDtorLogger> TestReturnOfType(int* constructed) { |
- return unique_ptr<CtorDtorLogger>(new CtorDtorLogger(constructed)); |
-} |
- |
-} // namespace |
- |
-TEST(UniquePtrTest, MoveTest) { |
- int constructed = 0; |
- int constructed4 = 0; |
- { |
- unique_ptr<CtorDtorLogger> ptr1(new CtorDtorLogger(&constructed)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_TRUE(ptr1); |
- |
- unique_ptr<CtorDtorLogger> ptr2(std::move(ptr1)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_FALSE(ptr1); |
- EXPECT_TRUE(ptr2); |
- |
- unique_ptr<CtorDtorLogger> ptr3; |
- ptr3 = std::move(ptr2); |
- EXPECT_EQ(1, constructed); |
- EXPECT_FALSE(ptr2); |
- EXPECT_TRUE(ptr3); |
- |
- unique_ptr<CtorDtorLogger> ptr4(new CtorDtorLogger(&constructed4)); |
- EXPECT_EQ(1, constructed4); |
- ptr4 = std::move(ptr3); |
- EXPECT_EQ(0, constructed4); |
- EXPECT_FALSE(ptr3); |
- EXPECT_TRUE(ptr4); |
- } |
- EXPECT_EQ(0, constructed); |
-} |
- |
-TEST(UniquePtrTest, UniquePtr) { |
- int constructed = 0; |
- |
- // Ensure size of unique_ptr<> doesn't increase unexpectedly. |
- static_assert(sizeof(int*) >= sizeof(unique_ptr<int>), |
- "unique_ptr_larger_than_raw_ptr"); |
- |
- { |
- unique_ptr<CtorDtorLogger> scoper(new CtorDtorLogger(&constructed)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_TRUE(scoper.get()); |
- |
- EXPECT_EQ(10, scoper->SomeMeth(10)); |
- EXPECT_EQ(10, scoper.get()->SomeMeth(10)); |
- EXPECT_EQ(10, (*scoper).SomeMeth(10)); |
- } |
- EXPECT_EQ(0, constructed); |
- |
- // Test reset() and release() |
- { |
- unique_ptr<CtorDtorLogger> scoper(new CtorDtorLogger(&constructed)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_TRUE(scoper.get()); |
- |
- scoper.reset(new CtorDtorLogger(&constructed)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_TRUE(scoper.get()); |
- |
- scoper.reset(); |
- EXPECT_EQ(0, constructed); |
- EXPECT_FALSE(scoper.get()); |
- |
- scoper.reset(new CtorDtorLogger(&constructed)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_TRUE(scoper.get()); |
- |
- CtorDtorLogger* take = scoper.release(); |
- EXPECT_EQ(1, constructed); |
- EXPECT_FALSE(scoper.get()); |
- delete take; |
- EXPECT_EQ(0, constructed); |
- |
- scoper.reset(new CtorDtorLogger(&constructed)); |
- EXPECT_EQ(1, constructed); |
- EXPECT_TRUE(scoper.get()); |
- } |
- EXPECT_EQ(0, constructed); |
- |
- // Test swap(), == and != |
- { |
- unique_ptr<CtorDtorLogger> scoper1; |
- unique_ptr<CtorDtorLogger> scoper2; |
- EXPECT_TRUE(scoper1 == scoper2.get()); |
- EXPECT_FALSE(scoper1 != scoper2.get()); |
- |
- CtorDtorLogger* logger = new CtorDtorLogger(&constructed); |
- scoper1.reset(logger); |
- EXPECT_EQ(logger, scoper1.get()); |
- EXPECT_FALSE(scoper2.get()); |
- EXPECT_FALSE(scoper1 == scoper2.get()); |
- EXPECT_TRUE(scoper1 != scoper2.get()); |
- |
- scoper2.swap(scoper1); |
- EXPECT_EQ(logger, scoper2.get()); |
- EXPECT_FALSE(scoper1.get()); |
- EXPECT_FALSE(scoper1 == scoper2.get()); |
- EXPECT_TRUE(scoper1 != scoper2.get()); |
- } |
- EXPECT_EQ(0, constructed); |
-} |
- |
-TEST(UniquePtrTest, UniquePtrWithArray) { |
- static const int kNumLoggers = 12; |
- |
- int constructed = 0; |
- |
- { |
- unique_ptr<CtorDtorLogger[]> scoper(new CtorDtorLogger[kNumLoggers]); |
- EXPECT_TRUE(scoper); |
- EXPECT_EQ(&scoper[0], scoper.get()); |
- for (int i = 0; i < kNumLoggers; ++i) { |
- scoper[i].SetPtr(&constructed); |
- } |
- EXPECT_EQ(12, constructed); |
- |
- EXPECT_EQ(10, scoper.get()->SomeMeth(10)); |
- EXPECT_EQ(10, scoper[2].SomeMeth(10)); |
- } |
- EXPECT_EQ(0, constructed); |
- |
- // Test reset() and release() |
- { |
- unique_ptr<CtorDtorLogger[]> scoper; |
- EXPECT_FALSE(scoper.get()); |
- EXPECT_FALSE(scoper.release()); |
- EXPECT_FALSE(scoper.get()); |
- scoper.reset(); |
- EXPECT_FALSE(scoper.get()); |
- |
- scoper.reset(new CtorDtorLogger[kNumLoggers]); |
- for (int i = 0; i < kNumLoggers; ++i) { |
- scoper[i].SetPtr(&constructed); |
- } |
- EXPECT_EQ(12, constructed); |
- scoper.reset(); |
- EXPECT_EQ(0, constructed); |
- |
- scoper.reset(new CtorDtorLogger[kNumLoggers]); |
- for (int i = 0; i < kNumLoggers; ++i) { |
- scoper[i].SetPtr(&constructed); |
- } |
- EXPECT_EQ(12, constructed); |
- CtorDtorLogger* ptr = scoper.release(); |
- EXPECT_EQ(12, constructed); |
- delete[] ptr; |
- EXPECT_EQ(0, constructed); |
- } |
- EXPECT_EQ(0, constructed); |
- |
- // Test swap(), ==, !=, and type-safe Boolean. |
- { |
- unique_ptr<CtorDtorLogger[]> scoper1; |
- unique_ptr<CtorDtorLogger[]> scoper2; |
- EXPECT_TRUE(scoper1 == scoper2.get()); |
- EXPECT_FALSE(scoper1 != scoper2.get()); |
- |
- CtorDtorLogger* loggers = new CtorDtorLogger[kNumLoggers]; |
- for (int i = 0; i < kNumLoggers; ++i) { |
- loggers[i].SetPtr(&constructed); |
- } |
- scoper1.reset(loggers); |
- EXPECT_TRUE(scoper1); |
- EXPECT_EQ(loggers, scoper1.get()); |
- EXPECT_FALSE(scoper2); |
- EXPECT_FALSE(scoper2.get()); |
- EXPECT_FALSE(scoper1 == scoper2.get()); |
- EXPECT_TRUE(scoper1 != scoper2.get()); |
- |
- scoper2.swap(scoper1); |
- EXPECT_EQ(loggers, scoper2.get()); |
- EXPECT_FALSE(scoper1.get()); |
- EXPECT_FALSE(scoper1 == scoper2.get()); |
- EXPECT_TRUE(scoper1 != scoper2.get()); |
- } |
- EXPECT_EQ(0, constructed); |
-} |
- |
-TEST(UniquePtrTest, ReturnTypeBehavior) { |
- int constructed = 0; |
- |
- // Test that we can return a unique_ptr. |
- { |
- CtorDtorLogger* logger = new CtorDtorLogger(&constructed); |
- unique_ptr<CtorDtorLogger> scoper(logger); |
- EXPECT_EQ(1, constructed); |
- } |
- EXPECT_EQ(0, constructed); |
- |
- // Test uncaught return type not leak. |
- { |
- CtorDtorLogger* logger = new CtorDtorLogger(&constructed); |
- unique_ptr<CtorDtorLogger> scoper(logger); |
- EXPECT_EQ(1, constructed); |
- } |
- EXPECT_EQ(0, constructed); |
- |
- // Call TestReturnOfType() so the compiler doesn't warn for an unused |
- // function. |
- { TestReturnOfType(&constructed); } |
- EXPECT_EQ(0, constructed); |
-} |
- |
-TEST(UniquePtrTest, CustomDeleter) { |
- double dummy_value; // Custom deleter never touches this value. |
- int deletes = 0; |
- int alternate_deletes = 0; |
- |
- // Normal delete support. |
- { |
- deletes = 0; |
- unique_ptr<double, CountingDeleter> scoper(&dummy_value, |
- CountingDeleter(&deletes)); |
- EXPECT_EQ(0, deletes); |
- EXPECT_TRUE(scoper.get()); |
- } |
- EXPECT_EQ(1, deletes); |
- |
- // Test reset() and release(). |
- deletes = 0; |
- { |
- unique_ptr<double, CountingDeleter> scoper(nullptr, |
- CountingDeleter(&deletes)); |
- EXPECT_FALSE(scoper.get()); |
- EXPECT_FALSE(scoper.release()); |
- EXPECT_FALSE(scoper.get()); |
- scoper.reset(); |
- EXPECT_FALSE(scoper.get()); |
- EXPECT_EQ(0, deletes); |
- |
- scoper.reset(&dummy_value); |
- scoper.reset(); |
- EXPECT_EQ(1, deletes); |
- |
- scoper.reset(&dummy_value); |
- EXPECT_EQ(&dummy_value, scoper.release()); |
- } |
- EXPECT_EQ(1, deletes); |
- |
- // Test get_deleter(). |
- deletes = 0; |
- alternate_deletes = 0; |
- { |
- unique_ptr<double, CountingDeleter> scoper(&dummy_value, |
- CountingDeleter(&deletes)); |
- // Call deleter manually. |
- EXPECT_EQ(0, deletes); |
- scoper.get_deleter()(&dummy_value); |
- EXPECT_EQ(1, deletes); |
- |
- // Deleter is still there after reset. |
- scoper.reset(); |
- EXPECT_EQ(2, deletes); |
- scoper.get_deleter()(&dummy_value); |
- EXPECT_EQ(3, deletes); |
- |
- // Deleter can be assigned into (matches C++11 unique_ptr<> spec). |
- scoper.get_deleter() = CountingDeleter(&alternate_deletes); |
- scoper.reset(&dummy_value); |
- EXPECT_EQ(0, alternate_deletes); |
- } |
- EXPECT_EQ(3, deletes); |
- EXPECT_EQ(1, alternate_deletes); |
- |
- // Test swap(), ==, !=, and type-safe Boolean. |
- { |
- unique_ptr<double, CountingDeleter> scoper1(nullptr, |
- CountingDeleter(&deletes)); |
- unique_ptr<double, CountingDeleter> scoper2(nullptr, |
- CountingDeleter(&deletes)); |
- EXPECT_TRUE(scoper1 == scoper2.get()); |
- EXPECT_FALSE(scoper1 != scoper2.get()); |
- |
- scoper1.reset(&dummy_value); |
- EXPECT_TRUE(scoper1); |
- EXPECT_EQ(&dummy_value, scoper1.get()); |
- EXPECT_FALSE(scoper2); |
- EXPECT_FALSE(scoper2.get()); |
- EXPECT_FALSE(scoper1 == scoper2.get()); |
- EXPECT_TRUE(scoper1 != scoper2.get()); |
- |
- scoper2.swap(scoper1); |
- EXPECT_EQ(&dummy_value, scoper2.get()); |
- EXPECT_FALSE(scoper1.get()); |
- EXPECT_FALSE(scoper1 == scoper2.get()); |
- EXPECT_TRUE(scoper1 != scoper2.get()); |
- } |
-} |
- |
-unique_ptr<int> NullIntReturn() { |
- return nullptr; |
-} |
- |
-TEST(UniquePtrTest, Nullptr) { |
- unique_ptr<int> scoper1(nullptr); |
- unique_ptr<int> scoper2(new int); |
- scoper2 = nullptr; |
- unique_ptr<int> scoper3(NullIntReturn()); |
- unique_ptr<int> scoper4 = NullIntReturn(); |
- EXPECT_EQ(nullptr, scoper1.get()); |
- EXPECT_EQ(nullptr, scoper2.get()); |
- EXPECT_EQ(nullptr, scoper3.get()); |
- EXPECT_EQ(nullptr, scoper4.get()); |
-} |
- |
-unique_ptr<int[]> NullIntArrayReturn() { |
- return nullptr; |
-} |
- |
-TEST(UniquePtrTest, NullptrArray) { |
- unique_ptr<int[]> scoper1(nullptr); |
- unique_ptr<int[]> scoper2(new int[3]); |
- scoper2 = nullptr; |
- unique_ptr<int[]> scoper3(NullIntArrayReturn()); |
- unique_ptr<int[]> scoper4 = NullIntArrayReturn(); |
- EXPECT_EQ(nullptr, scoper1.get()); |
- EXPECT_EQ(nullptr, scoper2.get()); |
- EXPECT_EQ(nullptr, scoper3.get()); |
- EXPECT_EQ(nullptr, scoper4.get()); |
-} |
- |
-// Logging a unique_ptr<T> to an ostream shouldn't convert it to a boolean |
-// value first. |
-TEST(ScopedPtrTest, LoggingDoesntConvertToBoolean) { |
- unique_ptr<int> x(new int); |
- std::stringstream s1; |
- s1 << x; |
- |
- std::stringstream s2; |
- s2 << x.get(); |
- |
- EXPECT_EQ(s2.str(), s1.str()); |
-} |