382 lines
9.5 KiB
C++
382 lines
9.5 KiB
C++
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
#include "dbgdll.hxx"
|
|
|
|
VOID
|
|
TracerTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DBG_OPEN( _T("DBG_TRACER"), DBG_DEFAULT, DBG_TRACE, DBG_NONE );
|
|
|
|
DBG_TRACER( _T("TestFunction Scope 1") );
|
|
{
|
|
DBG_TRACER( _T("TestFunction Scope 2") );
|
|
{
|
|
DBG_TRACER( _T("TestFunction Scope 3") );
|
|
{
|
|
DBG_TRACER( _T("TestFunction Scope 4") );
|
|
{
|
|
DBG_TRACER( _T("TestFunction Scope 5") );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DBG_CLOSE();
|
|
}
|
|
|
|
VOID
|
|
StatusTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DBG_OPEN( _T("DBG_STATUS"), DBG_DEFAULT, DBG_TRACE|DBG_WARN, DBG_NONE );
|
|
|
|
TStatus Status;
|
|
Status DBGCHK = ERROR_ACCESS_DENIED;
|
|
Status DBGCHK = ERROR_INVALID_PARAMETER;
|
|
|
|
TStatusB bStatus;
|
|
bStatus DBGCHK = TRUE;
|
|
|
|
SetLastError(ERROR_ACCESS_DENIED);
|
|
bStatus DBGCHK = FALSE;
|
|
|
|
TStatusH hStatus = S_OK;
|
|
hStatus DBGCHK = S_OK;
|
|
hStatus DBGCHK = E_NOTIMPL;
|
|
|
|
//
|
|
// Verify assert when reading an ininitalized variable.
|
|
//
|
|
#if DBG
|
|
TStatusH hr;
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
hr DBGCHK = E_FAIL;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Verify the safe values work.
|
|
//
|
|
TStatusB bStatus1;
|
|
DBGCFG1(bStatus1, DBG_TRACE, ERROR_ACCESS_DENIED);
|
|
SetLastError(ERROR_ACCESS_DENIED);
|
|
bStatus1 DBGCHK = FALSE;
|
|
SetLastError(ERROR_ARENA_TRASHED);
|
|
bStatus1 DBGCHK = FALSE;
|
|
|
|
TStatus Status1;
|
|
DBGCFG2(Status1, DBG_TRACE, ERROR_ACCESS_DENIED, ERROR_INVALID_HANDLE);
|
|
Status1 DBGCHK = ERROR_ACCESS_DENIED;
|
|
Status1 DBGCHK = ERROR_INVALID_HANDLE;
|
|
Status1 DBGCHK = ERROR_ARENA_TRASHED;
|
|
|
|
TStatusH hStatus1;
|
|
DBGCFG3(hStatus1, DBG_TRACE, E_FAIL, E_NOTIMPL, E_ABORT);
|
|
hStatus1 DBGCHK = E_FAIL;
|
|
hStatus1 DBGCHK = E_NOTIMPL;
|
|
hStatus1 DBGCHK = E_ABORT;
|
|
hStatus1 DBGCHK = HRESULT_FROM_WIN32(ERROR_ARENA_TRASHED);
|
|
|
|
DBG_CLOSE();
|
|
}
|
|
|
|
VOID
|
|
MessageTestHelper(
|
|
IN PTSTR sString,
|
|
IN TCHAR cValue,
|
|
IN SHORT sValue,
|
|
IN INT iValue,
|
|
IN LONG lValue
|
|
)
|
|
{
|
|
DBG_MSG(DBG_TRACE, (_T("Trace testing\n")));
|
|
DBG_MSG(DBG_TRACE, (_T("Trace sString = %s\n"), sString));
|
|
DBG_MSG(DBG_TRACE, (_T("Trace cValue = %c\n"), cValue));
|
|
DBG_MSG(DBG_TRACE, (_T("Trace sValue = %d\n"), sValue));
|
|
DBG_MSG(DBG_TRACE, (_T("Trace iValue = %d\n"), iValue));
|
|
DBG_MSG(DBG_TRACE, (_T("Trace lValue = %ld\n"), lValue));
|
|
|
|
DBG_MSG(DBG_WARN, (_T("Warning testing\n")));
|
|
DBG_MSG(DBG_WARN, (_T("Warning sString = %s\n"), sString));
|
|
DBG_MSG(DBG_WARN, (_T("Warning cValue = %c\n"), cValue));
|
|
DBG_MSG(DBG_WARN, (_T("Warning sValue = %d\n"), sValue));
|
|
DBG_MSG(DBG_WARN, (_T("Warning iValue = %d\n"), iValue));
|
|
DBG_MSG(DBG_WARN, (_T("Warning lValue = %ld\n"), lValue));
|
|
|
|
DBG_MSG(DBG_ERROR, (_T("Error testing\n")));
|
|
DBG_MSG(DBG_ERROR, (_T("Error sString = %s\n"), sString));
|
|
DBG_MSG(DBG_ERROR, (_T("Error cValue = %c\n"), cValue));
|
|
DBG_MSG(DBG_ERROR, (_T("Error sValue = %d\n"), sValue));
|
|
DBG_MSG(DBG_ERROR, (_T("Error iValue = %d\n"), iValue));
|
|
DBG_MSG(DBG_ERROR, (_T("Error lValue = %ld\n"), lValue));
|
|
|
|
DBG_MSG(DBG_FATAL, (_T("Fatal testing\n")));
|
|
DBG_MSG(DBG_FATAL, (_T("Fatal sString = %s\n"), sString));
|
|
DBG_MSG(DBG_FATAL, (_T("Fatal cValue = %c\n"), cValue));
|
|
DBG_MSG(DBG_FATAL, (_T("Fatal sValue = %d\n"), sValue));
|
|
DBG_MSG(DBG_FATAL, (_T("Fatal iValue = %d\n"), iValue));
|
|
DBG_MSG(DBG_FATAL, (_T("Fatal lValue = %ld\n"), lValue));
|
|
|
|
}
|
|
|
|
VOID
|
|
MessageTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
TCHAR cValue = _T('C');
|
|
PTSTR sString = _T("String");
|
|
SHORT sValue = 100;
|
|
INT iValue = 32000;
|
|
LONG lValue = 1000000;
|
|
UINT Trace = 0;
|
|
UINT Break = 0;
|
|
|
|
DWORD aLevels [] =
|
|
{
|
|
DBG_TRACE, DBG_NONE,
|
|
DBG_WARN, DBG_NONE,
|
|
DBG_ERROR, DBG_NONE,
|
|
DBG_FATAL, DBG_NONE,
|
|
};
|
|
|
|
for (UINT i = 0; i < sizeof(aLevels)/sizeof(*aLevels); i+=2)
|
|
{
|
|
DBG_OPEN(_T("DBG_MESSAGE"), DBG_DEFAULT, aLevels[i], aLevels[i+1]);
|
|
|
|
MessageTestHelper(sString, cValue, sValue, iValue, lValue);
|
|
|
|
DBG_DISABLE();
|
|
|
|
MessageTestHelper(sString, cValue, sValue, iValue, lValue);
|
|
|
|
DBG_ENABLE();
|
|
|
|
DBG_CLOSE();
|
|
}
|
|
}
|
|
|
|
VOID
|
|
BacktraceTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DBG_CAPTURE_HANDLE(Capture);
|
|
DBG_CAPTURE_OPEN(Capture, _T("symbols"), DBG_DEBUGGER, NULL);
|
|
DBG_CAPTURE(Capture, 0, (_T("Capture message %d.\n"), 0));
|
|
DBG_CAPTURE_CLOSE( Capture );
|
|
}
|
|
|
|
VOID
|
|
CaptureTest0(
|
|
IN DWORD dwThread
|
|
)
|
|
{
|
|
DBG_CAPTURE_HANDLE(Capture);
|
|
DBG_CAPTURE_OPEN(Capture, _T("nosymbols"), DBG_DEBUGGER, NULL);
|
|
DBG_CAPTURE(Capture, 0, (_T("Unicode %d Multi Thread Test.\n"), dwThread));
|
|
DBG_CAPTURE(Capture, 0, ("Ansi %d Multi Thread Test.\n", dwThread));
|
|
DBG_CAPTURE_CLOSE( Capture );
|
|
}
|
|
|
|
VOID
|
|
CaptureTest1(
|
|
IN DWORD dwThread
|
|
)
|
|
{
|
|
DBG_CAPTURE_HANDLE(Capture);
|
|
DBG_CAPTURE_OPEN(Capture, _T("nosymbols"), DBG_DEBUGGER, NULL);
|
|
DBG_CAPTURE(Capture, 0, (_T("Unicode %d Multi Thread Test.\n"), dwThread));
|
|
DBG_CAPTURE(Capture, 0, ("Ansi %d Multi Thread Test.\n", dwThread));
|
|
DBG_CAPTURE_CLOSE( Capture );
|
|
}
|
|
|
|
|
|
DWORD
|
|
MultiThreadProc0(
|
|
IN LPVOID lpThreadParameter
|
|
)
|
|
{
|
|
for ( UINT i = 10 ; i ; i-- )
|
|
{
|
|
DBG_OPEN(_T("DBG_MULTITHREAD 0"), DBG_DEFAULT, DBG_TRACE, DBG_NONE);
|
|
DBG_MSG(DBG_TRACE, ("TestFunction return value\n"));
|
|
DBG_CLOSE();
|
|
// CaptureTest0(0);
|
|
MessageTest(0, NULL);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
MultiThreadProc1(
|
|
IN LPVOID lpThreadParameter
|
|
)
|
|
{
|
|
for ( UINT i = 10 ; i ; i-- )
|
|
{
|
|
DBG_OPEN(_T("DBG_MULTITHREAD 1"), DBG_DEFAULT, DBG_TRACE, DBG_NONE);
|
|
DBG_MSG(DBG_TRACE, ("TestFunction return value\n"));
|
|
DBG_CLOSE();
|
|
// CaptureTest1(1);
|
|
MessageTest(0, NULL);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
ThreadTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DWORD dwThreadId = 0;
|
|
HANDLE ahThreads[2] = {0};
|
|
|
|
ahThreads[0] = CreateThread(NULL, 0, MultiThreadProc0, (PVOID)0, 0, &dwThreadId);
|
|
ahThreads[1] = CreateThread(NULL, 0, MultiThreadProc1, (PVOID)1, 0, &dwThreadId);
|
|
|
|
if (ahThreads[0] && ahThreads[1])
|
|
{
|
|
WaitForMultipleObjects(2, ahThreads, TRUE, INFINITE);
|
|
}
|
|
|
|
if (ahThreads[0])
|
|
{
|
|
CloseHandle(ahThreads[0]);
|
|
}
|
|
|
|
if (ahThreads[1])
|
|
{
|
|
CloseHandle(ahThreads[1]);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
DllTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DllFunction1(0xCAFECAFE);
|
|
}
|
|
|
|
VOID
|
|
TimestampTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DBG_OPEN(_T("DBG_TIME"), DBG_DEFAULT, DBG_TRACE|DBG_TIMESTAMP|DBG_THREADID, DBG_NONE);
|
|
|
|
DBG_MSG(DBG_TRACE, ("Test Message\n"));
|
|
|
|
DBG_CLOSE();
|
|
|
|
DBG_OPEN(_T("DBG_TIME"), DBG_DEFAULT, DBG_TRACE|DBG_TIMESTAMP|DBG_THREADID, DBG_NONE);
|
|
|
|
DBG_SET_FIELD_FORMAT(DBG_TIMESTAMP, _T(" Tick Count (%x)"));
|
|
|
|
DBG_SET_FIELD_FORMAT(DBG_THREADID, _T(" Thread Id = [%d]"));
|
|
|
|
DBG_MSG(DBG_TRACE, ("Test Message\n"));
|
|
|
|
DBG_CLOSE();
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
MemoryLeakTest(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
DBG_OPEN(_T("DBG_MEMORY"), DBG_DEFAULT, DBG_TRACE|DBG_WARN, DBG_NONE);
|
|
|
|
DBG_MSG(DBG_TRACE, ("Test memory leak detection\n"));
|
|
|
|
int *pInt = (int *)malloc(10);
|
|
WCHAR *pChar = new WCHAR[10];
|
|
|
|
DBG_CLOSE();
|
|
}
|
|
|
|
extern "C"
|
|
INT
|
|
_cdecl
|
|
_tmain(
|
|
IN INT ac,
|
|
IN TCHAR **av
|
|
)
|
|
{
|
|
ac--, av++;
|
|
|
|
LPCTSTR pszName = *av ? *av : _T("");
|
|
BOOL bTestExecuted = FALSE;
|
|
|
|
typedef VOID(*pfTest)(INT, TCHAR**);
|
|
|
|
struct Test
|
|
{
|
|
LPCTSTR pszName;
|
|
LPCTSTR pszDesc;
|
|
pfTest pFunction;
|
|
};
|
|
|
|
Test aTests [] =
|
|
{
|
|
{_T("Tracer"), _T("Tests trace messages"), TracerTest},
|
|
{_T("Status"), _T("Test TStatus[X] functionality"), StatusTest},
|
|
{_T("Message"), _T("Test message macros, trace and break levels"), MessageTest},
|
|
{_T("Backtrace"), _T("Test backtrace capture code"), BacktraceTest},
|
|
{_T("Thread"), _T("Test multi thread support"), ThreadTest},
|
|
{_T("Dll"), _T("Test dll functionality"), DllTest},
|
|
{_T("Time"), _T("Test time stamp functionality"), TimestampTest},
|
|
{_T("Memory"), _T("Test crt memory leak detections"), MemoryLeakTest},
|
|
{_T(""), _T(""), NULL},
|
|
};
|
|
|
|
for (Test *pTst = aTests; pTst->pFunction; pTst++)
|
|
{
|
|
if(!_tcsnicmp(pszName, pTst->pszName, _tcslen(pszName)))
|
|
{
|
|
DBG_INIT();
|
|
DBG_MEMORY_INIT();
|
|
|
|
pTst->pFunction(ac, av);
|
|
|
|
bTestExecuted = TRUE;
|
|
|
|
DBG_MEMORY_RELEASE();
|
|
DBG_RELEASE();
|
|
}
|
|
}
|
|
|
|
if (!bTestExecuted)
|
|
{
|
|
_tprintf(_T("Available Tests:\n"));
|
|
|
|
for (Test *p = aTests; p->pFunction; p++)
|
|
{
|
|
_tprintf(_T("\t%s%*s%s\n"), p->pszName, 12-_tcslen(p->pszName), _T(""), p->pszDesc);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|