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, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef XAPIAN_INCLUDED_TESTSUITE_H
#define XAPIAN_INCLUDED_TESTSUITE_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);
 
    [[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))
 
// Newer test macros:
#include "testmacros.h"
 
inline void XFAIL(const char* msg) {
    expected_failure = msg;
}
 
#endif // XAPIAN_INCLUDED_TESTSUITE_H