1 //: Mu scenarios. This will get long, but these are the tests we want to
  2 //: support in this layer.
  3 
  4 //: We avoid raw numeric locations in Mu -- except in scenarios, where they're
  5 //: handy to check the values of specific variables
  6 :(scenarios run_mu_scenario)
  7 :(scenario scenario_block)
  8 scenario foo [
  9   run [
 10     1:num <- copy 13
 11   ]
 12   memory-should-contain [
 13     1 <- 13
 14   ]
 15 ]
 16 # checks are inside scenario
 17 
 18 :(scenario scenario_multiple_blocks)
 19 scenario foo [
 20   run [
 21     1:num <- copy 13
 22   ]
 23   memory-should-contain [
 24     1 <- 13
 25   ]
 26   run [
 27     2:num <- copy 13
 28   ]
 29   memory-should-contain [
 30     1 <- 13
 31     2 <- 13
 32   ]
 33 ]
 34 # checks are inside scenario
 35 
 36 :(scenario scenario_check_memory_and_trace)
 37 scenario foo [
 38   run [
 39     1:num <- copy 13
 40     trace 1, [a], [a b c]
 41   ]
 42   memory-should-contain [
 43     1 <- 13
 44   ]
 45   trace-should-contain [
 46     a: a b c
 47   ]
 48   trace-should-not-contain [
 49     a: x y z
 50   ]
 51 ]
 52 # checks are inside scenario
 53 
 54 //:: Core data structure
 55 
 56 :(before "End Types")
 57 struct scenario {
 58   string name;
 59   string to_run;
 60   void clear() {
 61     name.clear();
 62     to_run.clear();
 63   }
 64 };
 65 
 66 :(before "End Globals")
 67 vector<scenario> Scenarios;
 68 
 69 //:: Parse the 'scenario' form.
 70 //: Simply store the text of the scenario.
 71 
 72 :(before "End Command Handlers")
 73 else if (command == "scenario") {
 74   scenario result = parse_scenario(in);
 75   if (!result.name.empty())
 76     Scenarios.push_back(result);
 77 }
 78 else if (command == "pending-scenario") {
 79   // for temporary use only
 80   parse_scenario(in);  // discard
 81 }
 82 
 83 :(code)
 84 scenario parse_scenario(istream& in) {
 85   scenario result;
 86   result.name = next_word(in);
 87   if (result.name.empty()) {
 88     assert(!has_data(in));
 89     raise << "incomplete scenario at end of file\n" << end();
 90     return result;
 91   }
 92   skip_whitespace_and_comments(in);
 93   if (in.peek() != '[') {
 94     raise << "Expected '[' after scenario '" << result.name << "'\n" << end();
 95     exit(0);
 96   }
 97   // scenarios are take special 'code' strings so we need to ignore brackets
 98   // inside comments
 99   result.to_run = slurp_quoted(in);
100   // delete [] delimiters
101   if (!starts_with(result.to_run, "[")) {
102     raise << "scenario " << result.name << " should start with '['\n" << end();
103     result.clear();
104     return result;
105   }
106   result.to_run.erase(0, 1);
107   if (result.to_run.at(SIZE(result.to_run)-1) != ']') {
108     raise << "scenario " << result.name << " has an unbalanced '['\n" << end();
109     result.clear();
110     return result;
111   }
112   result.to_run.erase(SIZE(result.to_run)-1);
113   return result;
114 }
115 
116 :(scenario read_scenario_with_bracket_in_comment)
117 scenario foo [
118   # ']' in comment
119   1:num <- copy 0
120 ]
121 +run: {1: "number"} <- copy {0: "literal"}
122 
123 :(scenario read_scenario_with_bracket_in_comment_in_nested_string)
124 scenario foo [
125   1:text <- new [# not a comment]
126 ]
127 +run: {1: ("address" "array" "character")} <- new {"# not a comment": "literal-string"}
128 
129 //:: Run scenarios when we run './mu test'.
130 //: Treat the text of the scenario as a regular series of instructions.
131 
132 :(before "End Globals")
133 int Num_core_mu_scenarios = 0;
134 :(after "Check For .mu Files")
135 Num_core_mu_scenarios = SIZE(Scenarios);
136 :(before "End Tests")
137 Hide_missing_default_space_errors = false;
138 if (Num_core_mu_scenarios > 0) {
139   time(&t);
140   cerr << "Mu tests: " << ctime(&t);
141   for (int i = 0;  i < Num_core_mu_scenarios;  ++i) {
142 //?     cerr << '\n' << i << ": " << Scenarios.at(i).name;
143     run_mu_scenario(Scenarios.at(i));
144     if (Passed) cerr << ".";
145     else ++Num_failures;
146   }
147   cerr << "\n";
148 }
149 run_app_scenarios:
150 if (Num_core_mu_scenarios != SIZE(Scenarios)) {
151   time(&t);
152   cerr << "App tests: " << ctime(&t);
153   for (int i = Num_core_mu_scenarios;  i < SIZE(Scenarios);  ++i) {
154 //?     cerr << '\n' << i << ": " << Scenarios.at(i).name;
155     run_mu_scenario(Scenarios.at(i));
156     if (Passed) cerr << ".";
157     else ++Num_failures;
158   }
159   cerr << "\n";
160 }
161 
162 //: For faster debugging, support running tests for just the Mu app(s) we are
163 //: loading.
164 :(before "End Globals")
165 bool Test_only_app = false;
166 :(before "End Commandline Options(*arg)")
167 else if (is_equal(*arg, "--test-only-app")) {
168   Test_only_app = true;
169 }
170 :(after "End Test Run Initialization")
171 if (Test_only_app && Num_core_mu_scenarios < SIZE(Scenarios)) {
172   goto run_app_scenarios;
173 }
174 
175 //: Convenience: run a single named scenario.
176 :(after "Test Runs")
177 for (int i = 0;  i < SIZE(Scenarios);  ++i) {
178   if (Scenarios.at(i).name == argv[argc-1]) {
179     if (Start_tracing) {
180       Trace_stream = new trace_stream;
181       Save_trace = true;
182     }
183     run_mu_scenario(Scenarios.at(i));
184     if (Passed) cerr << ".\n";
185     return 0;
186   }
187 }
188 
189 :(before "End Globals")
190 // this isn't a constant, just a global of type const*
191 const scenario* Current_scenario = NULL;
192 :(code)
193 void run_mu_scenario(const scenario& s) {
194   Current_scenario = &s;
195   bool not_already_inside_test = !Trace_stream;
196 //?   cerr << s.name << '\n';
197   if (not_already_inside_test) {
198     Trace_stream = new trace_stream;
199     setup();
200   }
201   vector<recipe_ordinal> tmp = load("recipe scenario_"+s.name+" [ "+s.to_run+" ]");
202   mark_autogenerated(tmp.at(0));
203   bind_special_scenario_names(tmp.at(0));
204   transform_all();
205   if (!trace_contains_errors())
206     run(tmp.front());
207   // End Mu Test Teardown
208   if (!Hide_errors && trace_contains_errors() && !Scenario_testing_scenario)
209     Passed = false;
210   if (not_already_inside_test && Trace_stream) {
211     teardown();
212     if (Save_trace) {
213       ofstream fout("last_trace");
214       fout << Trace_stream->readable_contents("");
215       fout.close();
216     }
217     delete Trace_stream;
218     Trace_stream = NULL;
219   }
220   Current_scenario = NULL;
221 }
222 
223 //: Permit numeric locations to be accessed in scenarios.
224 :(before "End check_default_space Special-cases")
225 // user code should never create recipes with underscores in their names
226 if (caller.name.find("scenario_") == 0) return;  // skip Mu scenarios which will use raw memory locations
227 if (caller.name.find("run_") == 0) return;  // skip calls to 'run', which should be in scenarios and will also use raw memory locations
228 
229 //: Some variables for fake resources always get special /raw addresses in scenarios.
230 
231 :(code)
232 // Should contain everything passed by is_special_name but failed by is_disqualified.
233 void bind_special_scenario_names(const recipe_ordinal r) {
234   // Special Scenario Variable Names(r)
235   // End Special Scenario Variable Names(r)
236 }
237 :(before "Done Placing Ingredient(ingredient, inst, caller)")
238 maybe_make_raw(ingredient, caller);
239 :(before "Done Placing Product(product, inst, caller)")
240 maybe_make_raw(product, caller);
241 :(code)
242 void maybe_make_raw(reagent& r, const recipe& caller) {
243   if (!is_special_name(r.name)) return;
244   if (starts_with(caller.name, "scenario_"))
245     r.properties.push_back(pair<string, string_tree*>("raw", NULL));
246   // End maybe_make_raw
247 }
248 
249 //: Test.
250 :(before "End is_special_name Special-cases")
251 if (s == "__maybe_make_raw_test__") return true;
252 :(before "End Special Scenario Variable Names(r)")
253 //: ugly: we only need this for this one test, but need to define it for all time
254 Name[r]["__maybe_make_raw_test__"] = Reserved_for_tests-1;
255 :(code)
256 void test_maybe_make_raw() {
257   // check that scenarios can use local-scope and special variables together
258   vector<recipe_ordinal> tmp = load(
259       "def scenario_foo [\n"
260       "  local-scope\n"
261       "  __maybe_make_raw_test__:num <- copy 34\n"
262       "]\n");
263   mark_autogenerated(tmp.at(0));
264   bind_special_scenario_names(tmp.at(0));
265   transform_all();
266   run(tmp.at(0));
267   CHECK_TRACE_DOESNT_CONTAIN_ERRORS();
268 }
269 
270 //: Watch out for redefinitions of scenario routines. We should never ever be
271 //: doing that, regardless of anything else.
272 :(scenarios run)
273 :(scenario forbid_redefining_scenario_even_if_forced)
274 % Hide_errors = true;
275 % Disable_redefine_checks = true;
276 def scenario-foo [
277   1:num <- copy 34
278 ]
279 def scenario-foo [
280   1:num <- copy 35
281 ]
282 +error: redefining recipe scenario-foo
283 
284 :(scenario scenario_containing_parse_error)
285 % Hide_errors = true;
286 scenario foo [
287   memory-should-contain [
288     1 <- 0
289   # missing ']'
290 ]
291 # no crash
292 
293 :(scenario scenario_containing_transform_error)
294 % Hide_errors = true;
295 def main [
296   local-scope
297   add x, 1
298 ]
299 # no crash
300 
301 :(after "bool should_check_for_redefine(const string& recipe_name)")
302   if (recipe_name.find("scenario-") == 0) return true;
303 
304 //:: The special instructions we want to support inside scenarios.
305 //: These are easy to support in an interpreter, but will require more work
306 //: when we eventually build a compiler.
307 
308 //: 'run' is a purely lexical convenience to separate the code actually being
309 //: tested from any setup or teardown
310 
311 :(scenario run)
312 def main [
313   run [
314     1:num <- copy 13
315   ]
316 ]
317 +mem: storing 13 in location 1
318 
319 :(before "End Rewrite Instruction(curr, recipe result)")
320 if (curr.name == "run") {
321   // Just inline all instructions inside the run block in the containing
322   // recipe. 'run' is basically a comment; pretend it doesn't exist.
323   istringstream in2("[\n"+curr.ingredients.at(0).name+"\n]\n");
324   slurp_body(in2, result);
325   curr.clear();
326 }
327 
328 :(scenario run_multiple)
329 def main [
330   run [
331     1:num <- copy 13
332   ]
333   run [
334     2:num <- copy 13
335   ]
336 ]
337 +mem: storing 13 in location 1
338 +mem: storing 13 in location 2
339 
340 //: 'memory-should-contain' raises errors if specific locations aren't as expected
341 //: Also includes some special support for checking strings.
342 
343 :(before "End Globals")
344 bool Scenario_testing_scenario = false;
345 :(before "End Setup")
346 Scenario_testing_scenario = false;
347 
348 :(scenario memory_check)
349 % Scenario_testing_scenario = true;
350 % Hide_errors = true;
351 def main [
352   memory-should-contain [
353     1 <- 13
354   ]
355 ]
356 +run: checking location 1
357 +error: expected location '1' to contain 13 but saw 0
358 
359 :(before "End Primitive Recipe Declarations")
360 MEMORY_SHOULD_CONTAIN,
361 :(before "End Primitive Recipe Numbers")
362 put(Recipe_ordinal, "memory-should-contain", MEMORY_SHOULD_CONTAIN);
363 :(before "End Primitive Recipe Checks")
364 case MEMORY_SHOULD_CONTAIN: {
365   break;
366 }
367 :(before "End Primitive Recipe Implementations")
368 case MEMORY_SHOULD_CONTAIN: {
369   if (!Passed) break;
370   check_memory(current_instruction().ingredients.at(0).name);
371   break;
372 }
373 
374 :(code)
375 void check_memory(const string& s) {
376   istringstream in(s);
377   in >> std::noskipws;
378   set<int> locations_checked;
379   while (true) {
380     skip_whitespace_and_comments(in);
381     if (!has_data(in)) break;
382     string lhs = next_word(in);
383     if (lhs.empty()) {
384       assert(!has_data(in));
385       raise << "incomplete 'memory-should-contain' block at end of file (0)\n" << end();
386       return;
387     }
388     if (!is_integer(lhs)) {
389       check_type(lhs, in);
390       continue;
391     }
392     int address = to_integer(lhs);
393     skip_whitespace_and_comments(in);
394     string _assign;  in >> _assign;  assert(_assign == "<-");
395     skip_whitespace_and_comments(in);
396     string rhs = next_word(in);
397     if (rhs.empty()) {
398       assert(!has_data(in));
399       raise << "incomplete 'memory-should-contain' block at end of file (1)\n" << end();
400       return;
401     }
402     if (!is_integer(rhs) && !is_noninteger(rhs)) {
403       if (Current_scenario && !Scenario_testing_scenario)
404         // genuine test in a .mu file
405         raise << "\nF - " << Current_scenario->name << ": location '" << address << "' can't contain non-number " << rhs << "\n" << end();
406       else
407         // just testing scenario support
408         raise << "location '" << address << "' can't contain non-number " << rhs << '\n' << end();
409       if (!Scenario_testing_scenario) Passed = false;
410       return;
411     }
412     double value = to_double(rhs);
413     if (contains_key(locations_checked, address))
414       raise << "duplicate expectation for location '" << address << "'\n" << end();
415     trace(9999, "run") << "checking location " << address << end();
416     if (get_or_insert(Memory, address) != value) {
417       if (Current_scenario && !Scenario_testing_scenario) {
418         // genuine test in a .mu file
419         raise << "\nF - " << Current_scenario->name << ": expected location '" << address << "' to contain " << no_scientific(value) << " but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end();
420       }
421       else {
422         // just testing scenario support
423         raise << "expected location '" << address << "' to contain " << no_scientific(value) << " but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end();
424       }
425       if (!Scenario_testing_scenario) Passed = false;
426       return;
427     }
428     locations_checked.insert(address);
429   }
430 }
431 
432 void check_type(const string& lhs, istream& in) {
433   reagent x(lhs);
434   if (is_mu_array(x.type) && is_mu_character(array_element(x.type))) {
435     x.set_value(to_integer(x.name));
436     skip_whitespace_and_comments(in);
437     string _assign = next_word(in);
438     if (_assign.empty()) {
439       assert(!has_data(in));
440       raise << "incomplete 'memory-should-contain' block at end of file (2)\n" << end();
441       return;
442     }
443     assert(_assign == "<-");
444     skip_whitespace_and_comments(in);
445     string literal = next_word(in);
446     if (literal.empty()) {
447       assert(!has_data(in));
448       raise << "incomplete 'memory-should-contain' block at end of file (3)\n" << end();
449       return;
450     }
451     int address = x.value;
452     // exclude quoting brackets
453     assert(*literal.begin() == '[');  literal.erase(literal.begin());
454     assert(*--literal.end() == ']');  literal.erase(--literal.end());
455     check_string(address, literal);
456     return;
457   }
458   // End Scenario Type Special-cases
459   raise << "don't know how to check memory for '" << lhs << "'\n" << end();
460 }
461 
462 void check_string(int address, const string& literal) {
463   trace(9999, "run") << "checking string length at " << address << end();
464   if (get_or_insert(Memory, address) != SIZE(literal)) {
465     if (Current_scenario && !Scenario_testing_scenario)
466       raise << "\nF - " << Current_scenario->name << ": expected location '" << address << "' to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << no_scientific(get_or_insert(Memory, address)) << " (" << read_mu_text(address-/*fake refcount*/1) << ")\n" << end();
467     else
468       raise << "expected location '" << address << "' to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end();
469     if (!Scenario_testing_scenario) Passed = false;
470     return;
471   }
472   ++address;  // now skip length
473   for (int i = 0;  i < SIZE(literal);  ++i) {
474     trace(9999, "run") << "checking location " << address+i << end();
475     if (get_or_insert(Memory, address+i) != literal.at(i)) {
476       if (Current_scenario && !Scenario_testing_scenario) {
477         // genuine test in a .mu file
478         raise << "\nF - " << Current_scenario->name << ": expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << no_scientific(get_or_insert(Memory, address+i)) << " ('" << static_cast<char>(get_or_insert(Memory, address+i)) << "')\n" << end();
479       }
480       else {
481         // just testing scenario support
482         raise << "expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << no_scientific(get_or_insert(Memory, address+i)) << '\n' << end();
483       }
484       if (!Scenario_testing_scenario) Passed = false;
485       return;
486     }
487   }
488 }
489 
490 :(scenario memory_check_multiple)
491 % Scenario_testing_scenario = true;
492 % Hide_errors = true;
493 def main [
494   memory-should-contain [
495     1 <- 0
496     1 <- 0
497   ]
498 ]
499 +error: duplicate expectation for location '1'
500 
501 :(scenario memory_check_string_length)
502 % Scenario_testing_scenario = true;
503 % Hide_errors = true;
504 def main [
505   1:num <- copy 3
506   2:num <- copy 97  # 'a'
507   3:num <- copy 98  # 'b'
508   4:num <- copy 99  # 'c'
509   memory-should-contain [
510     1:array:character <- [ab]
511   ]
512 ]
513 +error: expected location '1' to contain length 2 of string [ab] but saw 3
514 
515 :(scenario memory_check_string)
516 def main [
517   1:num <- copy 3
518   2:num <- copy 97  # 'a'
519   3:num <- copy 98  # 'b'
520   4:num <- copy 99  # 'c'
521   memory-should-contain [
522     1:array:character <- [abc]
523   ]
524 ]
525 +run: checking string length at 1
526 +run: checking location 2
527 +run: checking location 3
528 +run: checking location 4
529 
530 :(scenario memory_invalid_string_check)
531 % Scenario_testing_scenario = true;
532 % Hide_errors = true;
533 def main [
534   memory-should-contain [
535     1 <- [abc]
536   ]
537 ]
538 +error: location '1' can't contain non-number [abc]
539 
540 :(scenario memory_check_with_comment)
541 % Scenario_testing_scenario = true;
542 % Hide_errors = true;
543 def main [
544   memory-should-contain [
545     1 <- 34  # comment
546   ]
547 ]
548 -error: location 1 can't contain non-number 34  # comment
549 # but there'll be an error signalled by memory-should-contain
550 
551 //: 'trace-should-contain' is like the '+' lines in our scenarios so far
552 // Like runs of contiguous '+' lines, order is important. The trace checks
553 // that the lines are present *and* in the specified sequence. (There can be
554 // other lines in between.)
555 
556 :(scenario trace_check_fails)
557 % Scenario_testing_scenario = true;
558 % Hide_errors = true;
559 def main [
560   trace-should-contain [
561     a: b
562     a: d
563   ]
564 ]
565 +error: missing [b] in trace with label 'a'
566 
567 :(before "End Primitive Recipe Declarations")
568 TRACE_SHOULD_CONTAIN,
569 :(before "End Primitive Recipe Numbers")
570 put(Recipe_ordinal, "trace-should-contain", TRACE_SHOULD_CONTAIN);
571 :(before "End Primitive Recipe Checks")
572 case TRACE_SHOULD_CONTAIN: {
573   break;
574 }
575 :(before "End Primitive Recipe Implementations")
576 case TRACE_SHOULD_CONTAIN: {
577   if (!Passed) break;
578   check_trace(current_instruction().ingredients.at(0).name);
579   break;
580 }
581 
582 :(code)
583 // simplified version of check_trace_contents() that emits errors rather
584 // than just printing to stderr
585 void check_trace(const string& expected) {
586   Trace_stream->newline();
587   vector<trace_line> expected_lines = parse_trace(expected);
588   if (expected_lines.empty()) return;
589   int curr_expected_line = 0;
590   for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin();  p != Trace_stream->past_lines.end();  ++p) {
591     if (expected_lines.at(curr_expected_line).label != p->label) continue;
592     if (expected_lines.at(curr_expected_line).contents != trim(p->contents)) continue;
593     // match
594     ++curr_expected_line;
595     if (curr_expected_line == SIZE(expected_lines)) return;
596   }
597   if (Current_scenario && !Scenario_testing_scenario)
598     raise << "\nF - " << Current_scenario->name << ": missing [" << expected_lines.at(curr_expected_line).contents << "] "
599           << "in trace with label '" << expected_lines.at(curr_expected_line).label << "'\n" << end();
600   else
601     raise << "missing [" << expected_lines.at(curr_expected_line).contents << "] "
602           << "in trace with label '" << expected_lines.at(curr_expected_line).label << "'\n" << end();
603   if (!Hide_errors)
604     DUMP(expected_lines.at(curr_expected_line).label);
605   if (!Scenario_testing_scenario) Passed = false;
606 }
607 
608 vector<trace_line> parse_trace(const string& expected) {
609   vector<string> buf = split(expected, "\n");
610   vector<trace_line> result;
611   for (int i = 0;  i < SIZE(buf);  ++i) {
612     buf.at(i) = trim(buf.at(i));
613     if (buf.at(i).empty()) continue;
614     int delim = buf.at(i).find(": ");
615     if (delim == -1) {
616       raise << Current_scenario->name << ": lines in 'trace-should-contain' should be of the form <label>: <contents>. Both parts are required.\n" << end();
617       result.clear();
618       return result;
619     }
620     result.push_back(trace_line(trim(buf.at(i).substr(0, delim)),  trim(buf.at(i).substr(delim+2))));
621   }
622   return result;
623 }
624 
625 :(scenario trace_check_fails_in_nonfirst_line)
626 % Scenario_testing_scenario = true;
627 % Hide_errors = true;
628 def main [
629   run [
630     trace 1, [a], [b]
631   ]
632   trace-should-contain [
633     a: b
634     a: d
635   ]
636 ]
637 +error: missing [d] in trace with label 'a'
638 
639 :(scenario trace_check_passes_silently)
640 % Scenario_testing_scenario = true;
641 def main [
642   run [
643     trace 1, [a], [b]
644   ]
645   trace-should-contain [
646     a: b
647   ]
648 ]
649 -error: missing [b] in trace with label 'a'
650 $error: 0
651 
652 //: 'trace-should-not-contain' is like the '-' lines in our scenarios so far
653 //: Each trace line is separately checked for absense. Order is *not*
654 //: important, so you can't say things like "B should not exist after A."
655 
656 :(scenario trace_negative_check_fails)
657 % Scenario_testing_scenario = true;
658 % Hide_errors = true;
659 def main [
660   run [
661     trace 1, [a], [b]
662   ]
663   trace-should-not-contain [
664     a: b
665   ]
666 ]
667 +error: unexpected [b] in trace with label 'a'
668 
669 :(before "End Primitive Recipe Declarations")
670 TRACE_SHOULD_NOT_CONTAIN,
671 :(before "End Primitive Recipe Numbers")
672 put(Recipe_ordinal, "trace-should-not-contain", TRACE_SHOULD_NOT_CONTAIN);
673 :(before "End Primitive Recipe Checks")
674 case TRACE_SHOULD_NOT_CONTAIN: {
675   break;
676 }
677 :(before "End Primitive Recipe Implementations")
678 case TRACE_SHOULD_NOT_CONTAIN: {
679   if (!Passed) break;
680   check_trace_missing(current_instruction().ingredients.at(0).name);
681   break;
682 }
683 
684 :(code)
685 // simplified version of check_trace_contents() that emits errors rather
686 // than just printing to stderr
687 bool check_trace_missing(const string& in) {
688   Trace_stream->newline();
689   vector<trace_line> lines = parse_trace(in);
690   for (int i = 0;  i < SIZE(lines);  ++i) {
691     if (trace_count(lines.at(i).label, lines.at(i).contents) != 0) {
692       raise << "unexpected [" << lines.at(i).contents << "] in trace with label '" << lines.at(i).label << "'\n" << end();
693       if (!Scenario_testing_scenario) Passed = false;
694       return false;
695     }
696   }
697   return true;
698 }
699 
700 :(scenario trace_negative_check_passes_silently)
701 % Scenario_testing_scenario = true;
702 def main [
703   trace-should-not-contain [
704     a: b
705   ]
706 ]
707 -error: unexpected [b] in trace with label 'a'
708 $error: 0
709 
710 :(scenario trace_negative_check_fails_on_any_unexpected_line)
711 % Scenario_testing_scenario = true;
712 % Hide_errors = true;
713 def main [
714   run [
715     trace 1, [a], [d]
716   ]
717   trace-should-not-contain [
718     a: b
719     a: d
720   ]
721 ]
722 +error: unexpected [d] in trace with label 'a'
723 
724 :(scenario trace_count_check)
725 def main [
726   run [
727     trace 1, [a], [foo]
728   ]
729   check-trace-count-for-label 1, [a]
730 ]
731 # checks are inside scenario
732 
733 :(before "End Primitive Recipe Declarations")
734 CHECK_TRACE_COUNT_FOR_LABEL,
735 :(before "End Primitive Recipe Numbers")
736 put(Recipe_ordinal, "check-trace-count-for-label", CHECK_TRACE_COUNT_FOR_LABEL);
737 :(before "End Primitive Recipe Checks")
738 case CHECK_TRACE_COUNT_FOR_LABEL: {
739   if (SIZE(inst.ingredients) != 2) {
740     raise << maybe(get(Recipe, r).name) << "'check-trace-count-for-label' requires exactly two ingredients, but got '" << inst.original_string << "'\n" << end();
741     break;
742   }
743   if (!is_mu_number(inst.ingredients.at(0))) {
744     raise << maybe(get(Recipe, r).name) << "first ingredient of 'check-trace-count-for-label' should be a number (count), but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
745     break;
746   }
747   if (!is_literal_text(inst.ingredients.at(1))) {
748     raise << maybe(get(Recipe, r).name) << "second ingredient of 'check-trace-count-for-label' should be a literal string (label), but got '" << inst.ingredients.at(1).original_string << "'\n" << end();
749     break;
750   }
751   break;
752 }
753 :(before "End Primitive Recipe Implementations")
754 case CHECK_TRACE_COUNT_FOR_LABEL: {
755   if (!Passed) break;
756   int expected_count = ingredients.at(0).at(0);
757   string label = current_instruction().ingredients.at(1).name;
758   int count = trace_count(label);
759   if (count != expected_count) {
760     if (Current_scenario && !Scenario_testing_scenario) {
761       // genuine test in a .mu file
762       raise << "\nF - " << Current_scenario->name << ": " << maybe(current_recipe_name()) << "expected " << expected_count << " lines in trace with label '" << label << "' in trace: " << end();
763       DUMP(label);
764     }
765     else {
766       // just testing scenario support
767       raise << maybe(current_recipe_name()) << "expected " << expected_count << " lines in trace with label '" << label << "' in trace\n" << end();
768     }
769     if (!Scenario_testing_scenario) Passed = false;
770   }
771   break;
772 }
773 
774 :(scenario trace_count_check_2)
775 % Scenario_testing_scenario = true;
776 % Hide_errors = true;
777 def main [
778   run [
779     trace 1, [a], [foo]
780   ]
781   check-trace-count-for-label 2, [a]
782 ]
783 +error: main: expected 2 lines in trace with label 'a' in trace
784 
785 //: Minor detail: ignore 'system' calls in scenarios, since anything we do
786 //: with them is by definition impossible to test through Mu.
787 :(after "case _SYSTEM:")
788   if (Current_scenario) break;
789 
790 //:: Warn if people use '_' manually in function names. They're reserved for internal use.
791 
792 :(scenario recipe_name_with_underscore)
793 % Hide_errors = true;
794 def foo_bar [
795 ]
796 +error: foo_bar: don't create recipes with '_' in the name
797 
798 :(before "End recipe Fields")
799 bool is_autogenerated;
800 :(before "End recipe Constructor")
801 is_autogenerated = false;
802 :(code)
803 void mark_autogenerated(recipe_ordinal r) {
804   get(Recipe, r).is_autogenerated = true;
805 }
806 
807 :(after "void transform_all()")
808   for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin();  p != Recipe.end();  ++p) {
809     const recipe& r = p->second;
810     if (r.name.find('_') == string::npos) continue;
811     if (r.is_autogenerated) continue;  // created by previous call to transform_all()
812     raise << r.name << ": don't create recipes with '_' in the name\n" << end();
813   }
814 
815 //:: Helpers
816 
817 :(code)
818 // just for the scenarios running scenarios in C++ layers
819 void run_mu_scenario(const string& form) {
820   istringstream in(form);
821   in >> std::noskipws;
822   skip_whitespace_and_comments(in);
823   string _scenario = next_word(in);
824   if (_scenario.empty()) {
825     assert(!has_data(in));
826     raise << "no scenario in string passed into run_mu_scenario()\n" << end();
827     return;
828   }
829   assert(_scenario == "scenario");
830   scenario s = parse_scenario(in);
831   run_mu_scenario(s);
832 }