1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
//: Allow tests to be written in mu files.
:(before "End Types")
struct scenario {
string name;
string dump_layer;
string to_run;
map<int, int> memory_expectations;
// End scenario Fields
};
:(before "End Globals")
vector<scenario> Scenarios;
//: How we check Scenarios.
:(before "End Tests")
time_t mu_time; time(&mu_time);
cerr << "\nMu tests: " << ctime(&mu_time);
for (size_t i = 0; i < Scenarios.size(); ++i) {
setup();
Trace_file = Scenarios[i].name;
START_TRACING_UNTIL_END_OF_SCOPE
if (!Scenarios[i].dump_layer.empty())
Trace_stream->dump_layer = Scenarios[i].dump_layer;
//? cout << Scenarios[i].to_run; //? 2
run(Scenarios[i].to_run);
//? cout << "after: " << Memory[1] << '\n'; //? 1
//? cout << "After:\n"; dump_memory(); //? 1
for (map<int, int>::iterator p = Scenarios[i].memory_expectations.begin();
p != Scenarios[i].memory_expectations.end();
++p) {
if (Memory[p->first] != p->second) {
cerr << Scenarios[i].name << ": Expected location " << p->first << " to contain " << p->second << " but saw " << Memory[p->first] << '\n';
Passed = false;
}
}
// End Scenario Checks
if (Passed) cerr << ".";
}
//: How we create Scenarios.
:(scenarios "parse_scenario")
:(scenario "parse_scenario_memory_expectation")
scenario foo [
run [
a <- b
]
memory should contain [
1 <- 0
]
]
+parse: scenario will run: a <- b
:(before "End Command Handlers")
else if (command == "scenario") {
//? cout << "AAA scenario\n"; //? 1
Scenarios.push_back(parse_scenario(in));
}
:(code)
scenario parse_scenario(istream& in) {
scenario x;
x.name = next_word(in);
trace("parse") << "reading scenario " << x.name;
skip_bracket(in, "'scenario' must begin with '['");
ostringstream buffer;
slurp_until_matching_bracket(in, buffer);
//? cout << "inner buffer: ^" << buffer.str() << "$\n"; //? 1
istringstream inner(buffer.str());
inner >> std::noskipws;
while (!inner.eof()) {
skip_whitespace_and_comments(inner);
string scenario_command = next_word(inner);
if (scenario_command.empty() && inner.eof()) break;
// Scenario Command Handlers
if (scenario_command == "run") {
handle_scenario_run_directive(inner, x);
}
else if (scenario_command == "memory") {
handle_scenario_memory_directive(inner, x);
}
else if (scenario_command == "dump") {
skip_whitespace_and_comments(inner);
x.dump_layer = next_word(inner);
}
// End Scenario Command Handlers
else {
raise << "unknown command in scenario: ^" << scenario_command << "$\n";
}
}
return x;
}
void handle_scenario_run_directive(istream& in, scenario& result) {
skip_bracket(in, "'run' inside scenario must begin with '['");
ostringstream buffer;
slurp_until_matching_bracket(in, buffer);
string trace_result = buffer.str(); // temporary copy
trace("parse") << "scenario will run: " << trim(trace_result);
//? cout << buffer.str() << '\n'; //? 1
result.to_run = "recipe test-"+result.name+" [" + buffer.str() + "]";
}
void handle_scenario_memory_directive(istream& in, scenario& out) {
if (next_word(in) != "should") {
raise << "'memory' directive inside scenario must continue 'memory should'\n";
}
if (next_word(in) != "contain") {
raise << "'memory' directive inside scenario must continue 'memory should contain'\n";
}
skip_bracket(in, "'memory' directive inside scenario must begin with 'memory should contain ['\n");
while (true) {
skip_whitespace_and_comments(in);
if (in.eof()) break;
//? cout << "a: " << in.peek() << '\n'; //? 1
if (in.peek() == ']') break;
int address = 0; in >> address;
//? cout << "address: " << address << '\n'; //? 2
//? cout << "b: " << in.peek() << '\n'; //? 1
skip_whitespace_and_comments(in);
//? cout << "c: " << in.peek() << '\n'; //? 1
string _assign; in >> _assign; assert(_assign == "<-");
skip_whitespace_and_comments(in);
int value = 0; in >> value;
out.memory_expectations[address] = value;
trace("parse") << "memory expectation: *" << address << " == " << value;
}
skip_whitespace(in);
assert(in.get() == ']');
}
void slurp_until_matching_bracket(istream& in, ostream& out) {
int brace_depth = 1; // just scanned '['
char c;
while (in >> c) {
if (c == '[') ++brace_depth;
if (c == ']') --brace_depth;
if (brace_depth == 0) break; // drop final ']'
out << c;
}
}
// for tests
void parse_scenario(const string& s) {
istringstream in(s);
in >> std::noskipws;
skip_whitespace_and_comments(in);
string _scenario = next_word(in);
//? cout << _scenario << '\n'; //? 1
assert(_scenario == "scenario");
parse_scenario(in);
}
string &trim(string &s) {
return ltrim(rtrim(s));
}
string <rim(string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(isspace))));
return s;
}
string &rtrim(string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(isspace))).base(), s.end());
return s;
}
:(scenarios run)
|