windows-nt/Source/XPSP1/NT/base/cluster/admin/cluadmin/barf.h
2020-09-26 16:20:57 +08:00

242 lines
6.5 KiB
C++

/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1996-1997 Microsoft Corporation
//
// Module Name:
// Barf.h
//
// Abstract:
// Definition of the Basic Artifical Resource Failure classes.
// BARF allows API call failures to be simulated automatically to
// ensure full code test coverage.
//
// Implementation File:
// Barf.cpp
//
// Author:
// David Potter (davidp) April 11, 1997
//
// Revision History:
//
// Notes:
// This file compiles only in _DEBUG mode.
//
// To implement a new BARF type, declare a global instance of CBarf:
// CBarf g_barfMyApi(_T("My API"));
//
// To bring up the BARF dialog:
// DoBarfDialog();
// This brings up a modeless dialog with the BARF settings.
//
// A few functions are provided for special circumstances.
// Usage of these should be fairly limited:
// BarfAll(void); Top Secret -> NYI.
// EnableBarf(BOOL); Allows you to disable/reenable BARF.
// FailOnNextBarf; Force the next failable call to fail.
//
// NOTE: Your code calls the standard APIs (e.g. LoadIcon) and the
// BARF files do the rest.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef _BARF_H_
#define _BARF_H_
// Only process the rest of this file if BARF is to be implemented in the
// including module.
//#ifndef _NO_BARF_DEFINITIONS_
//#define _USING_BARF_
/////////////////////////////////////////////////////////////////////////////
// Forward Class Declarations
/////////////////////////////////////////////////////////////////////////////
class CBarf;
class CBarfSuspend;
/////////////////////////////////////////////////////////////////////////////
// External Class Declarations
/////////////////////////////////////////////////////////////////////////////
class CTraceTag;
/////////////////////////////////////////////////////////////////////////////
// Type Definitions
/////////////////////////////////////////////////////////////////////////////
#define BARF_REG_SECTION _T("Debug\\BARF")
#define BARF_REG_SECTION_FMT BARF_REG_SECTION _T("\\%s")
/////////////////////////////////////////////////////////////////////////////
// Include Files
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// CBarf
//
// Purpose:
// Basic Artificial Resource Failure class. Contains the BARF
// information for a class of calls
//
// The constructor initializes a bunch of parameters. CBarfDialog
// (a friend class) adjusts the various flags. The only public API
// is FFail(). This method determines if the next call should generate
// an artificial failure or not.
//
/////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
typedef void (*PFNBARFPOSTUPDATE)(void);
class CBarf : public CObject
{
friend class CBarfSuspend;
friend class CBarfDialog;
friend void InitBarf(void);
friend void CleanupBarf(void);
friend void EnableBarf(BOOL);
friend void BarfAll(void);
friend void DoBarfDialog(void);
public:
CBarf(IN LPCTSTR pszName);
protected:
void Init(void);
// Attributes
protected:
LPCTSTR m_pszName;
BOOL m_bDisabled;
BOOL m_bContinuous;
DWORD m_nFail;
DWORD m_nCurrent;
DWORD m_nCurrentSave;
DWORD m_nBarfAll;
public:
LPCTSTR PszName(void) const { return m_pszName; }
BOOL BDisabled(void) const { return m_bDisabled; }
BOOL BContinuous(void) const { return m_bContinuous; }
DWORD NFail(void) const { return m_nFail; }
DWORD NCurrent(void) const { return m_nCurrent; }
DWORD NCurrentSave(void) const { return m_nCurrentSave; }
DWORD NBarfAll(void) const { return m_nBarfAll; }
// Operations
public:
BOOL BFail(void);
// Implementation
public:
static PVOID PvSpecialMem(void) { return s_pvSpecialMem; }
protected:
static CBarf * s_pbarfFirst;
CBarf * m_pbarfNext;
static LONG s_nSuspend;
static BOOL s_bGlobalEnable;
// Routine for use by the BARF dialog so that it can be
// automatically updated with results of the BARF run.
static PFNBARFPOSTUPDATE s_pfnPostUpdate;
static void SetPostUpdateFn(IN PFNBARFPOSTUPDATE pfn) { ASSERT(pfn != NULL); s_pfnPostUpdate = pfn; }
static void ClearPostUpdateFn(void) { ASSERT(s_pfnPostUpdate != NULL); s_pfnPostUpdate = NULL; }
static PFNBARFPOSTUPDATE PfnPostUpdate(void) { return s_pfnPostUpdate; }
// Pointer for use by the memory subsystem so that the BARF
// dialog can be ignored.
static PVOID s_pvSpecialMem;
static void SetSpecialMem(IN PVOID pv) { ASSERT(pv != NULL); s_pvSpecialMem = pv; }
}; //*** class CBarf
#endif // _DEBUG
/////////////////////////////////////////////////////////////////////////////
//
// class CBarfSuspend
//
// Purpose:
// Temporarily suspends BARF counters. This is especially useful
// from within BARF code.
//
// Usage:
// Create an object on the stack. Counting will be
// suspended while the object exist.
//
// For example:
//
// void Foo(void)
// {
// DoFuncA(); // BARF counters are enabled
//
// {
// CBarfSuspend bs;
//
// DoFuncB(); // BARF counters are suspended
// }
//
// DoFuncC(); // BARF counters are enabled again
// }
//
// NOTE: This is mostly for use within the DEBUG subsystem
// to avoid testing the DEBUG code against BARF.
//
/////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
class CBarfSuspend
{
private:
static CRITICAL_SECTION s_critsec;
static BOOL s_bCritSecValid;
protected:
static PCRITICAL_SECTION Pcritsec(void) { return &s_critsec; }
static BOOL BCritSecValid(void) { return s_bCritSecValid; }
public:
CBarfSuspend(void);
~CBarfSuspend(void);
// for initialization only.
static void Init(void);
static void Cleanup(void);
}; //*** class CBarfSuspend
#endif // _DEBUG
/////////////////////////////////////////////////////////////////////////////
// Global Functions and Data
/////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
extern BOOL g_bFailOnNextBarf;
void EnableBarf(IN BOOL bEnable);
inline void FailOnNextBarf(void) { g_bFailOnNextBarf = TRUE; }
void InitBarf(void);
void CleanupBarf(void);
extern CTraceTag g_tagBarf;
#else
inline void EnableBarf(IN BOOL bEnable) { }
inline void FailOnNextBarf(void) { }
inline void InitBarf(void) { }
inline void CleanupBarf(void) { }
#endif // _DEBUG
/////////////////////////////////////////////////////////////////////////////
//#endif // _NO_BARF_DEFINITIONS_
#endif // _BARF_H_