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