base/containers/scoped_ptr_map_unittest.cc

// Copyright 2015 The Chromium 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 "base/containers/scoped_ptr_map.h"

#include <functional>
#include <map>
#include <utility>

#include "base/bind.h"
#include "base/callback.h"
#include "base/memory/scoped_ptr.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace base {
namespace {

namespace namespace_with_ignore_result {

class Value {};

template <typename T>
void ignore_result(const T&) {}

}  // namespace namespace_with_ignore_result

// A ScopedDestroyer sets a Boolean to true upon destruction.
class ScopedDestroyer {
 public:
  ScopedDestroyer(bool* destroyed) : destroyed_(destroyed) {
    *destroyed_ = false;
  }

  ~ScopedDestroyer() { *destroyed_ = true; }

 private:
  bool* destroyed_;
};

TEST(ScopedPtrMapTest, Insert) {
  bool destroyed1 = false;
  bool destroyed2 = false;
  {
    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;

    // Insert to new key.
    ScopedDestroyer* elem1 = new ScopedDestroyer(&destroyed1);
    EXPECT_FALSE(destroyed1);
    EXPECT_TRUE(scoped_map.insert(0, make_scoped_ptr(elem1)).second);
    EXPECT_EQ(elem1, scoped_map.find(0)->second);
    EXPECT_FALSE(destroyed1);

    // Insert to existing key.
    ScopedDestroyer* elem2 = new ScopedDestroyer(&destroyed2);
    EXPECT_FALSE(destroyed2);
    EXPECT_FALSE(scoped_map.insert(0, make_scoped_ptr(elem2)).second);
    EXPECT_EQ(elem1, scoped_map.find(0)->second);

    EXPECT_FALSE(destroyed1);
    EXPECT_TRUE(destroyed2);
  }
  EXPECT_TRUE(destroyed1);
}

TEST(ScopedPtrMapTest, Set) {
  bool destroyed1 = false;
  bool destroyed2 = false;
  {
    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;

    // Set a new key.
    ScopedDestroyer* elem1 = new ScopedDestroyer(&destroyed1);
    EXPECT_FALSE(destroyed1);
    scoped_map.set(0, make_scoped_ptr(elem1));
    EXPECT_EQ(elem1, scoped_map.find(0)->second);
    EXPECT_FALSE(destroyed1);

    // Set to replace an existing key.
    ScopedDestroyer* elem2 = new ScopedDestroyer(&destroyed2);
    EXPECT_FALSE(destroyed2);
    scoped_map.set(0, make_scoped_ptr(elem2));
    EXPECT_EQ(elem2, scoped_map.find(0)->second);

    EXPECT_TRUE(destroyed1);
    EXPECT_FALSE(destroyed2);
  }
  EXPECT_TRUE(destroyed1);
  EXPECT_TRUE(destroyed2);
}

TEST(ScopedPtrMapTest, EraseIterator) {
  bool destroyed = false;
  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
  scoped_map.insert(0, make_scoped_ptr(new ScopedDestroyer(&destroyed)));
  EXPECT_FALSE(destroyed);
  scoped_map.erase(scoped_map.find(0));
  EXPECT_TRUE(destroyed);
  EXPECT_TRUE(scoped_map.empty());
}

TEST(ScopedPtrMapTest, EraseKey) {
  bool destroyed = false;
  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
  scoped_map.insert(0, make_scoped_ptr(new ScopedDestroyer(&destroyed)));
  EXPECT_FALSE(destroyed);
  EXPECT_EQ(1u, scoped_map.erase(0));
  EXPECT_TRUE(destroyed);
  EXPECT_TRUE(scoped_map.empty());

  // Test erase of a non-existent key.
  EXPECT_EQ(0u, scoped_map.erase(7));
}

TEST(ScopedPtrMapTest, EraseRange) {
  bool destroyed1 = false;
  bool destroyed2 = false;
  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;

  scoped_map.insert(0, make_scoped_ptr(new ScopedDestroyer(&destroyed1)));
  EXPECT_FALSE(destroyed1);

  scoped_map.insert(1, make_scoped_ptr(new ScopedDestroyer(&destroyed2)));
  EXPECT_FALSE(destroyed2);

  scoped_map.erase(scoped_map.find(0), scoped_map.end());
  EXPECT_TRUE(destroyed1);
  EXPECT_TRUE(destroyed2);
  EXPECT_TRUE(scoped_map.empty());
}

TEST(ScopedPtrMapTest, TakeAndErase) {
  bool destroyed = false;
  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
  ScopedDestroyer* elem = new ScopedDestroyer(&destroyed);
  scoped_map.insert(0, make_scoped_ptr(elem));
  EXPECT_EQ(elem, scoped_map.find(0)->second);
  EXPECT_FALSE(destroyed);
  scoped_ptr<ScopedDestroyer> object = scoped_map.take_and_erase(0);
  EXPECT_EQ(elem, object.get());
  EXPECT_FALSE(destroyed);
  EXPECT_TRUE(scoped_map.empty());
  object.reset();
  EXPECT_TRUE(destroyed);
}

TEST(ScopedPtrMapTest, Clear) {
  bool destroyed = false;
  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
  scoped_map.insert(0, make_scoped_ptr(new ScopedDestroyer(&destroyed)));
  EXPECT_FALSE(destroyed);
  scoped_map.clear();
  EXPECT_TRUE(destroyed);
  EXPECT_TRUE(scoped_map.empty());
}

TEST(ScopedPtrMapTest, Compare) {
  // Construct a ScopedPtrMap with a custom comparison function.
  ScopedPtrMap<int, scoped_ptr<int>, std::greater<int>> scoped_map1;
  scoped_map1.insert(0, make_scoped_ptr(new int(0)));
  scoped_map1.insert(1, make_scoped_ptr(new int(0)));

  auto it = scoped_map1.begin();
  EXPECT_EQ(1, it->first);
  ++it;
  EXPECT_EQ(0, it->first);

  // Test the move constructor.
  ScopedPtrMap<int, scoped_ptr<int>, std::greater<int>> scoped_map2(
      scoped_map1.Pass());
  EXPECT_EQ(2u, scoped_map2.size());
  EXPECT_TRUE(scoped_map1.empty());

  // Test move assignment.
  scoped_map1 = scoped_map2.Pass();
  EXPECT_EQ(2u, scoped_map1.size());
  EXPECT_TRUE(scoped_map2.empty());

  // Test swap.
  scoped_map2.swap(scoped_map1);
  EXPECT_EQ(2u, scoped_map2.size());
  EXPECT_TRUE(scoped_map1.empty());
}

TEST(ScopedPtrMapTest, Scope) {
  bool destroyed = false;
  {
    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
    scoped_map.insert(0, make_scoped_ptr(new ScopedDestroyer(&destroyed)));
    EXPECT_FALSE(destroyed);
  }
  EXPECT_TRUE(destroyed);
}

TEST(ScopedPtrMapTest, MoveConstruct) {
  bool destroyed = false;
  {
    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
    ScopedDestroyer* elem = new ScopedDestroyer(&destroyed);
    scoped_map.insert(0, make_scoped_ptr(elem));
    EXPECT_EQ(elem, scoped_map.find(0)->second);
    EXPECT_FALSE(destroyed);
    EXPECT_FALSE(scoped_map.empty());

    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map_copy(
        scoped_map.Pass());
    EXPECT_TRUE(scoped_map.empty());
    EXPECT_FALSE(scoped_map_copy.empty());
    EXPECT_EQ(elem, scoped_map_copy.find(0)->second);
    EXPECT_FALSE(destroyed);
  }
  EXPECT_TRUE(destroyed);
}

TEST(ScopedPtrMapTest, MoveAssign) {
  bool destroyed = false;
  {
    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
    ScopedDestroyer* elem = new ScopedDestroyer(&destroyed);
    scoped_map.insert(0, make_scoped_ptr(elem));
    EXPECT_EQ(elem, scoped_map.find(0)->second);
    EXPECT_FALSE(destroyed);
    EXPECT_FALSE(scoped_map.empty());

    ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map_assign;
    scoped_map_assign = scoped_map.Pass();
    EXPECT_TRUE(scoped_map.empty());
    EXPECT_FALSE(scoped_map_assign.empty());
    EXPECT_EQ(elem, scoped_map_assign.find(0)->second);
    EXPECT_FALSE(destroyed);
  }
  EXPECT_TRUE(destroyed);
}

template <typename Key, typename ScopedPtr>
ScopedPtrMap<Key, ScopedPtr> PassThru(ScopedPtrMap<Key, ScopedPtr> scoper) {
  return scoper;
}

TEST(ScopedPtrMapTest, Passed) {
  bool destroyed = false;
  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
  ScopedDestroyer* elem = new ScopedDestroyer(&destroyed);
  scoped_map.insert(0, make_scoped_ptr(elem));
  EXPECT_EQ(elem, scoped_map.find(0)->second);
  EXPECT_FALSE(destroyed);

  base::Callback<ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>>(void)>
      callback = base::Bind(&PassThru<int, scoped_ptr<ScopedDestroyer>>,
                            base::Passed(&scoped_map));
  EXPECT_TRUE(scoped_map.empty());
  EXPECT_FALSE(destroyed);

  ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> result = callback.Run();
  EXPECT_TRUE(scoped_map.empty());
  EXPECT_EQ(elem, result.find(0)->second);
  EXPECT_FALSE(destroyed);

  result.clear();
  EXPECT_TRUE(destroyed);
};

// Test that using a value type from a namespace containing an ignore_result
// function compiles correctly.
TEST(ScopedPtrMapTest, IgnoreResultCompile) {
  ScopedPtrMap<int, scoped_ptr<namespace_with_ignore_result::Value>> scoped_map;
  scoped_map.insert(1,
                    make_scoped_ptr(new namespace_with_ignore_result::Value));
}

}  // namespace
}  // namespace base