static void RunTest(const TestInfo *theTest)
{
Boolean runTheTest;
runTheTest = true;
if ( gRunQuiet && gCheckLeaks ) {
fprintf(stderr, "LeakTest(%s)\n", theTest->testName);
} else if ( ! gRunQuiet ) {
fprintf(stderr, "%s\n", theTest->testName);
}
if ( theTest->needsRoot ) {
if (gNoRootTests) {
fprintf(stderr, "*** Did not run test because it requires root.\n");
runTheTest = false;
} else if ( geteuid() != 0 ) {
fprintf(stderr, "*** Did not run because the test requires root.\n");
runTheTest = false;
}
}
if (runTheTest) {
if ( gCheckLeaks ) {
LeakTest(theTest->tester);
} else {
theTest->tester();
}
}
if ( ! gRunQuiet ) {
fprintf(stderr, "\n");
}
}
int main(){
/** Unique pointers does not take additional memory. */
std::cout<<"sizeof(unique_ptr<int>):"<<(int)sizeof(std::unique_ptr<int>)<<std::endl;
std::cout<<"sizeof(int*):"<<(int)sizeof(int*)<<std::endl;
/** Test to prove that Infector does not cause memory leaks due to
* unkown evaluation order of constructors' parameters when construcors
* throws exceptions. This is a big advantage.*/
#ifndef INFECTOR_VS_DISABLE //disabled on visual studio due to a compiler bug
LeakTest();
/** Basic usage test, no shared objects. Creates a small object graph
* with unique ownership semantics.*/
BedTest();
/** This test assure that exception is thrown in case there's a circular
* dependency. */
CircularTest();
#endif
/** Basic usage test this time shared objects are used and multiple
* inheritance is tested.*/
SharedTest();
/** Multiple inheritance test failure.*/
MultiBaseFailure();
#ifndef INFECTOR_VS_DISABLE //disabled on visual studio due to a compiler bug
/** Can instantiate only bound types. Verify that.*/
InstantiateConcreteMustFail();
#endif
/**Same as Leak test1, but use shared_ptr instead of unique_ptr*/
LeakTest2();
/**Same as BedTest, but use shared_ptr instead of unique_ptr*/
BedTest2();
/**Same as Circular test, but use shared_ptr instead of unique_ptr*/
CircularTest2();
return 0;
}
