TestFixture.h

#pragma once


#include <celero/Export.h>
#include <celero/Timer.h>

#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <string>
#include <vector>

// This must be included last.
#include <celero/ThreadLocal.h>

namespace celero
{
    class Benchmark;
    class UserDefinedMeasurement;

    class CELERO_EXPORT TestFixture
    {
    public:
        TestFixture();

        virtual ~TestFixture();

        enum class Constants : int64_t
        {
#ifdef _MSC_VER
#if(_MSC_VER < 1900)
            NoProblemSpaceValue = -9223372036854775807
#else
            NoProblemSpaceValue = std::numeric_limits<int64_t>::min()
#endif
#else
            NoProblemSpaceValue = std::numeric_limits<int64_t>::min()
#endif
        };

        class ExperimentValue
        {
        public:
            ExperimentValue() = default;
            ExperimentValue(int64_t v) : Value(v){};
            ExperimentValue(int64_t v, int64_t i) : Value(v), Iterations(i){};

            virtual ~ExperimentValue() = default;

            int64_t Value{0};

            int64_t Iterations{0};
        };

        virtual std::vector<std::shared_ptr<celero::TestFixture::ExperimentValue>> getExperimentValues() const
        {
            return std::vector<std::shared_ptr<celero::TestFixture::ExperimentValue>>();
        };

        virtual double getExperimentValueResultScale() const
        {
            return 1.0;
        };

        virtual void onExperimentStart(const celero::TestFixture::ExperimentValue* const x);

        virtual void onExperimentEnd();

        virtual void setUp(const celero::TestFixture::ExperimentValue* const x);

        void setExperimentTime(uint64_t x);

        uint64_t getExperimentTime() const;

        void setExperimentIterations(uint64_t x);

        uint64_t getExperimentIterations() const;

        virtual void tearDown();

        virtual uint64_t run(uint64_t threads, uint64_t iterations, const celero::TestFixture::ExperimentValue* const experimentValue);

        virtual std::vector<std::shared_ptr<UserDefinedMeasurement>> getUserDefinedMeasurements() const;

        std::vector<std::string> getUserDefinedMeasurementNames() const;

    protected:
        virtual void UserBenchmark();

        virtual uint64_t HardCodedMeasurement() const;

    private:
        uint64_t experimentIterations{0};
        uint64_t experimentTime{0};
    };
} // namespace celero