tb_test_provider.hpp

#ifndef TurtleBrains_UnitTestProvider_hpp
#define TurtleBrains_UnitTestProvider_hpp

#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_defines.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_noncopyable.hpp>

#include <utility>
#include <vector>

namespace TurtleBrains
{
    namespace Core
    {
        namespace UnitTest
        {

            template<typename DataType, typename ResultType> class TestProvider
            {
            public:
                TestProvider(void) :
                    mIndex(0)
                {
                }

                void Push(const DataType& data, const ResultType& result)
                {
                    mProvidedData.push_back(DataResultPair(data, result));
                }

                bool Next(void)
                {
                    if (false == IsComplete())
                    {
                        ++mIndex;
                    }

                    return IsComplete();
                }

                bool IsComplete(void) const
                {
                    return (mIndex >= size());
                }

                size_t size(void) const
                {
                    return mProvidedData.size();
                }

                const DataType& Data(void) const
                {
                    return mProvidedData[mIndex].first;
                }

                const DataType& Data(const size_t atIndex) const
                {
                    return mProvidedData[atIndex].first;
                }

                const ResultType& Result(void) const
                {
                    return mProvidedData[mIndex].second;
                }

                const ResultType& Result(const size_t atIndex) const
                {
                    return mProvidedData[atIndex].second;
                }

            private:
                typedef std::pair<DataType, ResultType> DataResultPair;
                std::vector<DataResultPair> mProvidedData;
                size_t mIndex;
            };

        }; /* namespace UnitTest */
    }; /* namespace Core */
}; /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;

#endif /* TurtleBrains_UnitTestProvider_hpp */