1// Copyright (c) 2012 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
5#include "base/memory/ref_counted.h"
6#include "base/memory/scoped_ptr.h"
7#include "content/browser/indexed_db/list_set.h"
8#include "testing/gtest/include/gtest/gtest.h"
9
10namespace content {
11
12TEST(ListSetTest, ListSetIterator) {
13  list_set<int> set;
14  for (int i = 3; i > 0; --i)
15    set.insert(i);
16
17  list_set<int>::iterator it = set.begin();
18  EXPECT_EQ(3, *it);
19  ++it;
20  EXPECT_EQ(2, *it);
21  it++;
22  EXPECT_EQ(1, *it);
23  --it;
24  EXPECT_EQ(2, *it);
25  it--;
26  EXPECT_EQ(3, *it);
27  ++it;
28  EXPECT_EQ(2, *it);
29  it++;
30  EXPECT_EQ(1, *it);
31  ++it;
32  EXPECT_EQ(set.end(), it);
33}
34
35TEST(ListSetTest, ListSetConstIterator) {
36  list_set<int> set;
37  for (int i = 5; i > 0; --i)
38    set.insert(i);
39
40  const list_set<int>& ref = set;
41
42  list_set<int>::const_iterator it = ref.begin();
43  for (int i = 5; i > 0; --i) {
44    EXPECT_EQ(i, *it);
45    ++it;
46  }
47  EXPECT_EQ(ref.end(), it);
48}
49
50TEST(ListSetTest, ListSetPrimitive) {
51  list_set<int> set;
52  EXPECT_TRUE(set.empty());
53  EXPECT_EQ(0u, set.size());
54  {
55    list_set<int>::iterator it = set.begin();
56    EXPECT_EQ(set.end(), it);
57  }
58
59  for (int i = 5; i > 0; --i)
60    set.insert(i);
61  EXPECT_EQ(5u, set.size());
62  EXPECT_FALSE(set.empty());
63
64  set.erase(3);
65  EXPECT_EQ(4u, set.size());
66
67  EXPECT_EQ(1u, set.count(2));
68  set.erase(2);
69  EXPECT_EQ(0u, set.count(2));
70  EXPECT_EQ(3u, set.size());
71
72  {
73    list_set<int>::iterator it = set.begin();
74    EXPECT_EQ(5, *it);
75    ++it;
76    EXPECT_EQ(4, *it);
77    ++it;
78    EXPECT_EQ(1, *it);
79    ++it;
80    EXPECT_EQ(set.end(), it);
81  }
82
83  set.erase(1);
84  set.erase(4);
85  set.erase(5);
86
87  EXPECT_EQ(0u, set.size());
88  EXPECT_TRUE(set.empty());
89  {
90    list_set<int>::iterator it = set.begin();
91    EXPECT_EQ(set.end(), it);
92  }
93}
94
95template <typename T>
96class Wrapped {
97 public:
98  explicit Wrapped(const T& value) : value_(value) {}
99  explicit Wrapped(const Wrapped<T>& other) : value_(other.value_) {}
100  Wrapped& operator=(const Wrapped<T>& rhs) {
101    value_ = rhs.value_;
102    return *this;
103  }
104  int value() const { return value_; }
105  bool operator<(const Wrapped<T>& rhs) const { return value_ < rhs.value_; }
106  bool operator==(const Wrapped<T>& rhs) const { return value_ == rhs.value_; }
107
108 private:
109  T value_;
110};
111
112TEST(ListSetTest, ListSetObject) {
113  list_set<Wrapped<int> > set;
114  EXPECT_EQ(0u, set.size());
115  {
116    list_set<Wrapped<int> >::iterator it = set.begin();
117    EXPECT_EQ(set.end(), it);
118  }
119
120  set.insert(Wrapped<int>(0));
121  set.insert(Wrapped<int>(1));
122  set.insert(Wrapped<int>(2));
123
124  EXPECT_EQ(3u, set.size());
125
126  {
127    list_set<Wrapped<int> >::iterator it = set.begin();
128    EXPECT_EQ(0, it->value());
129    ++it;
130    EXPECT_EQ(1, it->value());
131    ++it;
132    EXPECT_EQ(2, it->value());
133    ++it;
134    EXPECT_EQ(set.end(), it);
135  }
136
137  set.erase(Wrapped<int>(0));
138  set.erase(Wrapped<int>(1));
139  set.erase(Wrapped<int>(2));
140
141  EXPECT_EQ(0u, set.size());
142  {
143    list_set<Wrapped<int> >::iterator it = set.begin();
144    EXPECT_EQ(set.end(), it);
145  }
146}
147
148TEST(ListSetTest, ListSetPointer) {
149  scoped_ptr<Wrapped<int> > w0(new Wrapped<int>(0));
150  scoped_ptr<Wrapped<int> > w1(new Wrapped<int>(1));
151  scoped_ptr<Wrapped<int> > w2(new Wrapped<int>(2));
152
153  list_set<Wrapped<int>*> set;
154  EXPECT_EQ(0u, set.size());
155  {
156    list_set<Wrapped<int>*>::iterator it = set.begin();
157    EXPECT_EQ(set.end(), it);
158  }
159
160  set.insert(w0.get());
161  set.insert(w1.get());
162  set.insert(w2.get());
163
164  EXPECT_EQ(3u, set.size());
165
166  {
167    list_set<Wrapped<int>*>::iterator it = set.begin();
168    EXPECT_EQ(0, (*it)->value());
169    ++it;
170    EXPECT_EQ(1, (*it)->value());
171    ++it;
172    EXPECT_EQ(2, (*it)->value());
173    ++it;
174    EXPECT_EQ(set.end(), it);
175  }
176
177  set.erase(w0.get());
178  set.erase(w1.get());
179  set.erase(w2.get());
180
181  EXPECT_EQ(0u, set.size());
182  {
183    list_set<Wrapped<int>*>::iterator it = set.begin();
184    EXPECT_EQ(set.end(), it);
185  }
186}
187
188template <typename T>
189class RefCounted : public base::RefCounted<RefCounted<T> > {
190 public:
191  explicit RefCounted(const T& value) : value_(value) {}
192  T value() { return value_; }
193
194 private:
195  virtual ~RefCounted() {}
196  friend class base::RefCounted<RefCounted<T> >;
197  T value_;
198};
199
200TEST(ListSetTest, ListSetRefCounted) {
201  list_set<scoped_refptr<RefCounted<int> > > set;
202  EXPECT_EQ(0u, set.size());
203  {
204    list_set<scoped_refptr<RefCounted<int> > >::iterator it = set.begin();
205    EXPECT_EQ(set.end(), it);
206  }
207
208  scoped_refptr<RefCounted<int> > r0(new RefCounted<int>(0));
209  scoped_refptr<RefCounted<int> > r1(new RefCounted<int>(1));
210  scoped_refptr<RefCounted<int> > r2(new RefCounted<int>(2));
211
212  set.insert(r0);
213  set.insert(r1);
214  set.insert(r2);
215
216  EXPECT_EQ(3u, set.size());
217
218  {
219    list_set<scoped_refptr<RefCounted<int> > >::iterator it = set.begin();
220    EXPECT_EQ(0, (*it)->value());
221    ++it;
222    EXPECT_EQ(1, (*it)->value());
223    ++it;
224    EXPECT_EQ(2, (*it)->value());
225    ++it;
226    EXPECT_EQ(set.end(), it);
227  }
228
229  set.erase(r0);
230  set.erase(r1);
231  set.erase(r2);
232
233  EXPECT_EQ(0u, set.size());
234  {
235    list_set<scoped_refptr<RefCounted<int> > >::iterator it = set.begin();
236    EXPECT_EQ(set.end(), it);
237  }
238}
239
240}  // namespace content
241