// test_class_SSArray_ctor_dctor_count
// Test suite for class template SSArray, number of class to item type
// ctor, dctor.
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate messages have been printed to cout.
// Does not throw (No-Throw Guarantee)
void test_class_SSArray_ctor_dctor_count(Tester & t)
{
std::cout << "Test Suite: class template SSArray - ctor, dctor count"
<< std::endl;
// Check number of value type ctor/dctor calls
// on array creation & destruction
Counter::reset();
{ // Block, so we get dctor calls before function ends
const SSArray<Counter> tacc(10);
t.test(Counter::getCtorCount() == 10,
"Counting default ctor calls due to array creation");
Counter::reset();
}
t.test(Counter::getDctorCount() == 10,
"Counting dctor calls due to destruction");
/*
// Check correct number of value type ctor & dctor calls
// on self-assignment
SSArray<Counter> tacc2(10);
Counter::reset();
tacc2 = tacc2;
int i1 = Counter::getCtorCount() + Counter::getDctorCount();
t.test(i1 == 0 || i1 == 20, "Self-assignment ctor/dctor calls");
*/
}
// test_class_SSArray_bracket_op
// Test suite for class Product, bracket operator
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate have been messages printed to cout.
void test_class_SSArray_bracket_op(Tester & t)
{
std::cout << "Test Suite: class Product, bracket operator" << std::endl;
const int theSize = 10;
bool noErrors; // True if no errors encountered
int i; // Counter
SSArray<int> ssai(theSize);
for (i = 0; i < theSize; ++i)
ssai[i] = 15 - i * i;
noErrors = true;
for (i = 0; i < theSize; ++i)
{
if (ssai[i] != 15 - i * i)
noErrors = false;
}
t.test(noErrors, "Bracket operator (non-const)");
// Make const version, no copy
const SSArray<int> & ssaiRef = ssai;
noErrors = true;
for (i = 0; i < theSize; ++i)
{
if (ssaiRef[i] != 15 - i * i)
noErrors = false;
}
t.test(noErrors, "Bracket operator (const)");
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("RMCast_Retransmission_Test"));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("This is ACE Version %u.%u.%u\n\n"),
ACE::major_version(),
ACE::minor_version(),
ACE::beta_version()));
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Running single threaded test\n")));
//! Run the test in single threaded mode
Tester tester;
tester.run (100);
tester.validate_message_count ();
}
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Running multi threaded test\n")));
//! Run the test in multi-threaded mode
Tester tester;
Task task (&tester);
if (task.activate (THR_NEW_LWP|THR_JOINABLE, 4) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Cannot activate the threads\n")),
1);
ACE_Thread_Manager::instance ()->wait ();
tester.validate_message_count ();
}
ACE_END_TEST;
return 0;
}
// test_class_SSArray_copy_assn
// Test suite for class SSArray, copy assignment
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate have been messages printed to cout.
void test_class_SSArray_copy_assn(Tester & t)
{
std::cout << "Test Suite: class SSArray - copy assignment" << std::endl;
const int theSize = 10;
bool noErrors; // True if no errors encountered
int i; // Counter
SSArray<int> ssai(theSize);
for (i = 0; i < theSize; ++i)
ssai[i] = 15 - i * i;
// Make const version, no copy
const SSArray<int> & ssaiRef = ssai;
// Make copy (copy assignment)
SSArray<int> ssaiCopy(1);
ssaiCopy = ssaiRef;
t.test(ssaiCopy.size() == theSize, "Copy assignment - check size");
noErrors = true;
for (i = 0; i < theSize; ++i)
{
if (ssaiCopy[i] != 15 - i * i)
noErrors = false;
}
t.test(noErrors, "Copy assignment - check values");
}
// test_class_KSArray_types
// Test suite for class KSArray, types
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate messages have been printed to cout.
// Does not throw (No-Throw Guarantee)
void test_class_KSArray_types(Tester & t)
{
std::cout << "Test Suite: class KSArray - types" << std::endl;
bool correctType; // result of type checking
// value_type test #1: int
KSArray<int>::value_type i1 = 0;
correctType = TypeCheck<int>::check(i1);
t.test(correctType, "value_type test #1");
// value_type test #2: double
KSArray<double>::value_type d1 = 0.;
correctType = TypeCheck<double>::check(d1);
t.test(correctType, "value_type test #2");
// value_type check modifiability (only needs to compile)
KSArray<double>::value_type d2;
d2 = 0.;
t.test(true, "value_type check modifiability");
// size_type test
KSArray<Counter>::size_type s1 = 0;
correctType = TypeCheck<std::size_t>::check(s1)
|| TypeCheck<std::ptrdiff_t>::check(s1);
t.test(correctType, "size_type test");
// size_type check modifiability (only needs to compile)
KSArray<Counter>::size_type s2;
s2 = 0;
t.test(true, "size_type check modifiability");
}
int main(int argc, char* argv[])
{
// default configuration filename
std::string configFilename = "test01.edl";
// parse arguments
for (int i = 1; i < argc; i++) {
if ( std::string(argv[i]) == "-f" ) {
configFilename = argv[++i];
}
}
// build tester
Tester* tester = builder(configFilename);
// create the thread
TimerThread* thread = createTheThread(tester);
if (thread != nullptr) {
// run the test
run(tester);
tester->event(oe::base::Component::SHUTDOWN_EVENT);
tester->unref();
tester = nullptr;
// stop the thread
thread->terminate();
thread->unref();
thread = nullptr;
}
return 0;
}
// test_class_SSArray_ctor_from_size_and_val
// Test suite for class template SSArray, ctor from size & value
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate have been messages printed to cout.
// Does not throw (No-Throw Guarantee)
void test_class_SSArray_ctor_from_size_and_val(Tester & t)
{
std::cout << "Test Suite: class template SSArray - "
<< "ctor from size & value"
<< std::endl;
const int theSize = 1000;
bool noErrors; // True if no errors encountered
const double val = -3.2;
SSArray<double> tad(theSize, val);
// check size
t.test(tad.size() == theSize, "Ctor from size & value - check size");
// check values
typedef SSArray<double>::size_type ST;
noErrors = true;
for (auto i = static_cast<ST>(0);
i < tad.size();
++i)
{
if (tad[i] != val)
noErrors = false;
}
t.test(noErrors, "Ctor from size & value - check values");
}
int main(){
Tester test;
test.otworzPlik();
test.symulacja();
test.zamknijPlik();
return 0;
}
void TestPage::doubleClick (QListBoxItem *item)
{
if (! item)
return;
Tester *dialog = new Tester(item->text(), chartIndex);
dialog->show();
}
// test_class_SSArray_equality_comparisons
// Test suite for class template SSArray, comparisons ==, !=
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate messages have been printed to cout.
// Does not throw (No-Throw Guarantee)
void test_class_SSArray_equality_comparisons(Tester & t)
{
std::cout << "Test Suite: class template SSArray - "
<< "equality comparisons"
<< std::endl;
bool correctType; // result of type checking
const int theSize = 10;
int i; // Counter
SSArray<int> tai1(theSize);
for (i = 0; i < theSize; ++i)
tai1[i] = 15 - i * i;
const SSArray<int> & tai1Ref = tai1;
SSArray<int> tai1Copy(tai1Ref);
SSArray<int> tai2(theSize-1);
for (i = 0; i < theSize-1; ++i)
tai2[i] = 15 - i * i;
const SSArray<int> & tai2Ref = tai2;
// operator== return type
correctType = TypeCheck<bool>::check(tai1 == tai1Copy);
t.test(correctType, "operator==, return type");
// operator!= return type
correctType = TypeCheck<bool>::check(tai1 != tai1Copy);
t.test(correctType, "operator!=, return type");
// Check equality of copies
t.test(tai1 == tai1Copy, "Equality of copies");
// Check inequality of copies
t.test(!(tai1 != tai1Copy), "Inequality of copies");
// Check equality of different sizes #1
// (compilation checks constness of op==)
t.test(!(tai1Ref == tai2Ref), "Equality of different sizes #1");
// Check inequality of different sizes #1
// (compilation checks constness of op!=)
t.test(tai1Ref != tai2Ref, "Inequality of different sizes #1");
// Check equality of different sizes #2
t.test(!(tai2Ref == tai1Ref), "Equality of different sizes #2");
// Check inequality of different sizes #2
t.test(tai2Ref != tai1Ref, "Inequality of different sizes #2");
// Modify copy
++tai1Copy[theSize-1];
// Check equality of modification of copy
t.test(!(tai1 == tai1Copy), "Equality of modification of copy");
// Check inequality of modification of copy
t.test(tai1 != tai1Copy, "Inequality of modification of copy");
}
void test_resto_divisao_maior()
{
t.open("resto_divisao_maior", 1);
t.add(resto_divisao_maior(5,2) == 1);
t.add(resto_divisao_maior(10,3) == 1);
t.add(resto_divisao_maior(3,5) == 2);
t.add(resto_divisao_maior(4,6) == 2);
t.close();
}
void test_a_eh_maior()
{
t.open("a_eh_maior", 1);
t.add(a_eh_maior(1,3,5) == false);
t.add(a_eh_maior(3,2,1) == true);
t.add(a_eh_maior(2,3,7) == false);
t.add(a_eh_maior(5,7,1) == false);
t.close();
}
void test_resto_divisao()
{
t.open("resto_divisao", 1);
t.add(resto_divisao(5,2) == 1);
t.add(resto_divisao(10,2) == 0);
t.add(resto_divisao(8,5) == 3);
t.add(resto_divisao(6,4) == 2);
t.close();
}
void test_valor_maximo2()
{
t.open("valor_maximo2", 1);
t.add(valor_maximo2(1,3) == 3);
t.add(valor_maximo2(3,2) == 3);
t.add(valor_maximo2(2,3) == 3);
t.add(valor_maximo2(5,7) == 7);
t.close();
}
int main( int argc, char **argv )
{
QApplication app( argc, argv );
Tester t;
t.test();
return 0;
}
int main() {
Tester<500> t;
char * ptr = t.getPtr();
char * buf = t.getBuf();
std::cout << "'" << (void*)ptr << std::endl;
std::cout << "'" << (void*)buf << std::endl;
assert( buf == ptr );
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Tester w;
QApplication::setApplicationName("widgetKeyboard");
w.show();
return app.exec();
}
void test_operacao2()
{
t.open("operacao2", 2);
t.add(operacao2(4,2) == 0);
t.add(operacao2(5,3) == 5);
t.add(operacao2(8,5) == 12);
t.add(operacao2(21,4) == 21);
t.add(operacao2(17,6) == 85);
t.close();
}
int main(int arc, char** argv)
{
iris::glog<iris::Warning>("Global Test");
iris::glog<iris::Warning>("Global Test 2",
"Arg1", iris::arg<int>(5));
Tester t;
t.doit();
return 0;
}
void test_eh_sobra31_div5()
{
t.open("eh_sobra31_div5",1);
t.add(eh_sobra31_div5(10) == true);
t.add(eh_sobra31_div5(15) == false);
t.add(eh_sobra31_div5(19) == false);
t.add(eh_sobra31_div5(25) == true);
t.close();
}
int main()
{
std::cout << "1 == 0 ? " << equal(1, 0) << std::endl;
std::cout << "1 == 1 ? " << equal(1, 1) << std::endl;
Tester<int> iT;
std::cout << "41 == 42 ? " << iT.equal(41, 42) << std::endl;
std::cout << "42 == 42 ? " << iT.equal(42, 42) << std::endl;
return 0;
}
void CompositeTest::action(Tester& t)
{
t.preTests(*this);
for (std::list<Test*>::iterator i = m_tests.begin(); i != m_tests.end(); ++i)
{
(*i)->action(t);
}
t.postTests(*this);
}
// test_class_SSArray_bracket_op
// Test suite for class template SSArray, bracket operator
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate messages have been printed to cout.
// Does not throw (No-Throw Guarantee)
void test_class_SSArray_bracket_op(Tester & t)
{
std::cout << "Test Suite: class template SSArray, bracket operator"
<< std::endl;
bool correctType; // result of type checking
const int theSize = 10;
bool noErrors; // True if no errors encountered
int i; // Counter
SSArray<double> tad1;
correctType = TypeCheck<SSArray<double>::value_type>::check(tad1[1]);
t.test(correctType, "Bracket operator (non-const), return type");
SSArray<int> tai(theSize);
for (i = 0; i < theSize; ++i)
tai[i] = 15 - i * i;
noErrors = true;
for (i = 0; i < theSize; ++i)
{
if (tai[i] != 15 - i * i)
noErrors = false;
}
t.test(noErrors, "Bracket operator (non-const) #1");
tai[2] = 1000;
noErrors = true;
for (i = 0; i < theSize; ++i)
{
if (tai[i] != ((i == 2) ? 1000 : 15 - i * i))
noErrors = false;
}
t.test(noErrors, "Bracket operator (non-const) #2");
// Make const version, no copy
const SSArray<int> & taiRef = tai;
const SSArray<double> tad2;
correctType = TypeCheck<SSArray<double>::value_type>::check(tad2[1]);
t.test(correctType, "Bracket operator (const), return type");
noErrors = true;
for (i = 0; i < theSize; ++i)
{
if (taiRef[i] != ((i == 2) ? 1000 : 15 - i * i))
noErrors = false;
}
t.test(noErrors, "Bracket operator (const)");
}
int _tmain(int argc, _TCHAR* argv[])
{
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
Tester tester;
tester.Test(TestTextEncoding, "TextEncoding");
tester.WriteResults();
CoUninitialize();
return 0;
}
// test_class_SSArray_size_and_ctor_from_size
// Test suite for class SSArray, function size and ctor from size
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate have been messages printed to cout.
void test_class_SSArray_size_and_ctor_from_size(Tester & t)
{
std::cout << "Test Suite: class SSArray - function size, ctor from size" << std::endl;
const SSArray<int> ssai(10);
t.test(ssai.size() == 10, "size, ctor from size (const) #1");
const SSArray<double> ssad(100);
t.test(ssad.size() == 100, "size, ctor from size (const) #2)");
SSArray<int> ssai2(20);
t.test(ssai2.size() == 20, "size, ctor from size (non-const)");
}
int main(int argc, char **argv)
{
Tester t;
t.InitTests();
t.RunTests();
float tx, ty;
BMU::OrthogonalProjectionOfPointOnCircle(7.5f, 2.5f, 2.5f, 6.f, 3.f, tx, ty);
printf("\n\n%.2f %.2f", tx, ty);
return 0;
}
int main(int argc, char** argv) {
VerboseType vType = ALL;
int numRuns = 10;
std::string rootTestFileName = "testFile";
Lexer* testLexer = NULL;
std::cout << "------------ Lexer Tester -------------" << std::endl;
std::cout << "CS480: campbcha, wadec, zoonb, piorkowd" << std::endl << std::endl;
std::cout << "Running " << numRuns << " tests" << std::endl;
if ( vType == ALL ) {
std::cout << "PRINTING ALL MESSAGES";
} else if ( vType == ERRORS ) {
std::cout << "PRINTING ONLY ERRORS";
} else if ( vType == NONE ) {
std::cout << "PRINTING NO MESSAGES";
} else {
std::cout << "VERBOSE ERROR";
}
std::cout << std::endl << std::endl;
for ( int i = 1 ; i <= numRuns; i++ ) {
Tester myTester;
std::stringstream out;
std::cout << "--------------------------------" << std::endl;
std::cout << "Start test " << i << std::endl;
out << rootTestFileName << i << ".txt";
std::string testFileName = out.str();
try {
myTester.generateTestFile(testFileName);
testLexer = new Lexer(testFileName.c_str());
myTester.run(testLexer, vType);
} catch (Exception e) {
e.print();
}
if ( testLexer != NULL ) {
delete testLexer;
testLexer = NULL;
}
std::cout << "Test " << i << " done" << std::endl;
std::cout << "--------------------------------" << std::endl;
#ifdef _WIN32
Sleep(1000);
#else
sleep(1);
#endif
}
return 0;
}
// test_class_KSArray_begin_end
// Test suite for class KSArray, functions begin & end
// Pre: None.
// Post:
// Pass/fail status of tests have been registered with t.
// Appropriate messages have been printed to cout.
// Does not throw (No-Throw Guarantee)
void test_class_KSArray_begin_end(Tester & t)
{
std::cout << "Test Suite: class KSArray - functions begin & end" << std::endl;
bool correctType; // result of type checking
const int theSize = 10;
bool noErrors; // True if no errors encountered
int i; // Counter
int * iter; // iterator
const int * citer; // const_iterator
KSArray<int> tai(theSize);
for (iter = tai.begin(), i = 0; iter != tai.end(); ++iter, ++i)
*iter = 15 - i * i;
// Non-const test
KSArray<double> tad1;
correctType = TypeCheck<KSArray<double>::value_type *>::check(tad1.begin());
t.test(correctType, "begin (non-const), return type");
correctType = TypeCheck<KSArray<double>::value_type *>::check(tad1.end());
t.test(correctType, "end (non-const), return type");
t.test(tai.begin() != tai.end(), "begin/end - inequality (non-const)");
t.test (tai.end() - tai.begin() == theSize, "begin/end - check difference (non-const)");
noErrors = true;
for (iter = tai.begin(), i = 0; iter != tai.end(); ++iter, ++i)
{
if (*iter != 15 - i * i)
noErrors = false;
}
t.test(noErrors, "begin/end - check values (non-const)");
// Make const version, no copy
const KSArray<int> & taiRef = tai;
// Const test
const KSArray<double> tad2;
correctType = TypeCheck<const KSArray<double>::value_type *>::check(tad2.begin());
t.test(correctType, "begin (const), return type");
correctType = TypeCheck<const KSArray<double>::value_type *>::check(tad2.end());
t.test(correctType, "end (const), return type");
t.test(taiRef.end() - taiRef.begin() == theSize, "begin/end - check difference (const)");
noErrors = true;
for (citer = taiRef.begin(), i = 0; citer != taiRef.end(); ++citer, ++i)
{
if (*citer != 15 - i * i)
noErrors = false;
}
t.test(noErrors, "begin/end - check values (const)");
}
// main
// Runs class SSArray test suite, prints results to cout.
int main()
{
Tester t;
test_class_SSArray(t);
std::cout << std::endl;
if (t.allPassed())
std::cout << "All tests successful"
<< std::endl;
else
std::cout << "Tests ********** UNSUCCESSFUL **********"
<< std::endl;
std::cout << std::endl;
}
void Invocation::runTesting() {
cout << endl;
Tester * curTest = new Tester(params, info);
int testsCount = params->getTestsCount();
if (!params->getInputFileMask()->getDigitsCount() || !params->getOutputFileMask()->getDigitsCount()) testsCount = 1;
ERROR_CODE errorCode = EC_OK;
OUTCOME_TYPE outcome = OT_UD;
bool autoDetectTestsNumber = !testsCount;
for (int test = 1; !testsCount || test <= testsCount; ++test) {
errorCode = curTest->runTest(test, autoDetectTestsNumber);
if (errorCode) {
delete curTest;
if (!testsCount && (errorCode == EC_INPUT_DATA_FILE_NOT_FOUND || errorCode == EC_ANSWER_DATA_FILE_NOT_FOUND)) {
info->setOutcome(OT_AC);
return;
}
printColoredText("Internal Error", CC_LIGHTMAGENTA);
cout << endl;
info->setOutcome(OT_IE);
info->setComment("Test " + toa(test) + ": " + ERROR_MESSAGES[errorCode]);
outputInfo();
if (errorCode != EC_CANNOT_TERMINATE_TESTING_PROGRAM && errorCode != EC_CANNOT_TERMINATE_CHECKER) terminate(true, true); else terminate(true, false);
}
cout << "Time: ";
printColoredText(toa(info->getLastTestTime()), CC_LIGHTCYAN);
cout << " ms Memory: ";
int usedMemory = info->getLastTestMemory();
if (usedMemory < 1000) {
printColoredText(toa(usedMemory), CC_LIGHTCYAN);
cout << " B ";
} else
if (usedMemory < 1000000) {
printColoredText(toa(usedMemory / 1000), CC_LIGHTCYAN);
cout << " KB ";
} else {
printColoredText(toa(usedMemory / 1000000.), CC_LIGHTCYAN);
cout << " MB ";
}
outcome = info->getOutcome();
printColoredText(SHORT_OUTCOME_NAME[outcome], OUTCOME_COLOR[outcome]);
cout << endl;
if (outcome != OT_UD) {
delete curTest;
return;
}
}
info->setOutcome(OT_AC);
delete curTest;
}
