testsuite.h

Go to the documentation of this file.

/* Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002,2003,2005,2006,2007,2008,2009,2013,2015,2016,2018 Olly Betts
 * Copyright 2007 Richard Boulton
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#ifndef OM_HGUARD_TESTSUITE_H
#define OM_HGUARD_TESTSUITE_H

#include "noreturn.h"

#ifndef XAPIAN_UNITTEST
# include "output.h"
# define UNITTEST_CHECK_EXCEPTION
#endif

#include "stringutils.h" // For STRINGIZE().

#include <iomanip>
#include <map>
#include <sstream>
#include <string>
#include <vector>

#include <cfloat> // For DBL_DIG.

class TestFail { };

class TestSkip { };

#define THROW_TEST_(EXCEPTION, MSG) \
    do { \
        if (verbose) { \
            tout << __FILE__ ":" STRINGIZE(__LINE__) ": " << MSG << '\n'; \
        } \
        throw EXCEPTION(); \
    } while (0)

#define FAIL_TEST(MSG) THROW_TEST_(TestFail, MSG)

#define SKIP_TEST(MSG) THROW_TEST_(TestSkip, MSG)

struct test_desc {
    const char *name;

    void (*run)();
};

//
//  If verbose is non-zero, then the test harness will display diagnostic output
//  for tests which fail or skip.  If it is > 1, then the diagnostic output will
//  also be displayed for tests which pass.  Individual tests may use this flag
//  to avoid needless generation of diagnostic output in cases when it's
//  expensive.
extern int verbose;

extern const char* expected_failure;

//  Used to detect if such an exception was mishandled by the
//  compiler/runtime.
extern const char * expected_exception;

extern std::ostringstream tout;

class test_driver {
    void write_and_clear_tout();

  public:
    struct result {
        unsigned int succeeded = 0;

        unsigned int failed = 0;

        unsigned int skipped = 0;

        unsigned int xfailed = 0;

        unsigned int xpassed = 0;

        result & operator+=(const result & o) {
            succeeded += o.succeeded;
            failed += o.failed;
            skipped += o.skipped;
            xfailed += o.xfailed;
            xpassed += o.xpassed;
            return *this;
        }

        void reset() {
            succeeded = 0;
            failed = 0;
            skipped = 0;
            xfailed = 0;
            xpassed = 0;
        }
    };

    static void add_command_line_option(const std::string &l, char s,
                                        std::string * arg);

    static void parse_command_line(int argc, char **argv);

    XAPIAN_NORETURN(static void usage());

    static int run(const test_desc *tests);

    test_driver(const test_desc *tests_);

    result run_tests();

    result run_tests(std::vector<std::string>::const_iterator b,
                     std::vector<std::string>::const_iterator e);

    static std::string get_srcdir();

    // Running subtotal for current backend.
    static result subtotal;

    // Running total for the whole test run.
    static result total;

    static void report(const test_driver::result &r, const std::string &desc);

  private:
    test_driver(const test_driver &);
    test_driver & operator=(const test_driver &);

    enum test_result {
        XPASS = 3, XFAIL = 2, PASS = 1, FAIL = 0, SKIP = -1
    };

    static std::map<int, std::string *> short_opts;

    static std::string opt_help;

    static std::vector<std::string> test_names;

    test_result runtest(const test_desc *test);

    result do_run_tests(std::vector<std::string>::const_iterator b,
                        std::vector<std::string>::const_iterator e);

    // abort tests at the first failure
    static bool abort_on_error;

    // the default stream to output to
    std::ostream out;

    // the list of tests to run.
    const test_desc *tests;

    // how many test runs we've done - no summary if just one run
    static int runs;

    // program name
    static std::string argv0;

    // strings to use for colouring - empty if output isn't a tty
    static std::string col_red, col_green, col_yellow, col_reset;

    // use \r to not advance a line when a test passes (this only
    // really makes sense if the output is a tty)
    static bool use_cr;
};

#define TEST_AND_EXPLAIN(a, b) do {\
        bool test_and_explain_fail_ = !(a);\
        UNITTEST_CHECK_EXCEPTION\
        if (test_and_explain_fail_)\
            FAIL_TEST(STRINGIZE(a) << '\n' << b << '\n');\
    } while (0)

#define TEST(a) TEST_AND_EXPLAIN(a, "")

#define TEST_EQUAL(a, b) TEST_AND_EXPLAIN(((a) == (b)), \
        "Expected '" STRINGIZE(a) "' and '" STRINGIZE(b) "' to be equal:" \
        " were " << (a) << " and " << (b))

#define TEST_STRINGS_EQUAL(a, b) TEST_AND_EXPLAIN(((a) == (b)), \
        "Expected " STRINGIZE(a) " and " STRINGIZE(b) " to be equal, were:\n\"" \
        << (a) << "\"\n\"" << (b) << '"')

extern bool TEST_EQUAL_DOUBLE_(double a, double b);

#define TEST_EQUAL_DOUBLE(a, b) TEST_AND_EXPLAIN(TEST_EQUAL_DOUBLE_((a), (b)), \
        "Expected '" STRINGIZE(a) "' and '" STRINGIZE(b) "' to be (nearly) equal:" \
        " were " << setprecision(DBL_DIG) << (a) << " and " << (b) << ")" << setprecision(6))

#define TEST_NOT_EQUAL_DOUBLE(a, b) TEST_AND_EXPLAIN(!TEST_EQUAL_DOUBLE_((a), (b)), \
        "Expected '" STRINGIZE(a) "' and '" STRINGIZE(b) "' not to be (nearly) equal:" \
        " were " << setprecision(DBL_DIG) << (a) << " and " << (b) << ")" << setprecision(6))

#define TEST_NOT_EQUAL(a, b) TEST_AND_EXPLAIN(((a) != (b)), \
        "Expected '" STRINGIZE(a) "' and '" STRINGIZE(b) "' not to be equal:" \
        " were " << (a) << " and " << (b))

#define DEFINE_TESTCASE(S,COND) void test_##S()

// Newer test macros:
#include "testmacros.h"

inline void XFAIL(const char* msg) {
    expected_failure = msg;
}

#endif // OM_HGUARD_TESTSUITE_H