net/disk_cache/disk_cache_test_util.h

   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 #ifndef NET_DISK_CACHE_DISK_CACHE_TEST_UTIL_H_
   6 #define NET_DISK_CACHE_DISK_CACHE_TEST_UTIL_H_
   7
   8 #include <string>
   9
  10 #include "base/files/file_path.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/timer/timer.h"
  13 #include "base/tuple.h"
  14 #include "build/build_config.h"
  15
  16 // Re-creates a given test file inside the cache test folder.
  17 bool CreateCacheTestFile(const base::FilePath& name);
  18
  19 // Deletes all file son the cache.
  20 bool DeleteCache(const base::FilePath& path);
  21
  22 // Fills buffer with random values (may contain nulls unless no_nulls is true).
  23 void CacheTestFillBuffer(char* buffer, size_t len, bool no_nulls);
  24
  25 // Generates a random key of up to 200 bytes.
  26 std::string GenerateKey(bool same_length);
  27
  28 // Returns true if the cache is not corrupt.
  29 bool CheckCacheIntegrity(const base::FilePath& path, bool new_eviction,
  30                          uint32 mask);
  31
  32 // -----------------------------------------------------------------------
  33
  34 // Simple helper to deal with the message loop on a test.
  35 class MessageLoopHelper {
  36  public:
  37   MessageLoopHelper();
  38   ~MessageLoopHelper();
  39
  40   // Run the message loop and wait for num_callbacks before returning. Returns
  41   // false if we are waiting to long. Each callback that will be waited on is
  42   // required to call CallbackWasCalled() to indicate when it was called.
  43   bool WaitUntilCacheIoFinished(int num_callbacks);
  44
  45   // True if a given callback was called more times than it expected.
  46   bool callback_reused_error() const { return callback_reused_error_; }
  47   void set_callback_reused_error(bool error) {
  48     callback_reused_error_ = error;
  49   }
  50
  51   int callbacks_called() const { return callbacks_called_; }
  52   // Report that a callback was called. Each callback that will be waited on
  53   // via WaitUntilCacheIoFinished() is expected to call this method to
  54   // indicate when it has been executed.
  55   void CallbackWasCalled() { ++callbacks_called_; }
  56
  57  private:
  58   // Sets the number of callbacks that can be received so far.
  59   void ExpectCallbacks(int num_callbacks) {
  60     num_callbacks_ = num_callbacks;
  61     num_iterations_ = last_ = 0;
  62     completed_ = false;
  63   }
  64
  65   // Called periodically to test if WaitUntilCacheIoFinished should return.
  66   void TimerExpired();
  67
  68   base::RepeatingTimer<MessageLoopHelper> timer_;
  69   int num_callbacks_;
  70   int num_iterations_;
  71   int last_;
  72   bool completed_;
  73
  74   // True if a callback was called/reused more than expected.
  75   bool callback_reused_error_;
  76   int callbacks_called_;
  77
  78   DISALLOW_COPY_AND_ASSIGN(MessageLoopHelper);
  79 };
  80
  81 // -----------------------------------------------------------------------
  82
  83 // Simple callback to process IO completions from the cache. It allows tests
  84 // with multiple simultaneous IO operations.
  85 class CallbackTest {
  86  public:
  87   // Creates a new CallbackTest object. When the callback is called, it will
  88   // update |helper|. If |reuse| is false and a callback is called more than
  89   // once, or if |reuse| is true and a callback is called more than twice, an
  90   // error will be reported to |helper|.
  91   CallbackTest(MessageLoopHelper* helper, bool reuse);
  92   ~CallbackTest();
  93
  94   void Run(int result);
  95
  96   int last_result() const { return last_result_; }
  97
  98  private:
  99   MessageLoopHelper* helper_;
 100   int reuse_;
 101   int last_result_;
 102   DISALLOW_COPY_AND_ASSIGN(CallbackTest);
 103 };
 104
 105 #endif  // NET_DISK_CACHE_DISK_CACHE_TEST_UTIL_H_