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 "net/dns/host_cache.h" 6 7 #include "base/format_macros.h" 8 #include "base/stl_util.h" 9 #include "base/strings/string_util.h" 10 #include "base/strings/stringprintf.h" 11 #include "net/base/net_errors.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 namespace net { 15 16 namespace { 17 18 const int kMaxCacheEntries = 10; 19 20 // Builds a key for |hostname|, defaulting the address family to unspecified. 21 HostCache::Key Key(const std::string& hostname) { 22 return HostCache::Key(hostname, ADDRESS_FAMILY_UNSPECIFIED, 0); 23 } 24 25 } // namespace 26 27 TEST(HostCacheTest, Basic) { 28 const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10); 29 30 HostCache cache(kMaxCacheEntries); 31 32 // Start at t=0. 33 base::TimeTicks now; 34 35 HostCache::Key key1 = Key("foobar.com"); 36 HostCache::Key key2 = Key("foobar2.com"); 37 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 38 39 EXPECT_EQ(0U, cache.size()); 40 41 // Add an entry for "foobar.com" at t=0. 42 EXPECT_FALSE(cache.Lookup(key1, now)); 43 cache.Set(key1, entry, now, kTTL); 44 EXPECT_TRUE(cache.Lookup(key1, now)); 45 EXPECT_TRUE(cache.Lookup(key1, now)->error == entry.error); 46 47 EXPECT_EQ(1U, cache.size()); 48 49 // Advance to t=5. 50 now += base::TimeDelta::FromSeconds(5); 51 52 // Add an entry for "foobar2.com" at t=5. 53 EXPECT_FALSE(cache.Lookup(key2, now)); 54 cache.Set(key2, entry, now, kTTL); 55 EXPECT_TRUE(cache.Lookup(key2, now)); 56 EXPECT_EQ(2U, cache.size()); 57 58 // Advance to t=9 59 now += base::TimeDelta::FromSeconds(4); 60 61 // Verify that the entries we added are still retrievable, and usable. 62 EXPECT_TRUE(cache.Lookup(key1, now)); 63 EXPECT_TRUE(cache.Lookup(key2, now)); 64 EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now)); 65 66 // Advance to t=10; key is now expired. 67 now += base::TimeDelta::FromSeconds(1); 68 69 EXPECT_FALSE(cache.Lookup(key1, now)); 70 EXPECT_TRUE(cache.Lookup(key2, now)); 71 72 // Update key1, so it is no longer expired. 73 cache.Set(key1, entry, now, kTTL); 74 EXPECT_TRUE(cache.Lookup(key1, now)); 75 EXPECT_EQ(2U, cache.size()); 76 77 // Both entries should still be retrievable and usable. 78 EXPECT_TRUE(cache.Lookup(key1, now)); 79 EXPECT_TRUE(cache.Lookup(key2, now)); 80 81 // Advance to t=20; both entries are now expired. 82 now += base::TimeDelta::FromSeconds(10); 83 84 EXPECT_FALSE(cache.Lookup(key1, now)); 85 EXPECT_FALSE(cache.Lookup(key2, now)); 86 } 87 88 // Try caching entries for a failed resolve attempt -- since we set the TTL of 89 // such entries to 0 it won't store, but it will kick out the previous result. 90 TEST(HostCacheTest, NoCacheZeroTTL) { 91 const base::TimeDelta kSuccessEntryTTL = base::TimeDelta::FromSeconds(10); 92 const base::TimeDelta kFailureEntryTTL = base::TimeDelta::FromSeconds(0); 93 94 HostCache cache(kMaxCacheEntries); 95 96 // Set t=0. 97 base::TimeTicks now; 98 99 HostCache::Key key1 = Key("foobar.com"); 100 HostCache::Key key2 = Key("foobar2.com"); 101 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 102 103 EXPECT_FALSE(cache.Lookup(key1, now)); 104 cache.Set(key1, entry, now, kFailureEntryTTL); 105 EXPECT_EQ(1U, cache.size()); 106 107 // We disallow use of negative entries. 108 EXPECT_FALSE(cache.Lookup(key1, now)); 109 110 // Now overwrite with a valid entry, and then overwrite with negative entry 111 // again -- the valid entry should be kicked out. 112 cache.Set(key1, entry, now, kSuccessEntryTTL); 113 EXPECT_TRUE(cache.Lookup(key1, now)); 114 cache.Set(key1, entry, now, kFailureEntryTTL); 115 EXPECT_FALSE(cache.Lookup(key1, now)); 116 } 117 118 // Try caching entries for a failed resolves for 10 seconds. 119 TEST(HostCacheTest, CacheNegativeEntry) { 120 const base::TimeDelta kFailureEntryTTL = base::TimeDelta::FromSeconds(10); 121 122 HostCache cache(kMaxCacheEntries); 123 124 // Start at t=0. 125 base::TimeTicks now; 126 127 HostCache::Key key1 = Key("foobar.com"); 128 HostCache::Key key2 = Key("foobar2.com"); 129 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 130 131 EXPECT_EQ(0U, cache.size()); 132 133 // Add an entry for "foobar.com" at t=0. 134 EXPECT_FALSE(cache.Lookup(key1, now)); 135 cache.Set(key1, entry, now, kFailureEntryTTL); 136 EXPECT_TRUE(cache.Lookup(key1, now)); 137 EXPECT_EQ(1U, cache.size()); 138 139 // Advance to t=5. 140 now += base::TimeDelta::FromSeconds(5); 141 142 // Add an entry for "foobar2.com" at t=5. 143 EXPECT_FALSE(cache.Lookup(key2, now)); 144 cache.Set(key2, entry, now, kFailureEntryTTL); 145 EXPECT_TRUE(cache.Lookup(key2, now)); 146 EXPECT_EQ(2U, cache.size()); 147 148 // Advance to t=9 149 now += base::TimeDelta::FromSeconds(4); 150 151 // Verify that the entries we added are still retrievable, and usable. 152 EXPECT_TRUE(cache.Lookup(key1, now)); 153 EXPECT_TRUE(cache.Lookup(key2, now)); 154 155 // Advance to t=10; key1 is now expired. 156 now += base::TimeDelta::FromSeconds(1); 157 158 EXPECT_FALSE(cache.Lookup(key1, now)); 159 EXPECT_TRUE(cache.Lookup(key2, now)); 160 161 // Update key1, so it is no longer expired. 162 cache.Set(key1, entry, now, kFailureEntryTTL); 163 // Re-uses existing entry storage. 164 EXPECT_TRUE(cache.Lookup(key1, now)); 165 EXPECT_EQ(2U, cache.size()); 166 167 // Both entries should still be retrievable and usable. 168 EXPECT_TRUE(cache.Lookup(key1, now)); 169 EXPECT_TRUE(cache.Lookup(key2, now)); 170 171 // Advance to t=20; both entries are now expired. 172 now += base::TimeDelta::FromSeconds(10); 173 174 EXPECT_FALSE(cache.Lookup(key1, now)); 175 EXPECT_FALSE(cache.Lookup(key2, now)); 176 } 177 178 // Tests that the same hostname can be duplicated in the cache, so long as 179 // the address family differs. 180 TEST(HostCacheTest, AddressFamilyIsPartOfKey) { 181 const base::TimeDelta kSuccessEntryTTL = base::TimeDelta::FromSeconds(10); 182 183 HostCache cache(kMaxCacheEntries); 184 185 // t=0. 186 base::TimeTicks now; 187 188 HostCache::Key key1("foobar.com", ADDRESS_FAMILY_UNSPECIFIED, 0); 189 HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4, 0); 190 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 191 192 EXPECT_EQ(0U, cache.size()); 193 194 // Add an entry for ("foobar.com", UNSPECIFIED) at t=0. 195 EXPECT_FALSE(cache.Lookup(key1, now)); 196 cache.Set(key1, entry, now, kSuccessEntryTTL); 197 EXPECT_TRUE(cache.Lookup(key1, now)); 198 EXPECT_EQ(1U, cache.size()); 199 200 // Add an entry for ("foobar.com", IPV4_ONLY) at t=0. 201 EXPECT_FALSE(cache.Lookup(key2, now)); 202 cache.Set(key2, entry, now, kSuccessEntryTTL); 203 EXPECT_TRUE(cache.Lookup(key2, now)); 204 EXPECT_EQ(2U, cache.size()); 205 206 // Even though the hostnames were the same, we should have two unique 207 // entries (because the address families differ). 208 EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now)); 209 } 210 211 // Tests that the same hostname can be duplicated in the cache, so long as 212 // the HostResolverFlags differ. 213 TEST(HostCacheTest, HostResolverFlagsArePartOfKey) { 214 const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10); 215 216 HostCache cache(kMaxCacheEntries); 217 218 // t=0. 219 base::TimeTicks now; 220 221 HostCache::Key key1("foobar.com", ADDRESS_FAMILY_IPV4, 0); 222 HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4, 223 HOST_RESOLVER_CANONNAME); 224 HostCache::Key key3("foobar.com", ADDRESS_FAMILY_IPV4, 225 HOST_RESOLVER_LOOPBACK_ONLY); 226 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 227 228 EXPECT_EQ(0U, cache.size()); 229 230 // Add an entry for ("foobar.com", IPV4, NONE) at t=0. 231 EXPECT_FALSE(cache.Lookup(key1, now)); 232 cache.Set(key1, entry, now, kTTL); 233 EXPECT_TRUE(cache.Lookup(key1, now)); 234 EXPECT_EQ(1U, cache.size()); 235 236 // Add an entry for ("foobar.com", IPV4, CANONNAME) at t=0. 237 EXPECT_FALSE(cache.Lookup(key2, now)); 238 cache.Set(key2, entry, now, kTTL); 239 EXPECT_TRUE(cache.Lookup(key2, now)); 240 EXPECT_EQ(2U, cache.size()); 241 242 // Add an entry for ("foobar.com", IPV4, LOOPBACK_ONLY) at t=0. 243 EXPECT_FALSE(cache.Lookup(key3, now)); 244 cache.Set(key3, entry, now, kTTL); 245 EXPECT_TRUE(cache.Lookup(key3, now)); 246 EXPECT_EQ(3U, cache.size()); 247 248 // Even though the hostnames were the same, we should have two unique 249 // entries (because the HostResolverFlags differ). 250 EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now)); 251 EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key3, now)); 252 EXPECT_NE(cache.Lookup(key2, now), cache.Lookup(key3, now)); 253 } 254 255 TEST(HostCacheTest, NoCache) { 256 // Disable caching. 257 const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10); 258 259 HostCache cache(0); 260 EXPECT_TRUE(cache.caching_is_disabled()); 261 262 // Set t=0. 263 base::TimeTicks now; 264 265 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 266 267 // Lookup and Set should have no effect. 268 EXPECT_FALSE(cache.Lookup(Key("foobar.com"),now)); 269 cache.Set(Key("foobar.com"), entry, now, kTTL); 270 EXPECT_FALSE(cache.Lookup(Key("foobar.com"), now)); 271 272 EXPECT_EQ(0U, cache.size()); 273 } 274 275 TEST(HostCacheTest, Clear) { 276 const base::TimeDelta kTTL = base::TimeDelta::FromSeconds(10); 277 278 HostCache cache(kMaxCacheEntries); 279 280 // Set t=0. 281 base::TimeTicks now; 282 283 HostCache::Entry entry = HostCache::Entry(OK, AddressList()); 284 285 EXPECT_EQ(0u, cache.size()); 286 287 // Add three entries. 288 cache.Set(Key("foobar1.com"), entry, now, kTTL); 289 cache.Set(Key("foobar2.com"), entry, now, kTTL); 290 cache.Set(Key("foobar3.com"), entry, now, kTTL); 291 292 EXPECT_EQ(3u, cache.size()); 293 294 cache.clear(); 295 296 EXPECT_EQ(0u, cache.size()); 297 } 298 299 // Tests the less than and equal operators for HostCache::Key work. 300 TEST(HostCacheTest, KeyComparators) { 301 struct { 302 // Inputs. 303 HostCache::Key key1; 304 HostCache::Key key2; 305 306 // Expectation. 307 // -1 means key1 is less than key2 308 // 0 means key1 equals key2 309 // 1 means key1 is greater than key2 310 int expected_comparison; 311 } tests[] = { 312 { 313 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 314 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 315 0 316 }, 317 { 318 HostCache::Key("host1", ADDRESS_FAMILY_IPV4, 0), 319 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 320 1 321 }, 322 { 323 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 324 HostCache::Key("host1", ADDRESS_FAMILY_IPV4, 0), 325 -1 326 }, 327 { 328 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 329 HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED, 0), 330 -1 331 }, 332 { 333 HostCache::Key("host1", ADDRESS_FAMILY_IPV4, 0), 334 HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED, 0), 335 1 336 }, 337 { 338 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 339 HostCache::Key("host2", ADDRESS_FAMILY_IPV4, 0), 340 -1 341 }, 342 { 343 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 344 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 345 HOST_RESOLVER_CANONNAME), 346 -1 347 }, 348 { 349 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 350 HOST_RESOLVER_CANONNAME), 351 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 0), 352 1 353 }, 354 { 355 HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED, 356 HOST_RESOLVER_CANONNAME), 357 HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED, 358 HOST_RESOLVER_CANONNAME), 359 -1 360 }, 361 }; 362 363 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) { 364 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i)); 365 366 const HostCache::Key& key1 = tests[i].key1; 367 const HostCache::Key& key2 = tests[i].key2; 368 369 switch (tests[i].expected_comparison) { 370 case -1: 371 EXPECT_TRUE(key1 < key2); 372 EXPECT_FALSE(key2 < key1); 373 break; 374 case 0: 375 EXPECT_FALSE(key1 < key2); 376 EXPECT_FALSE(key2 < key1); 377 break; 378 case 1: 379 EXPECT_FALSE(key1 < key2); 380 EXPECT_TRUE(key2 < key1); 381 break; 382 default: 383 FAIL() << "Invalid expectation. Can be only -1, 0, 1"; 384 } 385 } 386 } 387 388 } // namespace net 389
