rtest.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    rtest.h
// Purpose:     Superclass for Standard Tests of Relation-like Data Structures
// Last Change: 04.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 RTEST_INCLUDED
#define RTEST_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 REL_INCLUDED
#include "../rel/rel.h"
#endif


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

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

static const long RTEST_MAGIC = 0x5254450AL;    // 'RTE\n'

//-----------------------------------------------------------------------------
// RTEST_ROW_SIZE: Size of the string buffer for the problematic row.
//-----------------------------------------------------------------------------

static const int RTEST_ROW_SIZE = 80;


//=============================================================================
// Class Declaration:
//=============================================================================

class rtest_c {
        public:

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

        // Constructor:
        rtest_c(rel_t rel);

        // Destructor:
        ~rtest_c();

//-----------------------------------------------------------------------------
// Abstract Methods Required by this Class:
//-----------------------------------------------------------------------------

        virtual int insert() = 0;

        virtual int lookup() = 0;


        virtual int size_value(relsize_t relsize) = 0;


//-----------------------------------------------------------------------------
// Methods for accessing attributes (basic test data):
//-----------------------------------------------------------------------------

        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        rel_t rel() {

                // Check this object:
                CHECK_VALID("rtest_c::rel");

                // Return number of bound arguments:
                return Rel;
        }


        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        int num_rows() {

                // Check this object:
                CHECK_VALID("rtest_c::num_rows");

                // Return number of inserted rows:
                return NumRows;
        }


        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        str_t error_row() {

                // Check this object:
                CHECK_VALID("rtest_c::error_row");

                // There must be an error if this function is called:
                CHECK(ErrorRow[0] != '\0',
                                "rtest_c::error_row: No error detected");

                // Return row at which the error was detected:
                return ErrorRow;
        }


//-----------------------------------------------------------------------------
// Methods to be called by subclasses to store data in this object:
//-----------------------------------------------------------------------------

        protected:

        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        void inserted_rows(int n) {

                // Check this object:
                CHECK_VALID("rtest_c::inserted_rows");

                // Check parameter:
                CHECK(n >= 0,
                        "rtest_c::inserted_rows: n must be non-negative");

                // Increase number of rows:
                NumRows += n;
        }

        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        void error_row_open() {

                // Check this object:
                CHECK_VALID("rtest_c::error_row_open");

                // Initialize string buffer attributes:
                ErrorRowPtr  = ErrorRow;
                ErrorRowFree = RTEST_ROW_SIZE - 1;
                ErrorRowCol  = 0;

                // Write opening paranthesis:
                if(ErrorRowFree >= 1) {
                        *ErrorRowPtr++ = '[';
                        ErrorRowFree--;
                }

                // Ensure that string is always null-terminated:
                *ErrorRowPtr = '\0';
        }

        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        void error_row_int(int val) {

                // Check this object:
                CHECK_VALID("rtest_c::error_row_int");

                // If this is not the first column, write separator:
                if(ErrorRowCol > 0 && ErrorRowFree >= 2) {
                        *ErrorRowPtr++ = ',';
                        ErrorRowFree--;
                        *ErrorRowPtr++ = ' ';
                        ErrorRowFree--;
                }

                // write integer value:
                int chars = str_int(ErrorRowPtr, ErrorRowFree, val);
                ErrorRowPtr += chars;
                ErrorRowFree -= chars;
                ErrorRowCol++;

                // Ensure that string is always null-terminated:
                *ErrorRowPtr = '\0';
        }

        //---------------------------------------------------------------------
        //---------------------------------------------------------------------

        void error_row_close() {

                // Check this object:
                CHECK_VALID("rtest_c::error_row_close");

                // Write closing paranthesis:
                if(ErrorRowFree >= 1) {
                        *ErrorRowPtr++ = ']';
                        ErrorRowFree--;
                }

                // Ensure that string is always null-terminated:
                *ErrorRowPtr = '\0';
        }

//-----------------------------------------------------------------------------
// 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 "RTEST_MAGIC".
#endif

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

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

        private:

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


//-----------------------------------------------------------------------------
// Attributes:
//-----------------------------------------------------------------------------

        private:

        // Relation to be tested:
        rel_t Rel;

        // Number of rows that were successfully inserted (relation size):
        int NumRows;

        // Row, for which an operation failed (if an error was detected):
        char ErrorRow[RTEST_ROW_SIZE];

        // Pointer to next free place in the buffer:
        char *ErrorRowPtr;

        // Number of free places in the buffer (- 1 for terminating '\0'):
        int ErrorRowFree;

        // Number of column values already in the buffer:
        int ErrorRowCol;

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

};

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

typedef rtest_c *rtest_t;

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

#define RTEST_NULL (static_cast<rtest_t>(0))

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

#endif