unique_ptr_adapters_unittest.cc 3.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132
  1. // Copyright 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/containers/unique_ptr_adapters.h"
  5. #include <memory>
  6. #include <vector>
  7. #include "base/ranges/algorithm.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace base {
  10. namespace {
  11. class Foo {
  12. public:
  13. Foo() { instance_count++; }
  14. ~Foo() { instance_count--; }
  15. static int instance_count;
  16. };
  17. int Foo::instance_count = 0;
  18. TEST(UniquePtrComparatorTest, Basic) {
  19. std::set<std::unique_ptr<Foo>, UniquePtrComparator> set;
  20. Foo* foo1 = new Foo();
  21. Foo* foo2 = new Foo();
  22. Foo* foo3 = new Foo();
  23. EXPECT_EQ(3, Foo::instance_count);
  24. set.emplace(foo1);
  25. set.emplace(foo2);
  26. auto it1 = set.find(foo1);
  27. EXPECT_TRUE(it1 != set.end());
  28. EXPECT_EQ(foo1, it1->get());
  29. {
  30. auto it2 = set.find(foo2);
  31. EXPECT_TRUE(it2 != set.end());
  32. EXPECT_EQ(foo2, it2->get());
  33. }
  34. EXPECT_TRUE(set.find(foo3) == set.end());
  35. set.erase(it1);
  36. EXPECT_EQ(2, Foo::instance_count);
  37. EXPECT_TRUE(set.find(foo1) == set.end());
  38. {
  39. auto it2 = set.find(foo2);
  40. EXPECT_TRUE(it2 != set.end());
  41. EXPECT_EQ(foo2, it2->get());
  42. }
  43. set.clear();
  44. EXPECT_EQ(1, Foo::instance_count);
  45. EXPECT_TRUE(set.find(foo1) == set.end());
  46. EXPECT_TRUE(set.find(foo2) == set.end());
  47. EXPECT_TRUE(set.find(foo3) == set.end());
  48. delete foo3;
  49. EXPECT_EQ(0, Foo::instance_count);
  50. }
  51. TEST(UniquePtrMatcherTest, Basic) {
  52. std::vector<std::unique_ptr<Foo>> v;
  53. auto foo_ptr1 = std::make_unique<Foo>();
  54. Foo* foo1 = foo_ptr1.get();
  55. v.push_back(std::move(foo_ptr1));
  56. auto foo_ptr2 = std::make_unique<Foo>();
  57. Foo* foo2 = foo_ptr2.get();
  58. v.push_back(std::move(foo_ptr2));
  59. {
  60. auto iter = ranges::find_if(v, UniquePtrMatcher<Foo>(foo1));
  61. ASSERT_TRUE(iter != v.end());
  62. EXPECT_EQ(foo1, iter->get());
  63. }
  64. {
  65. auto iter = ranges::find_if(v, UniquePtrMatcher<Foo>(foo2));
  66. ASSERT_TRUE(iter != v.end());
  67. EXPECT_EQ(foo2, iter->get());
  68. }
  69. {
  70. auto iter = ranges::find_if(v, MatchesUniquePtr(foo2));
  71. ASSERT_TRUE(iter != v.end());
  72. EXPECT_EQ(foo2, iter->get());
  73. }
  74. }
  75. class TestDeleter {
  76. public:
  77. void operator()(Foo* foo) { delete foo; }
  78. };
  79. TEST(UniquePtrMatcherTest, Deleter) {
  80. using UniqueFoo = std::unique_ptr<Foo, TestDeleter>;
  81. std::vector<UniqueFoo> v;
  82. UniqueFoo foo_ptr1(new Foo);
  83. Foo* foo1 = foo_ptr1.get();
  84. v.push_back(std::move(foo_ptr1));
  85. UniqueFoo foo_ptr2(new Foo);
  86. Foo* foo2 = foo_ptr2.get();
  87. v.push_back(std::move(foo_ptr2));
  88. {
  89. auto iter = ranges::find_if(v, UniquePtrMatcher<Foo, TestDeleter>(foo1));
  90. ASSERT_TRUE(iter != v.end());
  91. EXPECT_EQ(foo1, iter->get());
  92. }
  93. {
  94. auto iter = ranges::find_if(v, UniquePtrMatcher<Foo, TestDeleter>(foo2));
  95. ASSERT_TRUE(iter != v.end());
  96. EXPECT_EQ(foo2, iter->get());
  97. }
  98. {
  99. auto iter = ranges::find_if(v, MatchesUniquePtr<Foo, TestDeleter>(foo2));
  100. ASSERT_TRUE(iter != v.end());
  101. EXPECT_EQ(foo2, iter->get());
  102. }
  103. }
  104. } // namespace
  105. } // namespace base