TestCase.h

#ifndef ROSE_BinaryAnalysis_Concolic_TestCase_H
#define ROSE_BinaryAnalysis_Concolic_TestCase_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/SymbolicExpression.h>
 
#include <Sawyer/Optional.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>
 
#include <string>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
 
typedef std::pair<std::string /*name*/, std::string /*value*/> EnvValue;
 
class TestCase: public Sawyer::SharedObject, public Sawyer::SharedFromThis<TestCase> {
public:
    typedef Sawyer::SharedPointer<TestCase> Ptr;
 
private:
    mutable SAWYER_THREAD_TRAITS::Mutex mutex_;         // protects the following data members
    std::string name_;                                  // name for debugging
    std::string timestamp_;                             // time of creation
    std::string executor_;                              // name of execution environment
    SpecimenPtr specimen_;                              // the thing to run
    std::vector<std::string> args_;                     // command line arguments
    std::vector<EnvValue> env_;                         // environment variables
    Sawyer::Optional<size_t> concolicResult_;           // non-empty if concolically tested
    Sawyer::Optional<double> concreteRank_;             // rank after testing
    bool concreteIsInteresting_;                        // concrete results present and interesting?
    TestCaseId parent_;                                 // test case from which this one was created, if any
    std::vector<SymbolicExpression::Ptr> assertions_;   // assertions for the SMT solver
 
protected:
    TestCase();
 
public:
    ~TestCase();
 
    static Ptr instance() {
        return Ptr(new TestCase);
    }
 
    static Ptr instance(const SpecimenPtr &specimen);
 
    TestCaseId parent() const;
    void parent(TestCaseId);
    std::string name() const;                           // value return is intentional for thread safety
    void name(const std::string&);
    std::string printableName(const DatabasePtr &db = DatabasePtr());
 
    void toYaml(std::ostream&, const DatabasePtr&, std::string prefix, ShowEvents, ShowAssertions);
 
    std::string timestamp() const;
    void timestamp(const std::string&);
    SpecimenPtr specimen() const;
    void specimen(const SpecimenPtr&);
    std::vector<std::string> args() const;
    void args(std::vector<std::string> arguments);
    std::vector<EnvValue> env() const;
    void env(std::vector<EnvValue> envvars);
    Sawyer::Optional<size_t> concolicResult() const {
        return concolicResult_;
    }
    void concolicResult(const Sawyer::Optional<size_t> &x) {
        concolicResult_ = x;
    }
    bool hasConcolicTest() const;
 
    Sawyer::Optional<double> concreteRank() const;
    void concreteRank(Sawyer::Optional<double> val);
    bool concreteIsInteresting() const;
    void concreteIsInteresting(bool);
    bool hasConcreteTest() const;
 
    const std::string& executor() const {
        return executor_;
    }
    void executor(const std::string &x) {
        executor_ = x;
    }
    const std::vector<SymbolicExpression::Ptr>& assertions() const {
        return assertions_;
    }
    std::vector<SymbolicExpression::Ptr>& assertions() {
        return assertions_;
    }
    void assertions(const std::vector<SymbolicExpression::Ptr> &v) {
        assertions_ = v;
    }
    // We'll need to add additional information about how to run the specimen:
    //   3. Auxilliary vector (auxv)
    //   4. System calls that provide input (e.g., virtual file system, network, etc.)
    // Some of this information might need to be separated into subclasses that support different architectures since the
    // info for testing a Linux ELF executable is different from a Windows PE executable, which is different from how one
    // would run firmware.
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif