tests/harness/testsuite.h

Go to the documentation of this file.

/* testsuite.h: a generic test suite engine
 *
 * Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002,2003,2005,2006,2007,2008 Olly Betts
 *
 * 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"

#include "output.h"

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

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

#include <float.h> // For DBL_DIG.

class TestFail { };

class TestSkip { };

// Don't bracket a, because it may have <<'s in it
#define FAIL_TEST(a) do { TestFail testfail; \
                          if (verbose) { tout << a << '\n'; } \
                          throw testfail; } while (0)

// Don't bracket a, because it may have <<'s in it
#define SKIP_TEST(a) do { TestSkip testskip; \
                          if (verbose) { tout << a << '\n'; } \
                          throw testskip; } while (0)

typedef bool (*test_func)();

struct test_desc {
    const char *name;

    test_func run;
};

//
//  If verbose is set, then the test harness will display diagnostic output
//  for tests which fail or skip.  Individual tests may use this flag to avoid
//  needless generation of diagnostic output in cases when it's expensive.
extern bool verbose;

//  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;

            unsigned int failed;

            unsigned int skipped;

            result() : succeeded(0), failed(0), skipped(0) { }

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

            void reset() {
                succeeded = 0;
                failed = 0;
                skipped = 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 &);

        typedef enum { PASS = 1, FAIL = 0, SKIP = -1 } test_result;

        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 TESTCASE_LOCN(a) __FILE__":"STRINGIZE(__LINE__)": "STRINGIZE(a)

#define TEST_AND_EXPLAIN(a, b) do {\
        if (!(a)) FAIL_TEST(TESTCASE_LOCN(a) << std::endl << b << std::endl);\
    } while (0)

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

// Crude wrapper for compatibility with tests backported from 1.1.x.
#define TEST_REL(A,R,B) TEST((A) R (B))

#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 TEST_GREATER_OR_EQUAL(a, b) TEST_AND_EXPLAIN(((a) >= (b)), \
        "Expected `"STRINGIZE(a)"' to be greater than or equal to `"STRINGIZE(b)"':" \
        " were " << (a) << " and " << (b))

#define TEST_GREATER(a, b) TEST_AND_EXPLAIN(((a) > (b)), \
        "Expected `"STRINGIZE(a)"' to be greater than `"STRINGIZE(b)"':" \
        " were " << (a) << " and " << (b))

#define TEST_LESSER_OR_EQUAL(a, b) TEST_AND_EXPLAIN(((a) <= (b)), \
        "Expected `"STRINGIZE(a)"' to be less than or equal to `"STRINGIZE(b)"':" \
        " were " << (a) << " and " << (b))

#define TEST_LESSER(a, b) TEST_AND_EXPLAIN(((a) < (b)), \
        "Expected `"STRINGIZE(a)"' to be less than than `"STRINGIZE(b)"':" \
        " were " << (a) << " and " << (b))

#endif // OM_HGUARD_TESTSUITE_H

---