include/Tests/TestVectors.hpp

Go to the documentation of this file.

#ifndef hpp_CPP_TestVectors_CPP_hpp
#define hpp_CPP_TestVectors_CPP_hpp

// We need String from BString lib
#include "../Strings/BString.hpp"
// We need stack too
#include "../Tree/FIFO.hpp"
// We need by ref
#include "../Types/ByRef.hpp"

#ifdef _MSC_VER
// We don't care about the 255 name limit in debug symbols 
#pragma warning(disable:4786)
// There is a bug here with release build, as the compiler doesn't understand it should not inline the pointed method when taking the reference
#if !defined(DEBUG) && !defined(_DEBUG)
    #define RefConstU U
#else
    #define RefConstU const U &
#endif
#endif

namespace Test
{
    // We use String from BString
    using Bstrlib::String;
    struct Unit
    {
        String testName;
        virtual bool launchTest() = 0;
        virtual String getTestName(const String & str = "") const { return testName + str; }

        Unit(const String & name) : testName(name) {}
        virtual ~Unit() {}
    };

    template <typename T, typename U>
    class UnitImpl0 : public Unit
    {
    private:
        T & object;
        RefConstU  function;

    private:
        // The test method
        inline bool launchTest() { return (bool)(object.*function)();   }

    public:
        UnitImpl0(const String & name, T & obj, RefConstU func) : Unit(name), object(obj), function(func) {}
    };

    template <typename T, typename U>
    inline UnitImpl0<T, U> * MakeUnitTest(const String & name, T & object, const U & func) 
    {
        return new UnitImpl0<T, U>(name, object, func);
    }


    template <typename T, typename U, typename P1>
    class UnitImpl1 : public Unit
    {
    private:
        T & object;
        RefConstU function;
        const P1  param1;

    private:
        // The test method
        inline bool launchTest() { return (bool)(object.*function)(param1); }

    public:
        UnitImpl1(const String & name, T & obj, RefConstU func, const P1 & p1) : Unit(name), object(obj), function(func), param1(p1) {}
    };

    template <typename T, typename U, typename P1>
    inline UnitImpl1<T, U, P1> * MakeUnitTest(const String & name, T & object, const U & func, const P1 & p1) 
    {
        return new UnitImpl1<T, U, P1>(name, object, func, p1);
    }

    template <typename T, typename U, typename P1, typename P2>
    class UnitImpl2 : public Unit
    {
    private:
        T & object;
        RefConstU function;
        const P1  param1;
        const P2  param2;

    private:
        // The test method
        inline bool launchTest() { return (bool)(object.*function)(param1, param2); }

    public:
        UnitImpl2(const String & name, T & obj, RefConstU func, const P1 & p1, const P2 & p2) : Unit(name), object(obj), function(func), param1(p1), param2(p2) {}
    };

    template <typename T, typename U, typename P1, typename P2>
    inline UnitImpl2<T, U, P1, P2> * MakeUnitTest(const String & name, T & object, const U & func, const P1 & p1, const P2 & p2) 
    {
        return new UnitImpl2<T, U, P1, P2>(name, object, func, p1, p2);
    }

    template <typename T, typename U, typename P1, typename P2, typename P3>
    class UnitImpl3 : public Unit
    {
    private:
        T & object;
        RefConstU function;
        const P1  param1;
        const P2  param2;
        const P3  param3;

    private:
        // The test method
        inline bool launchTest() { return (bool)(object.*function)(param1, param2, param3); }

    public:
        UnitImpl3(const String & name, T & obj, RefConstU func, const P1 & p1, const P2 & p2, const P3 & p3) : Unit(name), object(obj), function(func), param1(p1), param2(p2), param3(p3) {}
    };

    template <typename T, typename U, typename P1, typename P2, typename P3>
    inline UnitImpl3<T, U, P1, P2, P3> * MakeUnitTest(const String & name, T & object, const U & func, const P1 & p1, const P2 & p2, const P3 & p3) 
    {
        return new UnitImpl3<T, U, P1, P2, P3>(name, object, func, p1, p2, p3);
    }

    template <typename T, typename U, typename P1, typename P2, typename P3, typename P4>
    class UnitImpl4 : public Unit
    {
    private:
        T & object;
        RefConstU function;
        const P1  param1;
        const P2  param2;
        const P3  param3;
        const P4  param4;

    private:
        // The test method
        inline bool launchTest() { return (bool)(object.*function)(param1, param2, param3, param4); }

    public:
        UnitImpl4(const String & name, T & obj, RefConstU func, const P1 & p1, const P2 & p2, const P3 & p3, const P4 & p4) : Unit(name), object(obj), function(func), param1(p1), param2(p2), param3(p3), param4(p4) {}
    };

    template <typename T, typename U, typename P1, typename P2, typename P3, typename P4>
    inline UnitImpl4<T, U, P1, P2, P3, P4> * MakeUnitTest(const String & name, T & object, const U & func, const P1 & p1, const P2 & p2, const P3 & p3, const P4 & p4) 
    {
        return new UnitImpl4<T, U, P1, P2, P3, P4>(name, object, func, p1, p2, p3, p4);
    }

    template <typename T, typename U, typename P1, typename P2, typename P3, typename P4, typename P5>
    class UnitImpl5 : public Unit
    {
    private:
        T & object;
        RefConstU function;
        const P1  param1;
        const P2  param2;
        const P3  param3;
        const P4  param4;
        const P5  param5;

    private:
        // The test method
        inline bool launchTest() { return (bool)(object.*function)(param1, param2, param3, param4, param5); }

    public:
        UnitImpl5(const String & name, T & obj, RefConstU func, const P1 & p1, const P2 & p2, const P3 & p3, const P4 & p4, const P5 & p5) : Unit(name), object(obj), function(func), param1(p1), param2(p2), param3(p3), param4(p4), param5(p5) {}
    };

    template <typename T, typename U, typename P1, typename P2, typename P3, typename P4, typename P5>
    inline UnitImpl5<T, U, P1, P2, P3, P4, P5> * MakeUnitTest(const String & name, T & object, const U & func, const P1 & p1, const P2 & p2, const P3 & p3, const P4 & p4, const P5 & p5) 
    {
        return new UnitImpl5<T, U, P1, P2, P3, P4, P5>(name, object, func, p1, p2, p3, p4, p5);
    }
#define MakeTestName(X) String(__FILE__) + "(" + String().Format("%d", __LINE__) + ") : " + String( X )
    

    class Vector
    {
    private:
        ::Stack::WithClone::FIFO< Unit > vectorList;
        int unitSuccessful;
        int totalUnits;

    public:
        inline bool addUnitToTest(Unit * unit) { vectorList.Push(unit); return true; }
        inline String & testLastInsertedVectors(String & result) 
        {
            Unit *  unit = 0;
            totalUnits += vectorList.getSize();
            while ((unit = vectorList.Pop()) != NULL)
            {
                bool bResult = false;
                try { bResult = unit->launchTest(); } catch(...) { bResult = false; }
                
                if (!bResult)   result += unit->getTestName("\t[FAILED]\n");
                else            { result += unit->getTestName("\t[  OK  ]\n"); unitSuccessful++; }
            }
            return result;
        }
        inline String testAllVectors(const String & previousResults = "") 
        {
            String result = previousResults;
            if (previousResults.getLength() == 0)   { unitSuccessful = 0; totalUnits = 0; }
            testLastInsertedVectors(result);

            result += String().Format("Tests finished : Successful tests %d/%d total\n", unitSuccessful, totalUnits);
            return result;
        }

        Vector() : unitSuccessful(0), totalUnits(0) {}
    };

    static bool OutputTestName()
    {
        return true;
    }

    struct LineDelimiter : public Unit
    {
        // The test method
        inline bool launchTest() { return true; }
        inline String getTestName(const String & = "") const { return testName + "\n"; }
        LineDelimiter(const String & name) : Unit(name) {}
    };

    inline LineDelimiter * MakeLineDelimiter(const String & name) { return new LineDelimiter(name); }

}


#endif

(C) An X-Ryl669 project 2007

This document describes Unlimited Zooming Interface source code. UZI stands for Unlimited Zooming Interface, and source code license is