libgrading.h

Go to the documentation of this file.

#ifndef LIBGRADING_H
#define LIBGRADING_H

#include <functional>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>


namespace grading {


class CheckResult
{
    public:
    CheckResult();
    CheckResult(std::string message);
    CheckResult(std::string exected, std::string actual);

    CheckResult(const CheckResult&) = delete;
    CheckResult(CheckResult&&);

    ~CheckResult();

    CheckResult& operator << (const std::vector<std::string>&);

    template<class T>
    CheckResult& operator << (const T& x)
    {
        message_ << x;
        return *this;
    }

    bool error() const { return reportError_; }
    void cancel() { reportError_ = false; }

    std::string expected() const { return expected_; }
    std::string actual() const { return actual_; }
    std::string message() const { return message_.str(); }

    private:
    bool reportError_;

    const std::string expected_;
    const std::string actual_;

    std::ostringstream message_;
};

CheckResult operator && (CheckResult&&, CheckResult&&);

CheckResult operator && (CheckResult&&, CheckResult&);

CheckResult operator || (CheckResult&&, CheckResult&&);

CheckResult operator || (CheckResult&&, CheckResult&);


//
// Checks for tests:
//

CheckResult Check(bool, std::string description);

CheckResult CheckInt(int expected, int actual);

CheckResult CheckFloat(double exp, double act, double tolerance = 0.000001);

CheckResult CheckString(std::string expected, std::string actual,
                        size_t maxEditDistance = 0);


enum class TestResult : char
{
    Pass,          
    Fail,          
    Segfault,      
    Timeout,       
    OtherError     
};

std::ostream& operator << (std::ostream&, TestResult);


class SharedMemory
{
    public:
    virtual ~SharedMemory() {}

    virtual void* rawPointer() const = 0;
};


std::unique_ptr<SharedMemory> MapSharedData(size_t size);


TestResult RunTest(std::function<TestResult ()> test,
                   std::string name = "<unnamed test>",
                   time_t timeout = 0,
                   std::ostream& errorStream = std::cerr);


template<class T>
TestResult RunTest(std::function<TestResult (T&)> test, T& output,
                   std::string name = "<unnamed test>",
                   time_t timeout = 0,
                   std::ostream& errorStream = std::cerr)
{
    std::unique_ptr<SharedMemory> mem(MapSharedData(sizeof(T)));
    T *testOutput = static_cast<T*>(mem->rawPointer());

    TestResult result =
        RunTest([&]() { return test(*testOutput); }, name,
                timeout, errorStream);

    output = *testOutput;
    return result;
}


template<class Expectation, class Output>
TestResult RunTest(std::function<TestResult (const Expectation&, Output&)> t,
                   const Expectation& expect, Output& output,
                   std::string name = "<unnamed test>", time_t timeout = 0,
                   std::ostream& errorStream = std::cerr)
{
    using std::placeholders::_1;
    return RunTest<Output>(
        std::bind(t, expect, _1), output, name, timeout, errorStream);
}

} // namespace grading

#endif