|
|
#ifndef _TTIMER_HXX_
#define _TTIMER_HXX_
template < class TEnum > TEnum operator ++ ( TEnum &sub_phase, int ){ TEnum old = sub_phase; sub_phase = static_cast<TEnum>( static_cast<int>(sub_phase) + 1 ); return( old );}
class CTimerTest : public PTimerCallback{
public:
CTimerTest() { _fInitialized = FALSE; _cftExpected = 0; _hEvent = NULL; _ptszName = NULL; }
virtual ~CTimerTest() { UnInitialize(); }
public:
void Initialize(PTimerCallback *pTimerCallback, const TCHAR *ptszName, ULONG ulTimerContext, ULONG ulPeriodInSeconds, CNewTimer::TimerRetryType retrytype, ULONG ulLowerRetryTime, ULONG ulUpperRetryTime, ULONG ulMaxLifetime );
void UnInitialize() { if( _fInitialized ) { _timer.Cancel(); _timer.UnInitialize();
_fInitialized = FALSE; } }
public:
void WaitForTestToComplete() { if( 0xffffffff == WaitForSingleObjectEx( _hEvent, INFINITE, FALSE )) { TrkLog(( TRKDBG_ERROR, TEXT("Couldn't wait for event"))); TrkRaiseLastError( ); } }
void MarkTestCompleted() { if( !SetEvent( _hEvent )) TrkRaiseLastError( ); }
void EnsureTimerIsStopped( ) { _tprintf( TEXT(" Verifying that timer is stopped (%ds)\n"), g_ulDefaultPeriod * 2 ); VerifyRegistryDataRemoved(); Sleep( g_ulDefaultPeriod * 2 * 1000 ); }
void SetTimerRegistryValue( const TCHAR *ptszName, const CFILETIME &cftSet, const CFILETIME cftDue, ULONG ulRetry );
void VerifyRegistryDataCorrect(); void VerifyRegistryDataRemoved();
public:
void SetSingleShot( const CFILETIME &cftExpected = 0 ) { if( 0 != cftExpected ) _cftExpected = cftExpected; else { _cftExpected = CFILETIME(); _cftExpected.IncrementSeconds( _ulPeriod ); } _timer.SetSingleShot(); TrkLog(( TRKDBG_TIMER, TEXT("%s"), CDebugString( _timer )._tsz ));
if( _ptszName ) VerifyRegistryDataCorrect(); }
void SetRecurring( const CFILETIME &cftExpected = 0 ) { if( 0 != cftExpected ) _cftExpected = cftExpected; else { _cftExpected = CFILETIME(); _cftExpected.IncrementSeconds( _ulPeriod ); }
_timer.SetRecurring();
if( _ptszName ) VerifyRegistryDataCorrect(); }
protected:
BOOL _fInitialized; CNewTimer _timer; ULONG _ulPeriod; const TCHAR * _ptszName;
CFILETIME _cftExpected; HANDLE _hEvent;
};
class CTimerTest0 : public CTimerTest{
public:
CTimerTest0() { }
~CTimerTest0() { UnInitialize(); }
public:
void Initialize() { _tprintf( TEXT("Starting a timer with a given due time (%ds)\n"), g_ulDefaultPeriod );
_ulPeriod = g_ulDefaultPeriod; CTimerTest::Initialize( this, NULL, 0, _ulPeriod, CNewTimer::NO_RETRY, 0, 0, 0 );
}
public:
void Set() { SetSingleShot(); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
}; // class CTimerTest0
class CTimerTest1 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, FIRST_RECURRENCE = 2, FIRST_RETRY = 3, SECOND_RETRY = 4, THIRD_RETRY = 5, FOURTH_RETRY = 6, SECOND_RECURRENCE = 7, LAST_RETRY = 8, FINAL = 9 };
public:
CTimerTest1() { _SubPhase = INITIAL; }
~CTimerTest1() { UnInitialize(); }
public:
void Initialize() { _tprintf( TEXT("Starting a persistent, recurring, backoff-retry (%d-%ds) timer (%ds)\n"), g_ulMinRetry, g_ulMaxRetry, g_ulDefaultPeriod );
_ulPeriod = g_ulDefaultPeriod; CTimerTest::Initialize( this, L"Timer1", 1, _ulPeriod, CNewTimer::RETRY_WITH_BACKOFF, g_ulMinRetry, g_ulMaxRetry, 0 );
}
public:
void Set() { SetRecurring(); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest1
class CTimerTest2 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, RESET = 2, FINAL = 3 };
public:
CTimerTest2() { _SubPhase = INITIAL; }
~CTimerTest2() { UnInitialize(); }
public:
void Initialize() { _tprintf( TEXT("Starting a persistent, recurring, non-retrying timer (%ds)\n"), g_ulDefaultPeriod );
_ulPeriod = g_ulDefaultPeriod; CTimerTest::Initialize( this, L"Timer2", 2, _ulPeriod, CNewTimer::NO_RETRY, 0, 0, 0 );
}
public:
void Set() { SetRecurring(); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest1
class CTimerTest3 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, FINAL = 2 };
public:
CTimerTest3() { _SubPhase = INITIAL; }
~CTimerTest3() { UnInitialize(); }
public:
void Initialize() { CFILETIME cftNow; LONG lRet;
_tprintf( TEXT("Continuing a persistent timer (0s)\n") );
SetTimerRegistryValue( TEXT("Timer3"), 0, cftNow-1, 0 );
// We set a period, but it should really go off immediately because
// of the registry value we just set.
_ulPeriod = g_ulDefaultPeriod; CTimerTest::Initialize( this, // PTimerCallback
L"Timer3", // Timer name
3, // Timer context
_ulPeriod, // Period in seconds
CNewTimer::NO_RETRY, 0, 0, 0 ); // Lower, upper, max retry times.
}
public:
void Set() { SetSingleShot( CFILETIME() - 1 ); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest1
class CTimerTest4 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, SECOND = 2, THIRD = 3, FOURTH = 4, FINAL = 5 };
public:
CTimerTest4() { _SubPhase = INITIAL; }
~CTimerTest4() { UnInitialize(); }
public:
void Initialize() { _tprintf( TEXT("Starting a non-persistent timer with max lifetime\n") );
_ulPeriod = g_ulDefaultPeriod; CTimerTest::Initialize( this, // PTimerCallback
NULL, // Timer name
4, // Timer context
_ulPeriod, // Period in seconds
CNewTimer::RETRY_WITH_BACKOFF, g_ulDefaultPeriod/2, // Min retry
g_ulDefaultPeriod * 2, // Max retry
// Max lifetime
g_ulDefaultPeriod + g_ulDefaultPeriod/2 + g_ulDefaultPeriod + 2*g_ulDefaultPeriod + g_ulDefaultPeriod/4 );
}
public:
void Set() { SetSingleShot(); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest4
class CTimerTest5 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1 };
public:
CTimerTest5() { _SubPhase = INITIAL; }
~CTimerTest5() { UnInitialize(); }
public:
void Initialize() { _tprintf( TEXT("Starting a generic timer (%ds)\n"), g_ulDefaultPeriod * 2 );
_ulPeriod = g_ulDefaultPeriod * 2; CTimerTest::Initialize( this, // PTimerCallback
NULL, // Timer name
5, // Timer context
_ulPeriod, // Period in seconds
CNewTimer::NO_RETRY, 0, 0, 0 ); // Min, max retry, max lifetime
}
public:
void Set() { SetSingleShot(); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest4
class CTimerTest6 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, FIRST_RECURRENCE = 2, FIRST_RETRY = 3, SECOND_RETRY = 4, THIRD_RETRY = 5, FOURTH_RETRY = 6, FINAL = 7 };
public:
CTimerTest6() { _cftLower = 0; _cftUpper = 0; _cftLastSet = 0; _SubPhase = INITIAL; }
~CTimerTest6() { UnInitialize(); }
public:
void Initialize() { _tprintf( TEXT("Continuing a persistent, recurring, random-retry (%d-%ds) timer (%ds)\n"), g_ulMinRetry, g_ulMaxRetry, g_ulDefaultPeriod );
_ulPeriod = g_ulDefaultPeriod;
CFILETIME cftDue; cftDue.IncrementSeconds( _ulPeriod ); SetTimerRegistryValue( TEXT("Timer6"), 0, cftDue, 0 ); TrkLog(( TRKDBG_ERROR, TEXT("Timer6 due at %x"), cftDue.LowDateTime() ));
CTimerTest::Initialize( this, TEXT("Timer6"), 6, _ulPeriod, CNewTimer::RETRY_RANDOMLY, g_ulMinRetry, g_ulMaxRetry, 0 ); // No max lifetime
}
public:
void Set() { CFILETIME cftExpected; cftExpected.IncrementSeconds( _ulPeriod ); TrkLog(( TRKDBG_ERROR, TEXT("Timer6 due at %x"), cftExpected.LowDateTime() )); SetRecurring( cftExpected ); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
CFILETIME _cftLower, _cftUpper, _cftLastSet; SUB_PHASE_ENUM _SubPhase;
};
class CTimerTest7 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, FINAL = 2, };
public:
CTimerTest7() { _SubPhase = INITIAL; }
~CTimerTest7() { UnInitialize(); }
public:
void Initialize() { _ulPeriod = g_ulDefaultPeriod; _tprintf( TEXT("Starting a retrying (%d-%ds) timer (%ds)\n"), _ulPeriod*2, _ulPeriod*4, _ulPeriod );
CTimerTest::Initialize( this, // PTimerCallback
NULL, // Timer name
7, // Timer context
_ulPeriod, // Period in seconds
CNewTimer::RETRY_WITH_BACKOFF, _ulPeriod*2, _ulPeriod*4, // Min/max retry
0 ); // No max lifetime
}
public:
void Set() { SetSingleShot(); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest7
class CTimerTest8 : public CTimerTest{
private:
enum SUB_PHASE_ENUM { INITIAL = 1, FIRST_RETRY = 2, FINAL = 3 };
public:
CTimerTest8() { _SubPhase = INITIAL; }
~CTimerTest8() { UnInitialize(); }
public:
void Initialize() { _ulPeriod = g_ulDefaultPeriod; _tprintf( TEXT("Continuing a retrying timer which was already in retry mode\n") );
CFILETIME cftDue, cftSet; cftSet.DecrementSeconds( _ulPeriod * 2 ); // A regular period, and have the first retry, have already passed
cftDue.IncrementSeconds( _ulPeriod ); SetTimerRegistryValue( TEXT("Timer8"), cftSet, cftDue, _ulPeriod*2 );
CTimerTest::Initialize( this, // PTimerCallback
TEXT("Timer8"), // Timer name
8, // Timer context
_ulPeriod, // Period in seconds
CNewTimer::RETRY_WITH_BACKOFF, _ulPeriod*2, _ulPeriod*4, // Min/max retry
// The original period, two retries (2/4) and a retry up to the max lifetime
_ulPeriod*(1+2+4+1) );
}
public:
void Set() { CFILETIME cftExpected; cftExpected.IncrementSeconds( _ulPeriod ); SetSingleShot( cftExpected ); }
private:
TimerContinuation Timer( ULONG ulTimerContext );
private:
SUB_PHASE_ENUM _SubPhase;
}; // class CTimerTest8
#endif // #ifndef _TTIMER_HXX_
|
