diff -r 000000000000 -r 671dee74050a searchengine/util/tsrc/itk/src/itkobservers.cpp
--- /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()) );
+    }
+
+
+
+
+}