MockObjects.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_FRAMEWORK_UNITTESTS_MOCKOBJECTS_H
#define SURGSIM_FRAMEWORK_UNITTESTS_MOCKOBJECTS_H

#include <memory>

#include "SurgSim/Framework/Assert.h"
#include "SurgSim/Framework/BasicThread.h"
#include "SurgSim/Framework/Behavior.h"
#include "SurgSim/Framework/Component.h"
#include "SurgSim/Framework/ComponentManager.h"
#include "SurgSim/Framework/Representation.h"
#include "SurgSim/Framework/Runtime.h"
#include "SurgSim/Framework/SamplingMetricBase.h"
#include "SurgSim/Framework/Scene.h"
#include "SurgSim/Framework/SceneElement.h"

class MockSceneElement : public SurgSim::Framework::SceneElement
{
public:
    explicit MockSceneElement(const std::string& name = "MockSceneElement") :
        SceneElement(name),
        didInit(false),
        didUpdate(false),
        didLateUpdate(false),
        didFixedUpdate(false)
    {
        m_localRuntime = std::make_shared<SurgSim::Framework::Runtime>();
        setRuntime(m_localRuntime);

        m_localScene = m_localRuntime->getScene();
        setScene(m_localScene);
    }

    virtual void update(double dt)
    {
        didUpdate = true;
    }
    virtual void lateUpdate(double dt)
    {
        didLateUpdate = true;
    }
    virtual void fixedRateUpdate(double dt)
    {
        didFixedUpdate = true;
    }

    virtual bool doInitialize()
    {
        didInit = true;
        return didInit;
    };

    bool didInit;
    bool didUpdate;
    bool didLateUpdate;
    bool didFixedUpdate;
private:
    std::shared_ptr<SurgSim::Framework::Runtime> m_localRuntime;
    std::shared_ptr<SurgSim::Framework::Scene> m_localScene;

};

class MockThread : public SurgSim::Framework::BasicThread
{
public:
    explicit MockThread(int runCount = -1) :
        count(runCount),
        totalTime(0.0),
        didBeforeStop(false),
        runIndefinetly(false),
        didInitialize(false),
        didStartUp(false)
    {
    }

    virtual ~MockThread()
    {
    }

    int count;
    double totalTime;

    bool didBeforeStop;
    bool runIndefinetly;
    bool didInitialize;
    bool didStartUp;

private:
    virtual bool doInitialize()
    {
        didInitialize = true;
        return true;
    };

    virtual bool doStartUp()
    {
        didStartUp = true;
        return true;
    };

    virtual bool doUpdate(double dt)
    {
        --count;
        totalTime += dt;

        return count != 0;
    };

    virtual void doBeforeStop()
    {
        didBeforeStop = true;
    };
};


class MockComponent : public SurgSim::Framework::Component
{
public:
    explicit MockComponent(const std::string& name, bool succeedInit = true, bool succeedWakeUp = true);

    SURGSIM_CLASSNAME(MockComponent);

    virtual ~MockComponent();

    bool doInitialize() override;
    bool doWakeUp() override;
    void doRetire() override;

    bool getSucceedWithInit() const;
    void setSucceedWithInit(bool val);

    bool getSucceedWithWakeUp() const;
    void setSucceedWithWakeUp(bool val);

    void eventCallback(const SurgSim::Framework::Messenger::Event& event);

    bool succeedWithInit;
    bool succeedWithWakeUp;
    bool didWakeUp;
    bool didInit;
    bool didRetire;
    bool didCallback;
};

class MockBehavior : public SurgSim::Framework::Behavior
{
public:
    explicit MockBehavior(const std::string& name, bool succeedInit = true, bool succeedWakeUp = true) :
        Behavior(name),
        succeedWithInit(succeedInit),
        succeedWithWakeUp(succeedWakeUp),
        updateCount(0)
    {
    }
    virtual ~MockBehavior()
    {
    }

    virtual bool doInitialize()
    {
        return succeedWithInit;
    }

    virtual bool doWakeUp()
    {
        return succeedWithWakeUp;
    }

    virtual void update(double dt)
    {
        updateCount++;
    }

    bool succeedWithInit;
    bool succeedWithWakeUp;
    int updateCount;
};


class MockManager : public SurgSim::Framework::ComponentManager
{
public:
    explicit MockManager(bool succeedInit = true, bool succeedStartup = true) :
        succeedInit(succeedInit),
        succeedStartup(succeedStartup),
        didInitialize(false),
        didStartUp(false),
        didBeforeStop(false),
        count(0)
    {
    }

    virtual ~MockManager()
    {
    }

    int getType() const override
    {
        return SurgSim::Framework::MANAGER_TYPE_NONE;
    }

    const std::vector<std::shared_ptr<MockComponent>>& getComponents()
    {
        return m_components;
    }

    bool testTryAddComponent(const std::shared_ptr<SurgSim::Framework::Component>& component)
    {
        return executeAdditions(component);
    }

    bool testTryRemoveComponent(const std::shared_ptr<SurgSim::Framework::Component>& component)
    {
        return executeRemovals(component);
    }

    void testProcessComponents()
    {
        processComponents();
    }

    bool succeedInit;
    bool succeedStartup;
    bool didInitialize;
    bool didStartUp;
    bool didBeforeStop;
    int count;

private:
    virtual bool doInitialize()
    {
        didInitialize = true;
        return succeedInit;
    };
    virtual bool doStartUp()
    {
        didStartUp = true;
        return succeedStartup;
    };
    virtual bool doUpdate(double dt)
    {
        ++count;
        processComponents();
        return true;
    };

    virtual void doBeforeStop()
    {
        didBeforeStop = true;
        retireComponents(m_components);
        ComponentManager::doBeforeStop();
    }

    bool executeAdditions(const std::shared_ptr<SurgSim::Framework::Component>& component) override
    {
        return tryAddComponent(component, &m_components) != nullptr;
    }

    bool executeRemovals(const std::shared_ptr<SurgSim::Framework::Component>& component) override
    {
        return tryRemoveComponent(component, &m_components);
    }


    std::vector<std::shared_ptr<MockComponent>> m_components;


};

class MockRepresentation : public SurgSim::Framework::Representation
{
public:
    explicit MockRepresentation(const std::string& name) : SurgSim::Framework::Representation(name),
        m_didInit(false),
        m_didWakeUp(false)
    {
    }

    SURGSIM_CLASSNAME(MockRepresentation);

    bool didInit() const
    {
        return m_didInit;
    }

    bool didWakeUp() const
    {
        return m_didWakeUp;
    }

private:
    bool m_didInit;
    bool m_didWakeUp;

    virtual bool doInitialize()
    {
        m_didInit = true;
        return true;
    }

    virtual bool doWakeUp()
    {
        m_didWakeUp = true;
        return true;
    }
};


class MockSamplingMetric : public SurgSim::Framework::SamplingMetricBase
{
public:
    explicit MockSamplingMetric(const std::string& name,
                                bool ableToMeasure = true,
                                double initialMeasurement = 0.0) :
        SurgSim::Framework::SamplingMetricBase(name),
        m_canMeasure(ableToMeasure),
        m_measurement(initialMeasurement)
    {
    }

    SURGSIM_CLASSNAME(MockSamplingMetric);

    typedef SurgSim::Framework::SamplingMetricBase::MeasurementEntryType MeasurementEntryType;

    typedef SurgSim::Framework::SamplingMetricBase::MeasurementsType MeasurementsType;

private:
    bool m_canMeasure;

    double m_measurement;

    bool canMeasure(double dt)
    {
        return m_canMeasure;
    }

    double performMeasurement(double dt)
    {
        return ++m_measurement;
    }
};

#endif  // SURGSIM_FRAMEWORK_UNITTESTS_MOCKOBJECTS_H