condvar_test_base.h

Go to the documentation of this file.

// Copyright 2011 Google Inc.

#ifndef PAGESPEED_KERNEL_THREAD_CONDVAR_TEST_BASE_H_
#define PAGESPEED_KERNEL_THREAD_CONDVAR_TEST_BASE_H_

#include "pagespeed/kernel/base/condvar.h"

#include "base/logging.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/gtest.h"
#include "pagespeed/kernel/base/timer.h"
#include "pagespeed/kernel/base/thread_system.h"

namespace net_instaweb {

class CondvarTestBase : public testing::Test {
 protected:
  typedef void (ThreadSystem::Condvar::*SignalMethod)();

  CondvarTestBase()
      : mutex_(NULL),
        startup_condvar_(NULL),
        condvar_(NULL),
        ready_to_start_(false),
        iters_(0),
        current_iter_(0),
        signal_method_(&ThreadSystem::Condvar::Signal),
        wait_after_signal_(false),
        helper_increments_(0),
        init_called_(false) {
  }

  void Init(ThreadSystem::CondvarCapableMutex* mutex,
            ThreadSystem::Condvar* startup_condvar,
            ThreadSystem::Condvar* condvar) {
    CHECK(!init_called_);
    mutex_ = mutex;
    startup_condvar_ = startup_condvar;
    condvar_ = condvar;
    init_called_ = true;
  }

  static void* HelperThread(void* data) {
    CondvarTestBase* test = static_cast<CondvarTestBase*>(data);
    test->HelperThreadMethod();
    return NULL;
  }

  virtual void CreateHelper() = 0;

  virtual void FinishHelper() = 0;

  void StartHelper() {
    CHECK(init_called_);
    CreateHelper();
    {
      ScopedMutex lock(mutex_);
      ready_to_start_ = true;
      startup_condvar_->Signal();
    }
  }

  virtual void HelperThreadMethod() {
    {
      ScopedMutex lock(mutex_);
      while (!ready_to_start_) {
        startup_condvar_->Wait();
      }
    }
    while (true) {
      ScopedMutex lock(mutex_);
      int iter = current_iter_ + 1;
      if (iter > iters_) {
        return;
      }
      ++helper_increments_;
      current_iter_ = iter;
      (condvar_->*signal_method_)();
      while (wait_after_signal_ && current_iter_ == iter) {
        condvar_->Wait();
      }
    }
  }


  void StartupTest() {
    StartHelper();
    EXPECT_TRUE(ready_to_start_);
    FinishHelper();
    EXPECT_EQ(helper_increments_, 0);
  }

  void BlindSignalsTest() {
    iters_ = 10;
    StartHelper();
    EXPECT_TRUE(ready_to_start_);
    FinishHelper();
    EXPECT_EQ(helper_increments_, 10);
  }

  void PingPongTest() {
    iters_ = 10;
    wait_after_signal_ = true;
    StartHelper();
    int local_increments = 0;
    while (true) {
      ScopedMutex lock(mutex_);
      while ((current_iter_ % 2) == 0 && current_iter_ < iters_) {
        condvar_->Wait();
      }
      if (current_iter_ == iters_) {
        break;
      }
      ++current_iter_;
      ++local_increments;
      condvar_->Signal();
    }
    EXPECT_EQ(local_increments, 5);
    FinishHelper();
    EXPECT_EQ(helper_increments_, 5);
  }

  void TimeoutTest() {
    iters_ = 0;
    StartHelper();
    {
      ScopedMutex lock(mutex_);
      condvar_->TimedWait(10); 
    }
    FinishHelper();
  }

  void LongTimeoutTest(int wait_ms) {
    iters_ = 0;
    StartHelper();
    int64 start_ms = timer()->NowMs();
    {
      ScopedMutex lock(mutex_);
      condvar_->TimedWait(wait_ms);
    }
    int64 end_ms = timer()->NowMs();

    EXPECT_LE(wait_ms, end_ms - start_ms);
    FinishHelper();
  }

  void TimeoutPingPongTest() {
    iters_ = 10;
    wait_after_signal_ = true;
    StartHelper();
    int local_increments = 0;
    while (true) {
      ScopedMutex lock(mutex_);
      if ((current_iter_ % 2) == 0) {
        condvar_->TimedWait(1);
      }
      if (current_iter_ > iters_) {
        break;
      }
      ++current_iter_;
      ++local_increments;
      condvar_->Signal();
    }
    FinishHelper();
    EXPECT_LE(6, local_increments);
    EXPECT_GE(5, helper_increments_);
    EXPECT_EQ(11, local_increments + helper_increments_);
  }

  virtual Timer* timer() = 0;

  ThreadSystem::CondvarCapableMutex* mutex_;
  ThreadSystem::Condvar* startup_condvar_;
  ThreadSystem::Condvar* condvar_;
  bool ready_to_start_;
  int iters_;
  int current_iter_;
  SignalMethod signal_method_;
  bool wait_after_signal_;
  int helper_increments_;
  bool init_called_;

 private:
  
};

}  

#endif