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 10 namespace content { 11 12 TEST(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 35 TEST(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 50 TEST(ListSetTest, ListSetPrimitive) { 51 list_set<int> set; 52 EXPECT_TRUE(set.empty()); 53 EXPECT_EQ(static_cast<size_t>(0), 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(static_cast<size_t>(5), set.size()); 62 EXPECT_FALSE(set.empty()); 63 64 set.erase(3); 65 EXPECT_EQ(static_cast<size_t>(4), set.size()); 66 67 EXPECT_TRUE(set.has(2)); 68 set.erase(2); 69 EXPECT_FALSE(set.has(2)); 70 EXPECT_EQ(static_cast<size_t>(3), 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(static_cast<size_t>(0), 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 95 template <typename T> 96 class 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 112 TEST(ListSetTest, ListSetObject) { 113 list_set<Wrapped<int> > set; 114 EXPECT_EQ(static_cast<size_t>(0), 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(static_cast<size_t>(3), 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(static_cast<size_t>(0), set.size()); 142 { 143 list_set<Wrapped<int> >::iterator it = set.begin(); 144 EXPECT_EQ(set.end(), it); 145 } 146 } 147 148 TEST(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(static_cast<size_t>(0), 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(static_cast<size_t>(3), 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(static_cast<size_t>(0), set.size()); 182 { 183 list_set<Wrapped<int>*>::iterator it = set.begin(); 184 EXPECT_EQ(set.end(), it); 185 } 186 } 187 188 template <typename T> 189 class 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 200 TEST(ListSetTest, ListSetRefCounted) { 201 list_set<scoped_refptr<RefCounted<int> > > set; 202 EXPECT_EQ(static_cast<size_t>(0), 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(static_cast<size_t>(3), 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(static_cast<size_t>(0), 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
