Disk cache: Add a unit test that instantiates three caches...

net/disk_cache/disk_cache_test_util.cc

 // Copyright (c) 2006-2008 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 "net/disk_cache/disk_cache_test_util.h"
 
 #include "base/logging.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/file.h"
 
 using base::Time;
 using base::TimeDelta;
 
+namespace {
+
+std::wstring BuildCachePath(const std::wstring name) {

[Alpha Left Google, 2009/03/26 00:08:12]

Can we name this function GetCachePath(const std::wstring name)? We can also get
rid of namespace and put it next to GetCachePath.

+  std::wstring path;
+  PathService::Get(base::DIR_TEMP, &path);
+  file_util::AppendToPath(&path, name);
+  if (!file_util::PathExists(path))
+    file_util::CreateDirectory(path);
+
+  return path;
+}
+
+}  // namespace.
+
 std::string GenerateKey(bool same_length) {
   char key[200];
   CacheTestFillBuffer(key, sizeof(key), same_length);
 
   key[199] = '\0';
   return std::string(key);
 }
 
 void CacheTestFillBuffer(char* buffer, size_t len, bool no_nulls) {
   static bool called = false;
   if (!called) {
     called = true;
     int seed = static_cast<int>(Time::Now().ToInternalValue());
     srand(seed);
   }
 
   for (size_t i = 0; i < len; i++) {
     buffer[i] = static_cast<char>(rand());
     if (!buffer[i] && no_nulls)
       buffer[i] = 'g';
   }
   if (len && !buffer[0])
     buffer[0] = 'g';
 }
 
 std::wstring GetCachePath() {
-  std::wstring path;
-  PathService::Get(base::DIR_TEMP, &path);
-  file_util::AppendToPath(&path, L"cache_test");
-  if (!file_util::PathExists(path))
-    file_util::CreateDirectory(path);
-
-  return path;
+  return BuildCachePath(L"cache_test");
 }
 
 bool CreateCacheTestFile(const wchar_t* name) {
   using namespace disk_cache;
   int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
               base::PLATFORM_FILE_READ |
               base::PLATFORM_FILE_WRITE;
 
   scoped_refptr<File> file(new File(
       base::CreatePlatformFile(name, flags, NULL)));
@@ skipping 16 matching lines @@
   if (!cache->Init())
     return false;
   return cache->SelfCheck() >= 0;
 }
 
 ScopedTestCache::ScopedTestCache() : path_(GetCachePath()) {
   bool result = DeleteCache(path_.c_str());
   DCHECK(result);
 }
 
+ScopedTestCache::ScopedTestCache(const std::wstring& name)
+    : path_(BuildCachePath(name)) {
+  bool result = DeleteCache(path_.c_str());
+  DCHECK(result);
+}
+
 ScopedTestCache::~ScopedTestCache() {
   file_util::Delete(path(), true);
 }
 
 // -----------------------------------------------------------------------
 
 int g_cache_tests_max_id = 0;
 volatile int g_cache_tests_received = 0;
 volatile bool g_cache_tests_error = 0;
 
@@ skipping 45 matching lines @@
   } else {
     // Not finished yet. See if we have to abort.
     if (last_ == g_cache_tests_received)
       num_iterations_++;
     else
       last_ = g_cache_tests_received;
     if (40 == num_iterations_)
       MessageLoop::current()->Quit();
   }
 }