Newer
Older
#ifndef MONAD_SHARED
#define MONAD_SHARED
#include "util.h"
#include "pipestream.h"
namespace monad_shared
{
struct Version
{
int32_t major_;
int32_t minor_;
int32_t patch_;
Version(int32_t maj, int32_t min, int32_t pat)
: major_(maj), minor_(min), patch_(pat)
{ }
#if 0
Version(const std::string & s)
{
size_t i = 0;
}
#endif
void print(std::ostream & out) const
{
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
}
};
inline std::ostream & operator<<(std::ostream & out, const Version & v)
{
v.print(out);
return out;
}
namespace versioninfo
{
extern const char * official_name;
extern const char * version_name;
extern const Version version_num;
extern const char * date;
}
void printInfo();
struct unit_test_input
{
typedef void (*function)(util::pipestream &);
private:
function func_;
const char * name_;
long timeout_;
int32_t points_;
bool is_valgrind_;
public:
unit_test_input(const char * _name,
unit_test_input::function _func,
int32_t _points,
long _timeout,
bool _is_valgrind)
: func_(_func),
name_(_name),
timeout_(_timeout),
points_(_points),
is_valgrind_(_is_valgrind) { }
void execute(util::pipestream & checkstream) const { func_(checkstream); }
const char * name() const { return name_; }
long timeout() const { return timeout_; }
int32_t points() const { return points_; }
bool is_valgrind() const { return is_valgrind_; }
};
struct unit_test_result : public unit_test_input
{
private:
std::string errormsg_;
std::string output_;
long time_;
int32_t valgrind_flags_;
public:
unit_test_result(const unit_test_input & _input,
const std::string & _errormsg,
const std::string & _output,
const long _time,
const int32_t _valgrind_flags)
: unit_test_input(_input),
errormsg_((_errormsg != "") ? _errormsg : "Unexpectedly Aborted"),
output_(_output),
time_(_time),
valgrind_flags_(_valgrind_flags) { }
const std::string & errormsg() const { return errormsg_; }
const std::string & output() const { return output_; }
long time() const { return time_; }
int32_t valgrind_flags() const { return valgrind_flags_; }
bool passed() const { return errormsg_ == pass_string; }
bool failed() const { return !passed(); }
int32_t points_scored() const { return passed() ? points() : 0; }
// Static class data
static const char * pass_string;
static bool _failed(const unit_test_result & obj) { return obj.failed(); }
};
namespace output
{
void set_error_message();
void header(const std::string & title);
void total_score(int32_t score, int32_t outof);
void warning(const std::string & message);
void testname(const unit_test_input & curr_test, int32_t max_testname_len, int32_t max_points_len);
void detailed_info(const unit_test_result & curr_test);
std::string passed_string();
std::string failed_string();
} // namespace output
}
#endif // MONAD_SHARED