ExecutionManager.h

#ifndef ROSE_BinaryAnalysis_Concolic_ExecutionManager_H
#define ROSE_BinaryAnalysis_Concolic_ExecutionManager_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/Settings.h>

#include <Rose/Yaml.h>

#include <boost/noncopyable.hpp>
#include <Sawyer/SharedObject.h>
#include <vector>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

class ExecutionManager: boost::noncopyable, public Sawyer::SharedObject {
    // Types
public:
    using Ptr = Sawyer::SharedPointer<ExecutionManager>;

    // Data members
private:
    DatabasePtr database_;
    ConcolicExecutorSettings concolicExecutorSettings_;
    const Yaml::Node config_;

    // Construction and destruction
public:
    virtual ~ExecutionManager();
protected:
    explicit ExecutionManager(const DatabasePtr&);
    ExecutionManager(const DatabasePtr&, const ConcolicExecutorSettings&, const Yaml::Node&);

public:
    static Ptr instance(const ConcolicExecutorSettings&, const Yaml::Node&);

    static Ptr open(const std::string &databaseUrl);

    static Ptr create(const std::string &databaseUrl, const boost::filesystem::path &executableName,
                      const std::vector<std::string> &arguments, const std::string &testSuiteName = "");

    // Properties
public:
    const ConcolicExecutorSettings& concolicExecutorSettings() const;
    ConcolicExecutorSettings& concolicExecutorSettings();
    void concolicExecutorSettings(const ConcolicExecutorSettings&);
    DatabasePtr database() const;

    std::vector<TestSuiteId> testSuites() const;

    TestSuitePtr testSuite() const;
    void testSuite(const TestSuitePtr&);
    // Actions
public:
    virtual std::vector<TestCaseId> pendingConcreteResults(size_t n = UNLIMITED);
    TestCaseId pendingConcreteResult() /*final*/;
    virtual void insertConcreteResults(const TestCasePtr&, const ConcreteResultPtr&);

    virtual std::vector<TestCaseId> pendingConcolicResults(size_t n = UNLIMITED);
    TestCaseId pendingConcolicResult() /*final*/;
    virtual void insertConcolicResults(const TestCasePtr &original, const std::vector<TestCasePtr> &newCases);

    virtual bool isFinished() const;

    virtual void run();
};

} // namespace
} // namespace
} // namespace

#endif
#endif