test.h

/* Copyright (c) 2005-2014, Stefan Eilemann <eile@equalizergraphics.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of Eyescale Software GmbH nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef LBTEST_TEST_H
#define LBTEST_TEST_H

#include <lunchbox/log.h>
#include <lunchbox/sleep.h>
#include <lunchbox/thread.h>

#include <cstdlib>
#include <fstream>
#include <stdexcept>

#define OUTPUT lunchbox::Log::instance( __FILE__, __LINE__ )

#define TEST( x )                                                       \
    {                                                                   \
        LBVERB << "Test " << #x << std::endl;                           \
        if( !(x) )                                                      \
        {                                                               \
            OUTPUT << #x << " failed (l." << __LINE__ << ')' << std::endl; \
            lunchbox::abort();                                          \
            ::exit( EXIT_FAILURE );                                     \
        }                                                               \
    }

#define TESTINFO( x, info )                                           \
    {                                                                 \
        LBVERB << "Test " << #x << ": " << info << std::endl;         \
        if( !(x) )                                                    \
        {                                                             \
            OUTPUT << #x << " failed (l." << __LINE__ << "): " << info  \
                   << std::endl;                                        \
            lunchbox::abort();                                          \
            ::exit( EXIT_FAILURE );                                     \
        }                                                               \
    }

#define TESTRESULT( x, type )                                           \
    {                                                                   \
        LBVERB << "Test " << #x << std::endl;                           \
        const type& testRes = (x);                                      \
        if( !testRes )                                                  \
        {                                                               \
            OUTPUT << #x << " failed with " << testRes << " (l."        \
                   << __LINE__ << ")" << std::endl;                     \
            lunchbox::abort();                                          \
            ::exit( EXIT_FAILURE );                                     \
        }                                                               \
    }

int testMain( int argc, char **argv );

namespace
{
class Watchdog : public lunchbox::Thread
{
public:
    explicit Watchdog( const std::string& name ) : _name( name ) {}

    virtual void run()
        {
            lunchbox::Thread::setName( "Watchdog" );
#ifdef TEST_RUNTIME
            lunchbox::sleep( TEST_RUNTIME * 1000 );
            std::cerr << "Watchdog triggered - " << _name
                      << " did not terminate within " << TEST_RUNTIME << "s"
                      << std::endl;
#else
            lunchbox::sleep( 60000 );
            std::cerr << "Watchdog triggered - " << _name
                      << " did not terminate within 1 minute" << std::endl;
#endif
            lunchbox::abort( true /*dumpThreads*/ );
        }

private:
    const std::string _name;
};
}

int main( int argc, char **argv )
{
#ifndef TEST_NO_WATCHDOG
    Watchdog watchdog( argv[0] );
    watchdog.start();
#endif

    try
    {
        const int result = testMain( argc, argv );
        if( result != EXIT_SUCCESS )
            return result;
    }
    catch( const std::runtime_error& e )
    {
        LBINFO << "Test exception: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }

#ifndef TEST_NO_WATCHDOG
    watchdog.cancel();
    lunchbox::sleep( 10 ); // give watchdog time to terminate
#endif
    return EXIT_SUCCESS;
}

#  define main testMain

#endif // LBTEST_TEST_H