test_util.cpp

Go to the documentation of this file.

/*
This file is part of hugin.

hugin is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.

hugin is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with hugin.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <iostream>
#include <stdexcept>
#include <sstream>
#include <cstdio>
#include <sys/wait.h>
#include <iomanip>
#include "Makefile.h"
#include "test_util.h"

#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/code_converter.hpp>

using namespace makefile;
namespace fs = boost::filesystem;
namespace io = boost::iostreams;

namespace makefile { namespace tester {
int exec_make(std::stringbuf& makeoutbuf, std::stringbuf& makeerrbuf)
{
        // store 2 fd per pipe {read, write}
        int fdmakein[2];
        int fdmakeout[2];
        int fdmakeerr[2];
        if(pipe(fdmakein) || pipe(fdmakeout) || pipe(fdmakeerr))
        {
                std::cerr << "pipe() failed." << std::endl;
                return false;
        }


        if(fork())
        { // parent
                close(fdmakein[0]);
                close(fdmakeout[1]);
                close(fdmakeerr[1]);

                // boost gives us a way to use those pipes in C++ style.
                // the code_converter allows wchar mode Makefile to be written to a char-pipe
#ifdef USE_WCHAR
                io::stream< io::code_converter<io::file_descriptor_sink> > makein(fdmakein[1]);
#else
                io::stream<io::file_descriptor_sink> makein(fdmakein[1]);
#endif
                io::stream<io::file_descriptor_source> makeout(fdmakeout[0]);
                io::stream<io::file_descriptor_source> makeerr(fdmakeerr[0]);

                // Write the makefile to make's stdin
                Makefile::getSingleton().writeMakefile(makein);
                Makefile::getSingleton().clean();
                makein.close();

                makeout.get(makeoutbuf, '\0');  // delimiter \0 should read until eof.
                makeerr.get(makeerrbuf, '\0');

                int status;
                wait(&status);                  // status contains return value an some other flags
                if(WIFEXITED(status))   // that can be evaluated by these macros (man wait)
                {
                        return WEXITSTATUS(status);
                }
                // If WIFEXITED is false, something complicated happened (signal etc..).
                std::cerr << "Command terminated abnormally. status=" << std::hex << status << std::endl;
                return status;


        } else { // child
                close(fdmakein[1]);
                close(fdmakeout[0]);
                close(fdmakeerr[0]);
                // replace stdin and stdout
                if(dup2(fdmakein[0], 0) == -1 || dup2(fdmakeout[1], 1) == -1 || dup2(fdmakeerr[1], 2) == -1)
                {
                        std::cerr << "Failed to switch std stream" << std::endl;
                        exit(-1);
                }

                // execvp takes a NULL-terminated array of null-terminated strings. cool ;)
                const char* const argv[] = {"make", "-f-", (char*) NULL};
                execvp(argv[0], (char* const*)argv);
                return -1;              // exec should never return
        }
}

bool Test::run()
{
        int status = exec_make(makeoutbuf, makeerrbuf);

        std::cout << std::setw(30) << std::left <<  name;
        if(eval())
        {
                std::cout << "PASS" << std::endl;
                return true;
        }
        std::cout << "FAIL" << std::endl;
        std::cout << "ret: " << status << std::endl;
        std::cout << "out: " << makeoutbuf.str() << std::endl;
        std::cout << "cmp: " << goodout << std::endl;
        std::cout << "err: " << makeerrbuf.str() << std::endl;
        return false;
}
}}

---