--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/searchengine/util/tsrc/itk/src/itkobservers.cpp Mon Apr 19 14:40:16 2010 +0300
@@ -0,0 +1,763 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+
+#include <exception>
+#include <fstream>
+#include <iostream>
+#include <memory>
+
+#include "cpixfstools.h"
+
+#include "itktesters.h"
+#include "itkobservers.h"
+
+namespace Itk
+{
+ /**
+ * ITestRunObserver
+ */
+ ITestRunObserver::~ITestRunObserver()
+ {
+ ;
+ }
+
+
+ /*****************************************************************
+ * TestRunConsole
+ */
+ void TestRunConsole::beginRun(TestMgr * ,
+ size_t /* testCount */,
+ const char * /* baseDirPath */)
+ {
+ indent_ = 0;
+ os_ << "TEST RUN STARTING." << std::endl;
+ }
+
+
+ void TestRunConsole::endRun(TestMgr * ) throw ()
+ {
+ using namespace std;
+ os_ << endl << "TEST RUN COMPLETED." << endl;
+ }
+
+
+ void TestRunConsole::beginTestCase(TestMgr * ,
+ TesterBase * testerBase)
+ {
+ ++indent_;
+
+ using namespace std;
+
+ os_ << endl;
+ printIndent();
+ os_ << testerBase->name() << ' ';
+ }
+
+
+ void TestRunConsole::endTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+ --indent_;
+ }
+
+
+ void TestRunConsole::expecting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ if (!succeeded)
+ {
+ os_ << 'E';
+ }
+ }
+
+
+ void TestRunConsole::asserting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ if (!succeeded)
+ {
+ os_ << 'A';
+ }
+ }
+
+
+ void TestRunConsole::unknownFailure(TestMgr * testMgr,
+ const char * contextName)
+ {
+ os_ << "UNKNOWN ERROR IN CONTEXT: " << contextName;
+ }
+
+
+ void TestRunConsole::msg(TestMgr * testMgr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ using namespace std;
+
+ os_ << endl << msg << endl;
+ }
+
+
+ void TestRunConsole::panic(const char * file,
+ size_t line,
+ const char * msg)
+ {
+ using namespace std;
+
+ os_
+ << "PANIC at "
+ << file
+ << '/'
+ << line
+ << ": "
+ << msg
+ << endl;
+ }
+
+
+ void TestRunConsole::ioCaptureDefined(const char * file,
+ const char * msg)
+ {
+ using namespace std;
+
+ os_ << "Please check manually and version "
+ << file
+ << endl;
+ }
+
+
+ void TestRunConsole::ioCaptureError(const char * file,
+ const char * msg)
+ {
+ using namespace std;
+
+ os_ << "Please check problem with file "
+ << file
+ << endl;
+ }
+
+
+ void TestRunConsole::report(const char * name,
+ const char * value)
+ {
+ ;
+ }
+
+
+ TestRunConsole::TestRunConsole(std::ostream & os)
+ : os_(os),
+ indent_(0)
+ {
+ ;
+ }
+
+
+ TestRunConsole::~TestRunConsole()
+ {
+ ;
+ }
+
+
+ void TestRunConsole::printIndent()
+ {
+ for (int i = indent_; i >= 0; --i)
+ {
+ os_ << " ";
+ }
+ }
+
+
+
+ /*****************************************************************
+ * CompositeTestRunObserver
+ */
+ void CompositeTestRunObserver::beginRun(TestMgr * testMgr,
+ size_t testCount,
+ const char * baseDirPath)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->beginRun(testMgr,
+ testCount,
+ baseDirPath);
+ }
+ }
+
+
+ void CompositeTestRunObserver::endRun(TestMgr * testMgr) throw ()
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->endRun(testMgr);
+ }
+ }
+
+
+ void CompositeTestRunObserver::beginTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->beginTestCase(testMgr,
+ testerBase);
+ }
+ }
+
+
+ void CompositeTestRunObserver::endTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->endTestCase(testMgr,
+ testerBase);
+ }
+ }
+
+
+ void CompositeTestRunObserver::expecting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->expecting(testMgr,
+ succeeded,
+ expr,
+ file,
+ line,
+ msg);
+ }
+ }
+
+
+ void CompositeTestRunObserver::asserting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->asserting(testMgr,
+ succeeded,
+ expr,
+ file,
+ line,
+ msg);
+ }
+ }
+
+
+ void CompositeTestRunObserver::unknownFailure(TestMgr * testMgr,
+ const char * contextName)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->unknownFailure(testMgr,
+ contextName);
+ }
+ }
+
+
+ void CompositeTestRunObserver::msg(TestMgr * testMgr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->msg(testMgr,
+ file,
+ line,
+ msg);
+ }
+ }
+
+
+ void CompositeTestRunObserver::panic(const char * file,
+ size_t line,
+ const char * msg)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->panic(file,
+ line,
+ msg);
+ }
+ }
+
+
+ void CompositeTestRunObserver::ioCaptureDefined(const char * file,
+ const char * msg)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->ioCaptureDefined(file,
+ msg);
+ }
+ }
+
+
+ void CompositeTestRunObserver::ioCaptureError(const char * file,
+ const char * msg)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->ioCaptureError(file,
+ msg);
+ }
+ }
+
+
+ void CompositeTestRunObserver::report(const char * name,
+ const char * value)
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ (*i)->report(name,
+ value);
+ }
+ }
+
+
+ CompositeTestRunObserver::CompositeTestRunObserver()
+ {
+ ;
+ }
+
+
+ CompositeTestRunObserver::~CompositeTestRunObserver()
+ {
+ std::list<ITestRunObserver*>::iterator
+ i = observers_.begin(),
+ end = observers_.end();
+
+ for (; i != end; ++i)
+ {
+ delete *i;
+ }
+ }
+
+
+ void CompositeTestRunObserver::add(ITestRunObserver * testRunObserver)
+ {
+ std::auto_ptr<ITestRunObserver>
+ safeGuard(testRunObserver);
+
+ observers_.push_back(testRunObserver);
+ safeGuard.release();
+ }
+
+
+
+
+ /*****************************************************************
+ * ProgressDumper
+ */
+ void ProgressDumper::beginRun(TestMgr * testMgr,
+ size_t testCount,
+ const char * baseDirPath)
+ {
+ ofs_ << "TEST RUN STARTING." << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::endRun(TestMgr * testMgr) throw ()
+ {
+ ofs_ << "TEST RUN COMPLETED." << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::beginTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+ ofs_ << "TESTCASE BEGIN: " << testerBase->name() << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::endTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+ ofs_ << "TESTCASE END." << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::expecting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ if (!succeeded)
+ {
+ ofs_ << "EXPECTATION "
+ << expr
+ << " at ("
+ << file
+ << ":"
+ << line
+ << ") failed"
+ << std::endl;
+ ofs_.flush();
+ }
+ }
+
+
+ void ProgressDumper::asserting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ if (!succeeded)
+ {
+ ofs_ << "ASSERTION "
+ << expr
+ << " at ("
+ << file
+ << ":"
+ << line
+ << ") failed"
+ << std::endl;
+ ofs_.flush();
+ }
+ }
+
+
+ void ProgressDumper::unknownFailure(TestMgr * testMgr,
+ const char * contextName)
+ {
+ ofs_ << "UNKNOWN FAILURE IN CONTEXT " << contextName << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::msg(TestMgr * testMgr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ ofs_ << "MSG "
+ << msg
+ << " at ("
+ << file
+ << ":"
+ << line
+ << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::panic(const char * file,
+ size_t line,
+ const char * msg)
+ {
+ ofs_ << "PANIC "
+ << msg
+ << " at ("
+ << file
+ << ":"
+ << line
+ << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::ioCaptureDefined(const char * file,
+ const char * msg)
+ {
+ ofs_ << "IO CAPTURE DEFINED at ("
+ << file
+ << "): "
+ << msg
+ << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::ioCaptureError(const char * file,
+ const char * msg)
+ {
+ ofs_ << "IO CAPTURE ERROR at ("
+ << file
+ << "): "
+ << msg
+ << std::endl;
+ ofs_.flush();
+ }
+
+
+ void ProgressDumper::report(const char * name,
+ const char * value)
+ {
+ ofs_ << "REPORT "
+ << name
+ << ": "
+ << value
+ << std::endl;
+ ofs_.flush();
+ }
+
+
+ ProgressDumper::ProgressDumper(const char * path)
+ : ofs_(path)
+ {
+ if (!ofs_.is_open())
+ {
+ throw std::exception();
+ }
+ }
+
+
+ ProgressDumper::~ProgressDumper()
+ {
+ ;
+ }
+
+
+ /*****************************************************************
+ * ProgressFsDisplayer
+ */
+
+ const size_t BLINKENLICHT_CHARNUM = 4;
+ const char BLINKENLICHT_CHARS[] = "W3ME";
+
+
+ void ProgressFsDisplayer::beginRun(TestMgr * testMgr,
+ size_t testCount,
+ const char * baseDirPath)
+ {
+ baseFilePath_ = baseDirPath;
+ if (baseFilePath_[baseFilePath_.length() - 1] != '\\'
+ && baseFilePath_[baseFilePath_.length() - 1] != '/')
+ {
+ // TODO FIX platform-dependent code here
+ baseFilePath_ += '\\';
+ }
+ baseFilePath_ += "itk_";
+
+ curFilePath_ = "";
+
+ blinkenLichtStatus_ = 0;
+
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::endRun(TestMgr * testMgr) throw ()
+ {
+ deleteCurFile();
+ }
+
+
+ void ProgressFsDisplayer::beginTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::endTestCase(TestMgr * testMgr,
+ TesterBase * testerBase)
+ {
+
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::expecting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::asserting(TestMgr * testMgr,
+ bool succeeded,
+ const char * expr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::unknownFailure(TestMgr * testMgr,
+ const char * contextName)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::msg(TestMgr * testMgr,
+ const char * file,
+ size_t line,
+ const char * msg)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::panic(const char * file,
+ size_t line,
+ const char * msg)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::ioCaptureDefined(const char * file,
+ const char * msg)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::ioCaptureError(const char * file,
+ const char * msg)
+ {
+ blink();
+ }
+
+
+ void ProgressFsDisplayer::report(const char * name,
+ const char * value)
+ {
+ blink();
+ }
+
+
+ ProgressFsDisplayer::ProgressFsDisplayer()
+ {
+ ;
+ }
+
+
+ ProgressFsDisplayer::~ProgressFsDisplayer()
+ {
+ deleteCurFile();
+ }
+
+
+ void ProgressFsDisplayer::blink()
+ {
+ deleteCurFile();
+
+ // computing next file name to display status with
+ ++blinkenLichtStatus_;
+ if (blinkenLichtStatus_ == BLINKENLICHT_CHARNUM)
+ {
+ blinkenLichtStatus_ = 0;
+ }
+
+ curFilePath_ = baseFilePath_;
+ curFilePath_ += BLINKENLICHT_CHARS[blinkenLichtStatus_];
+ curFilePath_ += ".txt";
+
+ // "touch"
+ std::ofstream
+ ofs(curFilePath_.c_str());
+ }
+
+
+ void ProgressFsDisplayer::deleteCurFile()
+ {
+ Cpt_EINTR_RETRY_SP( remove(curFilePath_.c_str()) );
+ }
+
+
+
+
+}