test_set1.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    test_set1.h
// Purpose:     A test method for set implementations with one int argument.
// 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_SET1_INCLUDED
#define TEST_SET1_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 RELSIZE_INCLUDED
#include "../rel/relsize.h"
#endif

#ifndef GEN_CUR1_INCLUDED
#include "gen_cur1.h"
#endif

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

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

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

static const long TEST_SET1_MAGIC = 0x5453310AL;        // 'TS1\n'


//=============================================================================
// Class Template for Testing Sets with one Integer Argument:
//=============================================================================

template<class T> class test_set1_c : public rtest_c {

        public:

//-----------------------------------------------------------------------------
// Constructor:
//-----------------------------------------------------------------------------

        test_set1_c(T set, int test_id) :
                rtest_c(set),
                Cur1(rel1(test_id))
        {
                // Check parameters:
                CHECK_PAR(set, "test_set1_c::constructor");
                CHECK(test_id >= 0 && test_id <= 4,
                        "test_set1_c::constructor: unknown test_id");

                // Initialize attributes:
                Set = set;
                TestID = test_id;

                // Set Magic number:
                CHECK_CODE(Magic = TEST_SET1_MAGIC);
        }

//-----------------------------------------------------------------------------
// Destructor:
//-----------------------------------------------------------------------------

        ~test_set1_c()
        {

                // Check this object:
                CHECK_VALID("test_set1_c::destructor");

                // Make this object invalid:
                CHECK_CODE(Magic = 0);
        }

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

        private:

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

//-----------------------------------------------------------------------------
// insert: Insert tuples into set.
//-----------------------------------------------------------------------------

        int insert()
        {
                // Count number of tuples inserted:
                int tuple_no = 0;

                // Open generator for tuples:
                Cur1.open();

                // Insert tuples:
                while(Cur1.fetch()) {
                        tuple_no++;

                        int c1 = Cur1.c1();
                        bool ok = Set->insert(c1);
                        if(!ok) {
                                Cur1.close();
                                rtest_c::inserted_rows(tuple_no);
                                rtest_c::error_row_open();
                                rtest_c::error_row_int(c1);
                                rtest_c::error_row_close();
                                return tuple_no;
                        }
                }

                // Close cursor:
                Cur1.close();

                // Remember number of inserted rows:
                rtest_c::inserted_rows(tuple_no);

                // Ok:
                return 0;
        }

//-----------------------------------------------------------------------------
// lookup: Lookup all tuples that were inserted into the set.
//-----------------------------------------------------------------------------

        int lookup()
        {
                // Count number of tuples that were found:
                int tuple_no = 0;

                // Open generator for tuples:
                Cur1.open();

                // Lookup tuples:
                while(Cur1.fetch()) {
                        tuple_no++;

                        int c1 = Cur1.c1();
                        bool ok = Set->contains(c1);
                        if(!ok) {
                                Cur1.close();
                                rtest_c::error_row_open();
                                rtest_c::error_row_int(c1);
                                rtest_c::error_row_close();
                                return tuple_no;
                        }
                }

                // Close cursor:
                Cur1.close();

                // Ok:
                return 0;
        }


//-----------------------------------------------------------------------------
// Values of size measures for the set implementation:
//-----------------------------------------------------------------------------

        int size_value(relsize_t relsize) {
                return Set->size_value(relsize);
        }


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

#if     VER_DEBUG
        public:
        // Integrity check:
        str_t   check() const
        {
                // Check magic number:
                if(Magic != TEST_SET1_MAGIC)
                        return "wrong magic number";

                // Check superclass:
                str_t msg = rtest_c::check();
                if(msg)
                        return msg;

                // Ok:
                return 0;
        }


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

#if     VER_DUMP
        public:
        // Display data structure:
        virtual void dump(str_t headline = STR_NULL) const
        {
                // Headline:
                if(headline == STR_NULL)
                        headline =
                        "Test for sets with one int column (test_set1_c)";

                // Call dump method of superclass:
                rtest_c::dump(headline);
        }
#endif

//=============================================================================
// Private Object Members:
//=============================================================================

        private:

        // Set (Relation) to test:
        T Set;

        // ID of the test:
        int TestID;

        // Generator for tuples to insert:
        gen_cur1_c Cur1;

//=============================================================================
// Auxiliary Functions:
//=============================================================================

        private:

//-----------------------------------------------------------------------------
// rel1: Select tuple generator for initial insertion depending on test ID.
//-----------------------------------------------------------------------------

        int rel1(int test_id)
        {
                // Check parameter:
                CHECK(test_id >= 0 && test_id <= 4,
                        "test_set1_c::rel1: unknown test_id");

                switch(test_id) {
                        case 0:
                                // Small sequential relation:
                                return 0;
                        case 1:
                                // One million tuples, sequential:
                                return 1;
                        case 2:
                                // One million tuples, mixed sequences:
                                return 2;
                        case 3:
                                // 100 million tuples, mixed sequences:
                                return 3;
                        case 4:
                                // One billion tuples, mixed sequences:
                                return 4;
                        default:
                                // Invalid test id:
                                CHECK_IMPOSSIBLE("test_set1_c::rel1: bad id");
                                return 1;
                }
        }


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

};


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

#endif