FCL/sf/mw/searchsrv: comparison searchengine/util/tsrc/itk/src/itkobservers.cpp

equal deleted inserted replaced

--1:000000000000
+:671dee74050a
+/*
+* 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()) );
+}
+}

changeset 0	671dee74050a
child 8	6547bf8ca13a