Add support for the control group in the Simple Cache Experiment.

net/disk_cache/backend_unittest.cc

 // 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 "base/basictypes.h"
 #include "base/file_util.h"
+#include "base/metrics/field_trial.h"
 #include "base/port.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/mapped_file.h"
 #include "net/disk_cache/mem_backend_impl.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "net/disk_cache/tracing_cache_backend.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 using base::Time;
 
+namespace {
+
 // Tests that can run with different types of caches.
 class DiskCacheBackendTest : public DiskCacheTestWithCache {
  protected:
   void BackendBasics();
   void BackendKeying();
   void BackendShutdownWithPendingFileIO(bool fast);
   void BackendShutdownWithPendingIO(bool fast);
   void BackendShutdownWithPendingCreate(bool fast);
   void BackendSetSize();
   void BackendLoad();
@@ skipping 1625 matching lines @@
   net::TestCompletionCallback cb;
 
   disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
       cache_path_, cache_thread.message_loop_proxy(), NULL);
   int rv = cache->Init(cb.callback());
   ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
 
   delete cache;
 }
 
+class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
+ public:
+  virtual ~BadEntropyProvider() {}
+
+  virtual double GetEntropyForTrial(const std::string& trial_name,
+                                    uint32 randomization_seed) const OVERRIDE {
+    return 0.5;
+  }
+};
+
+TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
+  ASSERT_TRUE(CopyTestCache("insert_empty1"));
+
+  base::FieldTrialList field_trial_list(new BadEntropyProvider());
+  base::FieldTrialList::FactoryGetFieldTrial("SimpleCacheTrial", 100,
+                                             "Control", 2013, 12, 31, NULL);
+
+  base::Thread cache_thread("CacheThread");
+  ASSERT_TRUE(cache_thread.StartWithOptions(
+                  base::Thread::Options(MessageLoop::TYPE_IO, 0)));
+  net::TestCompletionCallback cb;
+
+  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
+      cache_path_, cache_thread.message_loop_proxy(), NULL);
+  int rv = cache->Init(cb.callback());
+  ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
+
+  delete cache;
+}
+
+TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
+  ASSERT_TRUE(CopyTestCache("simple_cache_control"));
+
+  base::FieldTrialList field_trial_list(new BadEntropyProvider());
+  base::FieldTrialList::FactoryGetFieldTrial("SimpleCacheTrial", 100,
+                                             "Control", 2013, 12, 31, NULL);
+
+  base::Thread cache_thread("CacheThread");
+  ASSERT_TRUE(cache_thread.StartWithOptions(
+                  base::Thread::Options(MessageLoop::TYPE_IO, 0)));
+  net::TestCompletionCallback cb;
+
+  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
+      cache_path_, cache_thread.message_loop_proxy(), NULL);
+  int rv = cache->Init(cb.callback());
+  ASSERT_EQ(net::OK, cb.GetResult(rv));
+
+  delete cache;
+}
+
+TEST_F(DiskCacheTest, SimpleCacheControlLeave) {
+  ASSERT_TRUE(CopyTestCache("simple_cache_control"));

[pasko-google - do not use, 2013/04/19 18:00:30]

coud we create this file programmatically here? binary files are not easy to
read

[gavinp, 2013/04/20 07:17:32]

Mooted, as Ricardo has asked for the removal of these tests.

+
+  base::Thread cache_thread("CacheThread");
+  ASSERT_TRUE(cache_thread.StartWithOptions(
+                  base::Thread::Options(MessageLoop::TYPE_IO, 0)));
+  net::TestCompletionCallback cb;
+
+  disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
+      cache_path_, cache_thread.message_loop_proxy(), NULL);
+  int rv = cache->Init(cb.callback());
+  ASSERT_EQ(net::OK, cb.GetResult(rv));
+
+  delete cache;
+}
+

[rvargas (doing something else), 2013/04/19 17:40:55]

I would actually prefer not adding these tests. I believe they generate more
burden than the value they provide. Every line of code that we add has a cost
somewhere... building time, infrastructure costs (moving the tests to test bots,
waterfall and try bot cycle time), reviewing time, maintenance costs etc, and I
don't think this is worth it (even though you already paid the writing cost).

[gavinp, 2013/04/20 07:17:32]

Done.

 // Tests that the cache is properly restarted on recovery error.
 TEST_F(DiskCacheBackendTest, DeleteOld) {
   ASSERT_TRUE(CopyTestCache("wrong_version"));
   SetNewEviction();
   base::Thread cache_thread("CacheThread");
   ASSERT_TRUE(cache_thread.StartWithOptions(
                   base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
   net::TestCompletionCallback cb;
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
@@ skipping 1100 matching lines @@
   cache_->OnExternalCacheHit("key0");
 
   TrimForTest(false);
 
   // Make sure the older key remains.
   EXPECT_EQ(1, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
   entry->Close();
 }
 
+}  // namespace

[rvargas (doing something else), 2013/04/19 17:40:55]

I don't understand why you're placing half of the file on an anonymous
namespace.

[gavinp, 2013/04/20 07:17:32]

Moot, now that I"m not adding tests.

+
 void DiskCacheBackendTest::TracingBackendBasics() {
   InitCache();
   cache_ = new disk_cache::TracingCacheBackend(cache_);
   cache_impl_ = NULL;
   EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
   if (!simple_cache_mode_) {
     EXPECT_EQ(0, cache_->GetEntryCount());
   }
 
   net::TestCompletionCallback cb;
@@ skipping 95 matching lines @@
   BackendDoomRecent();
 }
 
 TEST_F(DiskCacheBackendTest, SimpleDoomBetween) {
   SetSimpleCacheMode();
   InitCache();
   BackendDoomBetween();
 }
 
 #endif  // !defined(OS_WIN)