lib/cpp/src/concurrency/test/TimerManagerTests.h

#include <concurrency/TimerManager.h>
#include <concurrency/PosixThreadFactory.h>
#include <concurrency/Monitor.h>
#include <concurrency/Util.h>

#include <assert.h>
#include <iostream>

namespace facebook { namespace thrift { namespace concurrency { namespace test {

using namespace facebook::thrift::concurrency;

/** ThreadManagerTests class 

    @author marc
    @version $Id:$ */

class TimerManagerTests {

 public:

  static const double ERROR;

 class Task: public Runnable {

  public:
    
    Task(Monitor& monitor, long long timeout) : 
      _timeout(timeout),
      _startTime(Util::currentTime()),
      _monitor(monitor),
      _success(false),
    _done(false) {}

   ~Task() {std::cerr << this << std::endl;}

    void run() {

      _endTime = Util::currentTime();

      // Figure out error percentage

      long long delta = _endTime - _startTime;


      delta = delta > _timeout ?  delta - _timeout : _timeout - delta;

      float error = delta / _timeout;

      if(error < ERROR) {
	_success = true;
      }
      
      _done = true;

      std::cout << "\t\t\tTimerManagerTests::Task[" << this << "] done" << std::endl; //debug      

      {Synchronized s(_monitor);
	_monitor.notifyAll();
      }
    }

    

    long long _timeout;
    long long _startTime;
    long long _endTime;
    Monitor& _monitor;
    bool _success;
    bool _done;
  };

  /** This test creates two tasks and waits for the first to expire within 10% of the expected expiration time.  It then verifies that
      the timer manager properly clean up itself and the remaining orphaned timeout task when the manager goes out of scope and its 
      destructor is called. */

  bool test00(long long timeout=1000LL) {

    shared_ptr<TimerManagerTests::Task> orphanTask = shared_ptr<TimerManagerTests::Task>(new TimerManagerTests::Task(_monitor, 10 * timeout));

    {

      TimerManager timerManager;
      
      timerManager.threadFactory(shared_ptr<PosixThreadFactory>(new PosixThreadFactory()));
      
      timerManager.start();
      
      assert(timerManager.state() == TimerManager::STARTED);

      shared_ptr<TimerManagerTests::Task> task = shared_ptr<TimerManagerTests::Task>(new TimerManagerTests::Task(_monitor, timeout));

      {Synchronized s(_monitor);

	timerManager.add(orphanTask, 10 * timeout);

	timerManager.add(task, timeout);

	_monitor.wait();
      }

      assert(task->_done);


      std::cout << "\t\t\t" << (task->_success ? "Success" : "Failure") << "!" << std::endl;
    }

    // timerManager.stop(); This is where it happens via destructor

    assert(!orphanTask->_done);

    return true;
  }

  friend class TestTask;

  Monitor _monitor;
};

const double TimerManagerTests::ERROR = .20;
  
}}}} // facebook::thrift::concurrency