/*
* 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 <iostream>

#include "itktesters.h"
#include "itktestmgr.h"
#include "testexc.h"
#include "itkimpl.h"

namespace Itk
{
    class BeginEndSentry
    {
    private:
        Itk::TestMgr     * testMgr_;
        Itk::TesterBase  * testerBase_;

    public:
        BeginEndSentry(Itk::TestMgr   * testMgr,
                       Itk::TesterBase * testerBase)
            : testMgr_(testMgr),
              testerBase_(testerBase)
        {
            testMgr_->beginTestCase(testerBase_);
        }

        
        ~BeginEndSentry()
        {
            testMgr_->endTestCase(testerBase_);
        }
    };



    /**
     * Adapts the conventional C-style interface of a free function to
     * the TesterBase interface.
     */
    class FreeFuncAdapter : public Itk::TesterBase
    {
    private:
        void (* testFunc_)(Itk::TestMgr *);

    public:
        FreeFuncAdapter(const char * name,
                        void      (* testFunc)(Itk::TestMgr*))
            : Itk::TesterBase(name),
              testFunc_(testFunc)
        {
            ;
        }

        virtual void doRun(Itk::TestMgr * testMgr)
        {
            (*testFunc_)(testMgr);
        }

        virtual ~FreeFuncAdapter()
        {
            ;
        }
    };



    /**
     * Adapts the conventional C-style interface of a free function to
     * the TesterBase interface. The function will do (most) of its test
     * based on output produced and compared.
     */
    class FreeIOFuncAdapter : public Itk::TesterBase
    {
    private:
        void              (* testFunc_)(Itk::TestMgr *);
        const std::string    defFilesBaseName_;
        const std::string    lenience_;

    public:
        FreeIOFuncAdapter(const char * name,
                          void      (* testFunc)(Itk::TestMgr*),
                          const char * defFilesBaseName,
                          const char * lenience)
            : Itk::TesterBase(name),
              testFunc_(testFunc),
              defFilesBaseName_(defFilesBaseName),
              lenience_(lenience == NULL ? "" : lenience)
        {
            ;
        }

        virtual void doRun(Itk::TestMgr * testMgr)
        {
            Itk::Impl::EvaluateIOCapture(defFilesBaseName_,
                                         testMgr,
                                         testFunc_,
                                         lenience_);
        }

        virtual ~FreeIOFuncAdapter()
        {
            ;
        }
    };


    class SetupTearDownSentry
    {
    private:
        Itk::ITestContext   * context_;

    public:
        SetupTearDownSentry(Itk::ITestContext * context)
            : context_(context)
        {
            context_->setup();
        }

        ~SetupTearDownSentry()
        {
            context_->tearDown();
        }
    };

}



namespace Itk
{
    /****
     * IOCaptureExc
     */
    const char * IOCaptureExc::what() const throw()
    {
        return what_.c_str();
    }


    IOCaptureExc::IOCaptureExc(const char * what)
        : what_(what)
    {
        ;
    }


    IOCaptureExc::IOCaptureExc(const IOCaptureExc & that)
        : what_(that.what_)
    {
        ;
    }



    /****
     * TesterBase
     */
    TesterBase::TesterBase(const char * name)
        : name_(name)
    {
        ;
    }


    const std::string & TesterBase::name() const
    {
        return name_;
    }


    

    void TesterBase::run(TestMgr * testMgr)
    {
        BeginEndSentry
            sentry(testMgr,
                   this);

        doRun(testMgr);
    }


    void TesterBase::printHierarchy(std::ostream & os,
                                    int            indent) const
    {
        indentSpaces(indent,
                     os);
        os << name() << std::endl;
    }


    size_t TesterBase::count() const
    {
        return 1;
    }


    TesterBase::~TesterBase()
    {
        ;
    }


    
    void TesterBase::indentSpaces(int            indent,
                                  std::ostream & os) const
    {
        for (; indent > 0; --indent)
            {
                os << "  ";
            }
    }


    /****
     * SuiteTester
     */
    const char SuiteTester::REDIRECT_ONLY[] = "_ReDiReCtOnLy_";


    SuiteTester::SuiteTester(const char * name)
        : TesterBase(name)
    {
        ;
    }


    void SuiteTester::printHierarchy(std::ostream & os,
                                     int            indent) const
    {
        using namespace std;

        TesterBase::printHierarchy(os,
                                   indent);

        const ContextTester
            * contextTester = dynamic_cast<const ContextTester*>(this);

        // we don't print children of context testers as they
        // cannot be used for partial testing anyway
        if (contextTester == NULL)
            {
                list<TesterBase*>::const_iterator
                    i = testerBases_.begin(),
                    end = testerBases_.end();
                
                for (; i != end; ++i)
                    {
                        (*i)->printHierarchy(os,
                                             indent + 1);
                    }
            }
    }


    size_t SuiteTester::count() const
    {
        size_t
            rv = 0;

        std::list<TesterBase*>::const_iterator
            i = testerBases_.begin(),
            end = testerBases_.end();
        
        for (; i != end; ++i)
            {
                rv += (*i)->count();
            }

        return rv;
    }


    void SuiteTester::add(TesterBase * testerBase)
    {
        testerBases_.push_back(testerBase);
    }


    void SuiteTester::add(const char * name,
                          void (     * testFunc)(TestMgr * testMgr))
    {
        testerBases_.push_back(new FreeFuncAdapter(name,
                                                   testFunc));
    }


    
    void SuiteTester::add(const char * name,
                          void      (* testFunc)(TestMgr *),
                          const char * defFilesBaseName,
                          const char * lenience)
    {
        testerBases_.push_back(new FreeIOFuncAdapter(name,
                                                     testFunc,
                                                     defFilesBaseName,
                                                     lenience));
    }


    void SuiteTester::doRun(TestMgr * testMgr)
    {
        using namespace std;

        list<TesterBase*>::iterator
            i = testerBases_.begin(),
            end = testerBases_.end();

        for (; i != end; ++i)
            {
                (*i)->run(testMgr);
            }
    }


    
    TesterBase * SuiteTester::getChild(const char * name) const
    {
        using namespace std;

        TesterBase
            * rv = NULL;

        list<TesterBase*>::const_iterator
            i = testerBases_.begin(),
            end = testerBases_.end();

        for (; i != end; ++i)
            {
                if ((*i)->name() == name)
                    {
                        break;
                    }
            }

        if (i != end)
            {
                rv = *i;
            }

        return rv;
    }


    SuiteTester::~SuiteTester()
    {
        using namespace std;

        list<TesterBase*>::iterator
            i = testerBases_.begin(),
            end = testerBases_.end();

        for (; i != end; ++i)
            {
                delete *i;
            }
        
        testerBases_.clear();
    }



    /****
     * PanicExc
     */
    PanicExc::PanicExc(const char * file,
                       size_t       line,
                       const char * format,
                       ...)
        : file_(file),
          line_(line)
    {
        char
            msg[256];

        va_list
            args;
        va_start(args,
                 format);

        vsnprintf(msg,
                  sizeof(msg),
                  format,
                  args);

        va_end(args);

        msg_ = msg;
    }
    
    
    const char * PanicExc::file() const
    {
        return file_.c_str();
    }

    
    size_t PanicExc::line() const
    {
        return line_;
    }


    const char * PanicExc::msg() const
    {
        return msg_.c_str();
    }


    const char * PanicExc::what() const throw()
    {
        return msg_.c_str();
    }


    /****
     * ITestContext
     */
    ITestContext::~ITestContext()
    {
        ;
    }


    
    /****
     * DefaultContext
     */
    class DefaultContext : public ITestContext
    {
    public:
        virtual void setup() throw (PanicExc)
        {
            ;
        }

        virtual void tearDown() throw ()
        {
            ;
        }

        virtual ~DefaultContext()
        {
            ;
        }
    };


    /****
     * ContextTester
     */
    ContextTester::ContextTester(const char * name,
                                 ITestContext   * context)
        : SuiteTester(name),
          context_(context == NULL ? new DefaultContext : context)
    {
        ;
    }


    void ContextTester::doRun(TestMgr * testMgr)
    {
        try
            {
                SetupTearDownSentry
                    sentry(context_);

                SuiteTester::doRun(testMgr);
            }
        catch (TestExc & exc)
            {
                ;
            }
        catch (PanicExc & exc)
            {
                testMgr->panic(exc.file(),
                               exc.line(),
                               exc.msg());
            }
        catch (...)
            {
                testMgr->unknownFailure(name().c_str());
                throw;
            }
    }


    ContextTester::~ContextTester()
    {
        delete context_;
    }


}