/*

* 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: 

*

*/

#ifndef ITK_ITKIMPL_H_

#define ITK_ITKIMPL_H_

#include <string>

#include "cpixfstools.h"

namespace Itk

{

    namespace Impl

    {

        /**

         * Tells if it could open the file.

         */

        bool FileExists(const char * path);

        /**

         *  Redirects the standard input, if necessary

         */

        class InputRedirector

        {

        private:

            int    duplicatedStdInFD_;

            int    inFileFD_;

        public:

            InputRedirector(const std::string & defFilesBasePath);

            ~InputRedirector();

        };

        /**

         *  Redirects the standard output, if necessary

         */

        class OutputRedirector

        {

        private:

            int       duplicatedStdOutFD_;

            int       outFileFD_;

            bool      stdErr_;

            TestMgr * testMgr_;

        public:

            /**

             * Creates an output redirector instance. The same class

             * is used for redirecting output and error, but there are

             * slight differences in how they work. See parameter

             * list.

             *

             * @param defFilesBasePath the path of the base of the

             * test definition files

             *

             * @param testMgr must NOT be null for stdout redirection

             * and must be NULL for redirecting stderr.

             */

            OutputRedirector(const std::string  & defFilesBasePath,

                             TestMgr            * testMgr);

            ~OutputRedirector();

        };

        /**

         * Evaluates the results of an IO capturing session based on the

         * defFileBasePath argument (ctor) and what it can find on the

         * filesystem around those paths.

         */

        class IOCaptureEvaluator

        {

        private:

            //

            // private members

            //

            const std::string    defFileBasePath_;

            TestMgr            * testMgr_;

            const std::string  & lenience_;

        public:

            //

            // public operators

            //

            void evaluate();

            //

            // lifetime mgmt

            //

            IOCaptureEvaluator(const std::string  & defFileBasePath,

                               TestMgr            * testMgr,

                               const std::string  & lenience);

        private:

            //

            // private methods

            //

            void copyContent(const char * dstPath,

                             const char * srcPath);

            void compareContent(const char * expPath,

                                const char * resPath);

            void evaluate(bool stdErr);

        };

        /**

         * Only requirement for testFunc is that it should support the

         * following syntax: testFunc(testMgr);

         **/

        template<typename TESTFUNC>

        void EvaluateIOCapture(const std::string  & defFilesBaseName,

                               TestMgr            * testMgr,

                               TESTFUNC             testFunc,

                               const std::string  & lenience)

        {

            using namespace std;

            using namespace Itk::Impl;

            string

                defFilesBasePath;

            testMgr->ioTestCasesDir(defFilesBasePath);

            // OBS defFilesBasePath += defFilesBaseName;

            Cpt::pathappend(defFilesBasePath,

                            defFilesBaseName.c_str());

            try

                {

                    InputRedirector

                        stdInRedirector(defFilesBasePath);

                    OutputRedirector

                        stdOutRedirector(defFilesBasePath,

                                         testMgr), // std out

                        stdErrRedirector(defFilesBasePath,

                                         NULL); // std err

                    testFunc(testMgr);

                }

            catch (IOCaptureExc & exc)

                {

                    testMgr->ioCaptureError("(?)",

                                            exc.what());

                }

            IOCaptureEvaluator

                evaluator(defFilesBasePath,

                          testMgr,

                          lenience);

            evaluator.evaluate();

        }

    }

}

#endif ITK_ITKIMPL_H_