test.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    test.h
// Purpose:     List of all Tests/Benchmarks
// Last Change: 11.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 2016-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef TEST_INCLUDED
#define TEST_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef VER_INCLUDED
#include "../base/ver.h"
#endif

#ifndef STR_INCLUDED
#include "../base/str.h"
#endif

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

#ifndef REL_INCLUDED
#include "../rel/rel.h"
#endif

#ifndef RTEST_INCLUDED
#include "rtest.h"
#endif

#ifndef BENCH_INCLUDED
#include "bench.h"
#endif

//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// TEST_MAGIC: Magic number (identifies objects of this class).
//-----------------------------------------------------------------------------

static const long TEST_MAGIC = 0x5445530AL;     // 'TES\n'


//=============================================================================
// Class Containing All Tests / Benchmarks:
//=============================================================================

class test_c {
        public:

//-----------------------------------------------------------------------------
// Constructor, Destructor:
//-----------------------------------------------------------------------------

        // Constructor:
        test_c(str_t test_id, bool (*test_fun)(test_c* test),
                        int test_arg, str_t test_name);

        // Destructor:
        ~test_c();

//-----------------------------------------------------------------------------
// (Object) Methods:
//-----------------------------------------------------------------------------

        // id: Return ID of this test (short name).
        str_t id() {
                // Check this object:
                CHECK_VALID("test_c::id");

                // Return ID attribute value:
                return Id;
        }

        // run: Execute this test.
        bool run();

//-----------------------------------------------------------------------------
// Static Methods:
//-----------------------------------------------------------------------------

        // get_test: Get test with a given ID.
        static test_c* get_test(str_t test_id);

        // print_list: Print list of all tests.
        static void print_list();

//-----------------------------------------------------------------------------
// Debugging Support:
//-----------------------------------------------------------------------------

#if     VER_DEBUG
        public:
        // Integrity check:
        str_t   check() const;

        private:
        // Magic number (identifies objects of this class for debugging).
        long    Magic;          // Must be "TEST_MAGIC".
#endif

#if     VER_DUMP
        public:
        // Display data structure:
        void dump(str_t headline = STR_NULL) const;
#endif

//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        test_c(const test_c& obj);              // Not implemented
        test_c& operator=(const test_c& obj);   // Not implemented

//-----------------------------------------------------------------------------
// Private Object Members:
//-----------------------------------------------------------------------------

        private:

        // Id of Test/Benchmark (short name):
        str_t Id;

        // Integer Argument of Benchmark (0 if not used):
        int Arg;

        // Test/Benchmark Function:
        bool (*Fun)(test_c* test);

        // Name of the Test/Benchmark (longer name, description):
        str_t Name;

        // Test was executed:
        bool Done;

        // Test was successful:
        bool Ok;

        // Something strange happened (e.g. very different cpu/realtime):
        bool Warn;

        // Overall Runtime (Larger of Wallclock and CPU-Time):
        long TotalTime;

        // If Standard Benchmark: Time for Loading Data.
        long LoadTime;

        // If Standard Benchmark: Time for Bottom-Up Evaluation.
        long EvalTime;

//-----------------------------------------------------------------------------
// Private Methods - Auxiliary Functions for Executing the tests:
//-----------------------------------------------------------------------------

        private:

        // run_bench: Run a Benchmark.
        bool run_bench(bench_t bench);

        // run_bench_static: Run a Benchmark defined as a static method.
        bool run_bench_static(str_t name,
                long (*run)(str_t file, perf_t timer_load, perf_t timer_eval),
                str_t file_name, long expected_result);

        // run_rtest: Run a test of a data structure for storing relations.
        bool run_rtest(rtest_t rtest, rel_t rel);

        // Function to call if argument is not used:
        void arg_unused();

        // mem_statistics: Print memory pool statistics.
        void mem_statistics(str_t headline);

        // test_failed: An error occurred during the test.
        void test_failed(str_t msg);

        // wrong_result: A function called in the test returned a wrong result.
        void wrong_result(str_t fun, long result, long expected_result);

        // rtest_failed: An error occurred during insertion/lookup of a tuple.
        void rtest_failed(str_t msg, int tuple_no, int arity, int c1, int c2);

        // max_time: Return the larger of realtime+cputime, check plausibility.
        long max_time(long realtime, long cputime);

//-----------------------------------------------------------------------------
// Private Static Methods - These are the Test Functions:
//-----------------------------------------------------------------------------

        private:

        //---------------------------------------------------------------------
        // Tests of Data Structures for Storing Relations:
        //---------------------------------------------------------------------

        // Test set with one int column, implemented as dynamic hash table:
        static bool set_1d(test_c* test);

        // Test set with one int column, implemented as extendible hash table:
        static bool set_1e(test_c* test);

        // Test set with one int column, implemented using C++11 standard lib:
        static bool set_1s(test_c* test);

        // Test set with two int columns, implemented as dynamic hash table:
        static bool set_2d(test_c* test);

        // Test set with two int columns, implemented as extendible hash table:
        static bool set_2e(test_c* test);

        // Test set with two int columns, implemented using C++11 standard lib:
        static bool set_2s(test_c* test);

        //---------------------------------------------------------------------
        // Benchmarks for Bottom-Up Evaluation:
        //---------------------------------------------------------------------

        // DBLP benchmark (different implementations):
        static bool bench_dblp_1(test_c* test);
        static bool bench_dblp_2(test_c* test);
        static bool bench_dblp_3(test_c* test);

        // Join 1 benchmark with query a(X,Y):
        static bool bench_j1axy_1(test_c* test);
        static bool bench_j1axy_2(test_c* test);
        static bool bench_j1axy_3(test_c* test);
        static bool bench_j1axy_4(test_c* test);
        static bool bench_j1axy_5(test_c* test);
        static bool bench_j1axy_6(test_c* test);
        static bool bench_j1axy_7(test_c* test);
        static bool bench_j1axy_8(test_c* test);
        static bool bench_j1axy_9(test_c* test);

        // Transitive closure benchmark with query tc(X,Y), i.e. binding "ff":
        static bool bench_tcff_1(test_c* test);
        static bool bench_tcff_2(test_c* test);
        static bool bench_tcff_3(test_c* test);
        static bool bench_tcff_4(test_c* test);
        static bool bench_tcff_5(test_c* test);

        // Transitive closure benchmark with query tc(1,X), i.e. binding "bf":
        static bool bench_tcbf_1(test_c* test);
        static bool bench_tcbf_2(test_c* test);
        static bool bench_tcbf_4(test_c* test);

        // The "Wine Ontology" benchmark:
        static bool bench_wine(test_c* test);

//-----------------------------------------------------------------------------
// Data Load Tests (Partial Benchmarks):
//-----------------------------------------------------------------------------

        // Load DBLP data file:
        static bool load_dblp(test_c* test);

        // Load transitive closure data file:
        static bool load_tc(test_c* test);

        // Load transitive closure data file, new version with general loader:
        static bool load_tc_gen(test_c* test);

//-----------------------------------------------------------------------------
// Dummy Test Function:
//-----------------------------------------------------------------------------

        static bool end_marker(test_c* test);

//-----------------------------------------------------------------------------
// Private Static Variables:
//-----------------------------------------------------------------------------

        private:

        // List of all tests:
        static test_c Tests[];

//=============================================================================
// End of Class:
//=============================================================================

};

//-----------------------------------------------------------------------------
// Define pointer type:
//-----------------------------------------------------------------------------

typedef test_c *test_t;

//-----------------------------------------------------------------------------
// Define null pointer:
//-----------------------------------------------------------------------------

#define TEST_NULL (static_cast<test_t>(0))

//=============================================================================
// End of Include File:
//=============================================================================

#endif