colin
/
tripwire-open-source
mirror of https://github.com/Tripwire/tripwire-open-source.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix/implement more unit tests that were marked as 'skipped'

This commit is contained in:
Brian Cox 2017-09-24 18:44:47 -07:00
parent 1333f3c15e
commit 9872bef2f2
9 changed files with 156 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
src/core/tasktimer.h
View File

@ -46,95 +46,20 @@
#endif #endif
#include <string> #include <string>
#include <ctime>
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// cTaskTimer -- // cTaskTimer --
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
template<class TIME_FN, class TIME_TYPE>
class cTaskTimer class cTaskTimer
{ {
public: public:
cTaskTimer(const TSTRING& name) : mName(name), mTotalTime(0), mStartTime(0), mNumStarts(0) {} cTaskTimer(const TSTRING& name) : mName(name), mTotalTime(0), mStartTime(0), mNumStarts(0) {}
~cTaskTimer();
void Start(); inline ~cTaskTimer()
void Stop();
bool IsRunning() { return (mStartTime != 0); }
void Reset() { mNumStarts = mStartTime = mTotalTime = 0 }
int32 GetTotalTime() const;
int32 GetNumTimesStarted() const; // returns the number of times start() was called
const std::string& GetName() const;
private:
TSTRING mName;
int32 mTotalTime;
TIME_TYPE mStartTime;
int32 mNumStarts;
};
///////////////////////////////////////////////////////////////////////////////
// cUnixTimeFn -- Unix version, inserts proper function call and overloads
// operator()
///////////////////////////////////////////////////////////////////////////////
#include <ctime>
class cUnixTimeFn
{
public:
typedef uint32 DataType;
uint32 operator()()
{
return time( &dummy_var );
}
private:
time_t dummy_var;
};
///////////////////////////////////////////////////////////////////////////////
// cUnixTaskTimer -- the Unix typedef...
///////////////////////////////////////////////////////////////////////////////
typedef cTaskTimer<cUnixTimeFn, cUnixTimeFn::DataType> cUnixTaskTimer;
typedef cUnixTaskTimer cGenericTaskTimer;
//-----------------------------------------------------------------------------
// inline implementation
//-----------------------------------------------------------------------------
template<class TIME_FN, class TIME_TYPE>
inline void cTaskTimer<TIME_FN, TIME_TYPE>::Start()
{
ASSERT(! IsRunning());
TIME_FN GetTime;
mStartTime = GetTime();
mNumStarts++;
}
template<class TIME_FN, class TIME_TYPE>
inline void cTaskTimer<TIME_FN, TIME_TYPE>::Stop()
{
ASSERT(IsRunning());
TIME_FN GetTime;
mTotalTime += ( GetTime() - mStartTime );
mStartTime = 0;
}
template<class TIME_FN, class TIME_TYPE>
inline int32 cTaskTimer<TIME_FN, TIME_TYPE>::GetTotalTime() const
{
return mTotalTime;
}
template<class TIME_FN, class TIME_TYPE>
inline const std::string& cTaskTimer<TIME_FN, TIME_TYPE>::GetName() const
{
return mName
}
template<class TIME_FN, class TIME_TYPE>
inline cTaskTimer<TIME_FN, TIME_TYPE>::~cTaskTimer()
{ {
// stop the timer if it is currently running // stop the timer if it is currently running
if(IsRunning()) if(IsRunning())
@ -145,6 +70,36 @@ inline cTaskTimer<TIME_FN, TIME_TYPE>::~cTaskTimer()
d.TraceDebug("----- Time to execute %s: %d (started %d times)\n", mName.c_str(), mTotalTime, mNumStarts); d.TraceDebug("----- Time to execute %s: %d (started %d times)\n", mName.c_str(), mTotalTime, mNumStarts);
} }
inline void Start()
{
ASSERT(! IsRunning());
time_t dummy;
mStartTime = time(&dummy);
mNumStarts++;
}
void Stop()
{
ASSERT(IsRunning());
time_t dummy;
mTotalTime += ( time(&dummy) - mStartTime );
mStartTime = 0;
}
bool IsRunning() { return (mStartTime != 0); }
void Reset() { mNumStarts = mStartTime = mTotalTime = 0; }
uint32 GetTotalTime() const { return mTotalTime; }
uint32 GetNumTimesStarted() const { return mNumStarts; }
const std::string& GetName() const { return mName; }
private:
TSTRING mName;
uint32 mTotalTime;
uint32 mStartTime;
uint32 mNumStarts;
};
#endif #endif

4
src/tripwire/twcmdline.cpp
View File

@ -751,7 +751,7 @@ int cTWModeDbInit::Execute(cErrorQueue* pQueue)
cTWCmdLineUtil::ParsePolicyFile(genreSpecList, mpData->mPolFile, mpData->mSiteKeyFile, pQueue); cTWCmdLineUtil::ParsePolicyFile(genreSpecList, mpData->mPolFile, mpData->mSiteKeyFile, pQueue);
#ifdef TW_PROFILE #ifdef TW_PROFILE
cWin32TaskTimer timer("cTripwire::GenerateDatabase"); cTaskTimer timer("cTripwire::GenerateDatabase");
timer.Start(); timer.Start();
#endif #endif
@ -1375,7 +1375,7 @@ int cTWModeIC::Execute(cErrorQueue* pQueue)
iUserNotify::GetInstance()->Notify(1, TSS_GetString( cTripwire, tripwire::STR_INTEGRITY_CHECK).c_str()); iUserNotify::GetInstance()->Notify(1, TSS_GetString( cTripwire, tripwire::STR_INTEGRITY_CHECK).c_str());
#ifdef TW_PROFILE #ifdef TW_PROFILE
cWin32TaskTimer timer("cTripwire::IntegrityCheck"); cTaskTimer timer("cTripwire::IntegrityCheck");
timer.Start(); timer.Start();
#endif #endif
cIntegrityCheck ic( (cGenre::Genre)dbIter.GetGenre(), specList, dbIter.GetDb(), report, pQueue ); cIntegrityCheck ic( (cGenre::Genre)dbIter.GetGenre(), specList, dbIter.GetDb(), report, pQueue );

4
src/tw/twutil.cpp
View File

@ -345,7 +345,7 @@ void cTWUtil::WriteDatabase(const TCHAR* filename, cFCODatabaseFile& db, bool bE
//fileHeader.SetVersion(1); //fileHeader.SetVersion(1);
#ifdef TW_PROFILE #ifdef TW_PROFILE
cWin32TaskTimer timer(_T("Write Database")); cTaskTimer timer(_T("Write Database"));
timer.Start(); timer.Start();
#endif #endif
@ -370,7 +370,7 @@ void cTWUtil::ReadDatabase(const TCHAR* filename, cFCODatabaseFile& db, const cE
cDisplayEncoder::EncodeInline( filename ).c_str() ); cDisplayEncoder::EncodeInline( filename ).c_str() );
#ifdef TW_PROFILE #ifdef TW_PROFILE
cWin32TaskTimer timer("cTWUtil::ReadDatabase"); cTaskTimer timer("cTWUtil::ReadDatabase");
timer.Start(); timer.Start();
#endif #endif

21
src/twtest/charutil_t.cpp
View File

@ -43,7 +43,7 @@
#include "twtest/test.h" #include "twtest/test.h"
void PrintChars( const TSTRING& str ) void CheckChars( const TSTRING& str, int length_expected = 1)
{ {
TSTRING::const_iterator cur = str.begin(); TSTRING::const_iterator cur = str.begin();
TSTRING::const_iterator end = str.end(); TSTRING::const_iterator end = str.end();
@ -51,19 +51,9 @@ void PrintChars( const TSTRING& str )
while( cCharUtil::PopNextChar( cur, end, first, last ) ) while( cCharUtil::PopNextChar( cur, end, first, last ) )
{ {
TCOUT << _T("char length: ") << (int)(last - first) << std::endl; int length = (int)(last - first);
TEST(length == length_expected);
TCOUT << _T("char: <");
for( TSTRING::const_iterator at = first; at != last; at++ )
{
if( at != first )
TCOUT << _T(",");
TCOUT << (int)*at;
} }
TCOUT << _T(">") << std::endl;
}
TCOUT << _T("----------------------------") << std::endl;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
@ -71,8 +61,9 @@ void PrintChars( const TSTRING& str )
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
void TestCharUtilBasic() void TestCharUtilBasic()
{ {
PrintChars( _T("foo") ); CheckChars( "foo" );
PrintChars( _T("fo\x23 54") ); CheckChars( "fo\x23 54" );
CheckChars( "\U0001F408", 4 ); //Cat emoji. Assumes UTF-8
} }
void RegisterSuite_CharUtil() void RegisterSuite_CharUtil()

109
src/twtest/fsdatasourceiter_t.cpp
View File

@ -36,84 +36,89 @@
#include "core/debug.h" #include "core/debug.h"
#include "twtest/test.h" #include "twtest/test.h"
#include "fco/fco.h" #include "fco/fco.h"
#include "fco/twfactory.h"
#include "core/errorbucketimpl.h"
/* namespace
static void PrintDb( cHierDatabase::iterator iter, cDebug d, bool bFirst = true )
{ {
if( ! bFirst ) int num_processed = 0;
{
iter.Descend();
}
d.TraceDebug( "-- Processing directory %s\n", iter.GetCwd().c_str() );
for( iter.SeekBegin(); ! iter.Done(); iter.Next() ) void util_ProcessDir( iFCODataSourceIter* pIter )
{ {
d.TraceDebug( "Processing entry %s\n", iter.GetName().c_str() ); TEST( ! pIter->Done() );
if( iter.CanDescend() ) TEST( pIter->CanDescend() );
{ if( ! pIter->CanDescend() )
d.TraceDebug( ">>Descending...\n" );
PrintDb(iter, d, false);
}
}
d.TraceDebug( "-- Done Processing directory %s\n", iter.GetCwd().c_str() );
}
*/
static void PrintIter( cFSDataSourceIter iter, cDebug& d )
{
int count = 0;
if( ! iter.CanDescend() )
{
d.TraceError( "Iterator cannot descend; returning!\n");
TEST(!"Unexpected !CanDescend at beginning of test");
return; return;
}
iter.Descend();
iter.TraceContents();
for( iter.SeekBegin(); ! iter.Done(); iter.Next() ) pIter->Descend();
for( pIter->SeekBegin(); ! pIter->Done(); pIter->Next() )
{ {
count++; iFCO* pFCO = pIter->CreateFCO();
iFCO* pFCO = iter.CreateFCO();
if( pFCO ) if( pFCO )
{ {
pFCO->TraceContents(); num_processed++;
pFCO->Release(); pFCO->Release();
if( pIter->CanDescend() )
{
TW_UNIQUE_PTR<iFCODataSourceIter> pCopy( pIter->CreateCopy() );
util_ProcessDir( pCopy.get() );
}
} }
else else
{ {
d.TraceError( "*** Create of FCO failed!\n"); fail("CreateFCO failure");
fail("CreateFCO() failure");
} }
if( iter.CanDescend() ) }
}
void util_ProcessDir( const cFCOName& name )
{ {
d.TraceDebug( ">>Descending...\n" ); //Create a cFSDataSourceIter the same way we do in DB gen / IC
PrintIter(iter, d); TW_UNIQUE_PTR<iFCODataSourceIter> pDSIter(iTWFactory::GetInstance()->CreateDataSourceIter());
cErrorQueue errorQueue;
pDSIter->SetErrorBucket(&errorQueue);
pDSIter->SeekToFCO ( name, false ); // false means don't generate my peers...
if( ! pDSIter->Done() )
{
iFCO* pFCO = pDSIter->CreateFCO();
if( pFCO )
{
num_processed++;
pFCO->Release();
if( pDSIter->CanDescend() )
{
TW_UNIQUE_PTR<iFCODataSourceIter> pCopy( pDSIter->CreateCopy() );
util_ProcessDir( pCopy.get() );
}
}
else
{
fail("CreateFCO failure");
} }
} }
TEST(count > 0); TEST( 0 == errorQueue.GetNumErrors());
TEST( 0 < num_processed );
} }
} // namespace
//////////////////////////////////////
void TestFSDataSourceIter() void TestFSDataSourceIter()
{ {
skip("Fix this test");
cFSDataSourceIter iter;
cDebug d("TestFSDataSourceIter"); cDebug d("TestFSDataSourceIter");
cFCOName base(TwTestDir()); cFCOName base(TwTestDir());
util_ProcessDir(base);
// go to my temp directory and iterate over everything!
iter.SeekToFCO( cFCOName(TwTestDir()) );
//
// print out everything below the iterator
//
PrintIter( iter, d );
} }
void RegisterSuite_FSDataSourceIter() void RegisterSuite_FSDataSourceIter()

25
src/twtest/fsobject_t.cpp
View File

@ -32,13 +32,34 @@
// fsobject_t -- the file system object test driver // fsobject_t -- the file system object test driver
#include "fs/stdfs.h" #include "fs/stdfs.h"
#include "fs/fsobject.h" #include "fs/fsobject.h"
#include "fs/fspropcalc.h"
#include "test.h" #include "test.h"
#include <fstream>
void TestFSObject() void TestFSObject()
{ {
cDebug d("TestFSObject"); cDebug d("TestFSObject");
d.TraceError("Implement this!\n");
skip("TestFSObject not implemented"); cFCOName path( TwTestPath("fsobject") );
std::ofstream fstr(path.AsString().c_str());
if(fstr.bad())
{
d.TraceError("Unable to create test file %s!\n", path.AsString().c_str());
TEST(false);
}
fstr.close();
cFSObject obj(path);
cFSPropCalc propCalc;
cFCOPropVector v(obj.GetPropSet()->GetValidVector().GetSize());
for( int x=0; x < cFSPropSet::PROP_NUMITEMS; x++)
v.AddItem(x);
propCalc.SetPropVector(v);
obj.AcceptVisitor(&propCalc);
TEST(obj.GetPropSet()->GetNumProps() == cFSPropSet::PROP_NUMITEMS);
} }
void RegisterSuite_FSObject() void RegisterSuite_FSObject()

10
src/twtest/refcountobj_t.cpp
View File

@ -158,9 +158,13 @@ void TestRefCountObj()
} }
} }
//These fields only exist in debug builds, so we can't use TEST() here. #ifdef DEBUG
ASSERT(cRefCountObj::objectCounter == 0); //These fields only exist in debug builds
ASSERT(cRefCountObj::referenceCounter == 0); TEST(cRefCountObj::objectCounter == 0);
TEST(cRefCountObj::referenceCounter == 0);
#else
TEST("This test can only make useful assertions in debug builds");
#endif
db.TraceAlways("Done...\n"); db.TraceAlways("Done...\n");

23
src/twtest/tasktimer_t.cpp
View File

@ -32,12 +32,29 @@
// tasktimer_t -- test driver for cTaskTimer // tasktimer_t -- test driver for cTaskTimer
#include "core/stdcore.h" #include "core/stdcore.h"
#include "test.h" #include "test.h"
#include "core/tasktimer.h"
#include <unistd.h>
void TestTaskTimer() void TestTaskTimer()
{ {
cDebug d("TestTaskTimer"); cTaskTimer timer("unit testing");
d.TraceError("Implement this!\n");
skip("TestTaskTimer unimplemented"); TEST(!timer.IsRunning());
TEST(0 == timer.GetTotalTime());
TEST(0 == timer.GetNumTimesStarted());
for( int counter=0; counter<5; counter++)
{
timer.Start();
TEST(timer.IsRunning());
sleep(1);
timer.Stop();
TEST(!timer.IsRunning());
}
TEST(!timer.IsRunning());
TEST(5 >= timer.GetTotalTime());
TEST(5 == timer.GetNumTimesStarted());
} }
void RegisterSuite_TaskTimer() void RegisterSuite_TaskTimer()

134
src/twtest/twlocale_t.cpp
View File

@ -55,38 +55,6 @@ void TestHex();
TEST( false ); \ TEST( false ); \
} catch( error& ) {} } catch( error& ) {}
/* We don't do atoi stuff in cTWLocale anymore
void TestAtoi()
{
//
// setup
//
int32 n;
TSTRING str = _T("123456");
//
// Try formatting with our default locale
//
TWLocale::InitGlobalLocale();
n = cTWLocale::FormatNumberClassic( str );
TEST( n == 123456 );
//
// Try formatting with "" locale
//
std::locale::global( std::locale("") );
n = cTWLocale::FormatNumberClassic( str );
TEST( n == 123456 );
//
// Try formatting with "C" locale
//
std::locale::global( std::locale("") );
n = cTWLocale::FormatNumberClassic( str );
TEST( n == 123456 );
}
*/
void TestItoa() void TestItoa()
{ {
try try
@ -129,110 +97,8 @@ void TestItoa()
} }
} }
/* We don't do atoi stuff in cTWLocale anymore, so no roundtrip
void TestRoundtrip()
{
//
// init
//
cTWLocale::InitGlobalLocale();
//
// atoitoa
//
TSTRING strIn = _T("123456");
TSTRING strOut;
strOut = cTWLocale::FormatNumber( cTWLocale::FormatNumberClassic( strIn ), strOut );
// don't know if string will be the same due to possible changes in formatting from locale
// ASSERT( strOut == strIn ); <---- can't do this ^^^
TEST( 123456 == cTWLocale::FormatNumberClassic( strOut ) );
//
// itoatoi
//
int32 nIn = 654321;
int32 nOut;
nOut = cTWLocale::FormatNumberClassic( cTWLocale::FormatNumber( nIn, strIn ) );
TEST( nOut == nIn );
}
*/
void TestFlags()
{
skip("Modernize & re-enable this");
#if 0
//
// init
//
cTWLocale::InitGlobalLocale();
//
// hex
//
TSTRING str = _T("FF");
int n = cTWLocale::FormatNumber( str, std::ios_base::hex );
TEST( n == 0xFF );
//
// bad number for dec
//
ASSERT_THAT_IT_THROWS( cTWLocale::FormatNumberAsHex( str ), eError );
//
// oct
//
TSTRING strOct = _T("0712");
n = cTWLocale::FormatNumber( strOct, std::ios_base::oct );
TEST( n == 0712 );
//
// oct again
//
strOct = _T("00712");
n = cTWLocale::FormatNumber( strOct, std::ios_base::oct );
TEST( n == 0712 );
//
// oct again again
//
strOct = _T("712");
n = cTWLocale::FormatNumber( strOct, std::ios_base::oct );
TEST( n == 0712 );
//
// try bad oct
//
ASSERT_THAT_IT_THROWS( cTWLocale::FormatNumber( _T("99"), std::ios_base::oct ), eError );
#endif
}
/*
void doTestHex(const uint32 value, const std::string& expected, const std::string& expected2 = "")
{
TSTRING str = cTWLocale::FormatNumberAsHex( value );
TCERR << "STR = " << str << " | Expected = " << expected << " | Expected2 = " << expected2 << std::endl;
TEST( str == expected || (!expected2.empty() && str == expected2) );
}
void TestHex()
{
TSTRING str;
doTestHex( 0x1234, _T("1234") );
doTestHex( 16, _T("10") );
doTestHex( 0x12344321, _T("12344321") );
doTestHex( 0xFFFFFFFF, _T("FFFFFFFF"), _T("ffffffff"));
}
*/
void RegisterSuite_TWLocale() void RegisterSuite_TWLocale()
{ {
// RegisterTest("TWLocale", "Hex", TestHex);
// RegisterTest("TWLocale", "Atoi", TestAtoi);
RegisterTest("TWLocale", "Itoa", TestItoa); RegisterTest("TWLocale", "Itoa", TestItoa);
RegisterTest("TWLocale", "Flags", TestFlags);
// RegisterTest("TWLocale", "Roundtrip", TestRoundtrip);
} }