// Copyright (c) 2012 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 "content/browser/indexed_db/list_set.h"

#include <memory>

#include "base/memory/ref_counted.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace content {

TEST(ListSetTest, ListSetIterator) {
  list_set<int> set;
  for (int i = 3; i > 0; --i)
    set.insert(i);

  list_set<int>::iterator it = set.begin();
  EXPECT_EQ(3, *it);
  ++it;
  EXPECT_EQ(2, *it);
  it++;
  EXPECT_EQ(1, *it);
  --it;
  EXPECT_EQ(2, *it);
  it--;
  EXPECT_EQ(3, *it);
  ++it;
  EXPECT_EQ(2, *it);
  it++;
  EXPECT_EQ(1, *it);
  ++it;
  EXPECT_EQ(set.end(), it);
}

TEST(ListSetTest, ListSetConstIterator) {
  list_set<int> set;
  for (int i = 5; i > 0; --i)
    set.insert(i);

  const list_set<int>& ref = set;

  list_set<int>::const_iterator it = ref.begin();
  for (int i = 5; i > 0; --i) {
    EXPECT_EQ(i, *it);
    ++it;
  }
  EXPECT_EQ(ref.end(), it);
}

TEST(ListSetTest, ListSetInsertFront) {
  list_set<int> set;
  for (int i = 5; i > 0; --i)
    set.insert(i);
  for (int i = 6; i <= 10; ++i)
    set.insert_front(i);

  const list_set<int>& ref = set;

  list_set<int>::const_iterator it = ref.begin();
  for (int i = 10; i > 0; --i) {
    EXPECT_EQ(i, *it);
    ++it;
  }
  EXPECT_EQ(ref.end(), it);
}

TEST(ListSetTest, ListSetPrimitive) {
  list_set<int> set;
  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.size());
  {
    list_set<int>::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }

  for (int i = 5; i > 0; --i)
    set.insert(i);
  EXPECT_EQ(5u, set.size());
  EXPECT_FALSE(set.empty());

  set.erase(3);
  EXPECT_EQ(4u, set.size());

  EXPECT_EQ(1u, set.count(2));
  set.erase(2);
  EXPECT_EQ(0u, set.count(2));
  EXPECT_EQ(3u, set.size());

  {
    list_set<int>::iterator it = set.begin();
    EXPECT_EQ(5, *it);
    ++it;
    EXPECT_EQ(4, *it);
    ++it;
    EXPECT_EQ(1, *it);
    ++it;
    EXPECT_EQ(set.end(), it);
  }

  set.erase(1);
  set.erase(4);
  set.erase(5);

  EXPECT_EQ(0u, set.size());
  EXPECT_TRUE(set.empty());
  {
    list_set<int>::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }
}

template <typename T>
class Wrapped {
 public:
  explicit Wrapped(const T& value) : value_(value) {}
  explicit Wrapped(const Wrapped<T>& other) : value_(other.value_) {}
  Wrapped& operator=(const Wrapped<T>& rhs) {
    value_ = rhs.value_;
    return *this;
  }
  int value() const { return value_; }
  bool operator<(const Wrapped<T>& rhs) const { return value_ < rhs.value_; }
  bool operator==(const Wrapped<T>& rhs) const { return value_ == rhs.value_; }

 private:
  T value_;
};

TEST(ListSetTest, ListSetObject) {
  list_set<Wrapped<int> > set;
  EXPECT_EQ(0u, set.size());
  {
    list_set<Wrapped<int> >::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }

  set.insert(Wrapped<int>(0));
  set.insert(Wrapped<int>(1));
  set.insert(Wrapped<int>(2));

  EXPECT_EQ(3u, set.size());

  {
    list_set<Wrapped<int> >::iterator it = set.begin();
    EXPECT_EQ(0, it->value());
    ++it;
    EXPECT_EQ(1, it->value());
    ++it;
    EXPECT_EQ(2, it->value());
    ++it;
    EXPECT_EQ(set.end(), it);
  }

  set.erase(Wrapped<int>(0));
  set.erase(Wrapped<int>(1));
  set.erase(Wrapped<int>(2));

  EXPECT_EQ(0u, set.size());
  {
    list_set<Wrapped<int> >::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }
}

TEST(ListSetTest, ListSetPointer) {
  std::unique_ptr<Wrapped<int>> w0 = std::make_unique<Wrapped<int>>(0);
  std::unique_ptr<Wrapped<int>> w1 = std::make_unique<Wrapped<int>>(1);
  std::unique_ptr<Wrapped<int>> w2 = std::make_unique<Wrapped<int>>(2);

  list_set<Wrapped<int>*> set;
  EXPECT_EQ(0u, set.size());
  {
    list_set<Wrapped<int>*>::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }

  set.insert(w0.get());
  set.insert(w1.get());
  set.insert(w2.get());

  EXPECT_EQ(3u, set.size());

  {
    list_set<Wrapped<int>*>::iterator it = set.begin();
    EXPECT_EQ(0, (*it)->value());
    ++it;
    EXPECT_EQ(1, (*it)->value());
    ++it;
    EXPECT_EQ(2, (*it)->value());
    ++it;
    EXPECT_EQ(set.end(), it);
  }

  set.erase(w0.get());
  set.erase(w1.get());
  set.erase(w2.get());

  EXPECT_EQ(0u, set.size());
  {
    list_set<Wrapped<int>*>::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }
}

template <typename T>
class RefCounted : public base::RefCounted<RefCounted<T> > {
 public:
  explicit RefCounted(const T& value) : value_(value) {}
  T value() { return value_; }

 private:
  virtual ~RefCounted() {}
  friend class base::RefCounted<RefCounted<T> >;
  T value_;
};

TEST(ListSetTest, ListSetRefCounted) {
  list_set<scoped_refptr<RefCounted<int> > > set;
  EXPECT_EQ(0u, set.size());
  {
    list_set<scoped_refptr<RefCounted<int> > >::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }

  scoped_refptr<RefCounted<int> > r0(new RefCounted<int>(0));
  scoped_refptr<RefCounted<int> > r1(new RefCounted<int>(1));
  scoped_refptr<RefCounted<int> > r2(new RefCounted<int>(2));

  set.insert(r0);
  set.insert(r1);
  set.insert(r2);

  EXPECT_EQ(3u, set.size());

  {
    list_set<scoped_refptr<RefCounted<int> > >::iterator it = set.begin();
    EXPECT_EQ(0, (*it)->value());
    ++it;
    EXPECT_EQ(1, (*it)->value());
    ++it;
    EXPECT_EQ(2, (*it)->value());
    ++it;
    EXPECT_EQ(set.end(), it);
  }

  set.erase(r0);
  set.erase(r1);
  set.erase(r2);

  EXPECT_EQ(0u, set.size());
  {
    list_set<scoped_refptr<RefCounted<int> > >::iterator it = set.begin();
    EXPECT_EQ(set.end(), it);
  }
}

}  // namespace content