/*

* 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