package main
import (
"fmt"
"io/ioutil"
"os"
"time"
"framagit.org/andinus/cetus/pkg/background"
"framagit.org/andinus/cetus/pkg/bpod"
"framagit.org/andinus/indus/notification"
)
func execBPOD() {
// reqInfo holds all the parameters that needs to be sent with
// the request. GetJson() will pack apiKey & date in params
// map before sending it to another function. Adding params
// here will not change the behaviour of the function, changes
// have to be made in GetJson() too.
reqInfo := make(map[string]string)
reqInfo["api"] = string(*bpodAPI)
if *bpodRand {
reqInfo["random"] = "true"
}
cacheDir := fmt.Sprintf("%s/%s", getCacheDir(), "bpod")
os.MkdirAll(cacheDir, os.ModePerm)
// Check if the file is available locally, if it is then don't
// download it again and get it from disk.
//
// We don't know the bpod date because that will be there in
// response & we can't read the response without requesting
// it. So this will assume the bpod date to be today's date if
// *bpodRand is not set true. If *bpodRand is set true then we
// can't assume the date. Also this way too it can cause error
// if our assumed date doesn't matches date at the server.
var body string
var file string
var err error
if !*bpodRand {
// If not *bpodRand and the file exists then read from
// disk, if the file doesn't exist then get it and
// save it to disk.
file = fmt.Sprintf("%s/%s", cacheDir, time.Now().UTC().Format("2006-01-02"))
if _, err := os.Stat(file); err == nil {
data, err := ioutil.ReadFile(file)
chkErrpre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long *///: Mu scenarios. This will get long, but these are the tests we want to
//: support in this layer.
//: You can use variable names in scenarios, but for the most part we'll use
//: raw location numbers, because that lets us make assertions on memory.
//: Tests should avoid abstraction as far as possible.
:(scenarios run_mu_scenario)
:(scenario scenario_block)
scenario foo [
run [
1:number <- copy 13:literal
]
memory-should-contain [
1 <- 13
]
]
# checks are inside scenario
:(scenario scenario_multiple_blocks)
scenario foo [
run [
1:number <- copy 13:literal
]
memory-should-contain [
1 <- 13
]
run [
2:number <- copy 13:literal
]
memory-should-contain [
1 <- 13
2 <- 13
]
]
:(scenario scenario_check_memory_and_trace)
scenario foo [
run [
1:number <- copy 13:literal
trace [a], [a b c]
]
memory-should-contain [
1 <- 13
]
trace-should-contain [
a: a b c
]
trace-should-not-contain [
a: x y z
]
]
//:: Core data structure
:(before "End Types")
struct scenario {
string name;
string to_run;
};
:(before "End Globals")
vector<scenario> Scenarios;
//:: Parse the 'scenario' form.
//: Simply store the text of the scenario.
:(before "End Command Handlers")
else if (command == "scenario") {
Scenarios.push_back(parse_scenario(in));
}
:(code)
scenario parse_scenario(istream& in) {
scenario result;
result.name = next_word(in);
skip_bracket(in, "'scenario' must begin with '['");
ostringstream buffer;
slurp_until_matching_bracket(in, buffer);
result.to_run = buffer.str();
return result;
}
//:: Run scenarios when we run 'mu test'.
//: Treat the text of the scenario as a regular series of instructions.
:(before "End Tests")
time_t mu_time; time(&mu_time);
cerr << "\nMu tests: " << ctime(&mu_time);
for (long long int i = 0; i < SIZE(Scenarios); ++i) {
//? cerr << Passed << '\n'; //? 1
//? cerr << i << ": " << Scenarios.at(i).name << '\n'; //? 3
run_mu_scenario(Scenarios.at(i));
if (Passed) cerr << ".";
}
//: Convenience: run a single named scenario.
:(before "Loading Commandline Files")
if (argc == 2 && Run_tests) {
for (long long int i = 0; i < SIZE(Scenarios); ++i) {
if (Scenarios.at(i).name == argv[1]) {
run_mu_scenario(Scenarios.at(i));
return 0;
}
}
}
:(before "End Globals")
const scenario* Current_scenario = NULL;
:(code)
void run_mu_scenario(const scenario& s) {
Current_scenario = &s;
bool not_already_inside_test = !Trace_stream;
if (not_already_inside_test) {
Trace_file = s.name;
Trace_stream = new trace_stream;
setup();
}
run("recipe "+s.name+" [ " + s.to_run + " ]");
if (not_already_inside_test && Trace_stream) {
teardown();
ofstream fout((Trace_dir+Trace_file).c_str());
fout << Trace_stream->readable_contents("");
fout.close();
delete Trace_stream;
Trace_stream = NULL;
Trace_file = "";
}
Current_scenario = NULL;
}
//:: The special instructions we want to support inside scenarios.
//: In a compiler for the mu VM these will require more work.
//: 'run' interprets a string as a set of instructions
:(scenarios run)
:(scenario run)
#? % Trace_stream->dump_layer = "all";
recipe main [
run [
1:number <- copy 13:literal
]
]
+mem: storing 13 in location 1
:(before "End Primitive Recipe Declarations")
RUN,
:(before "End Primitive Recipe Numbers")
Recipe_number["run"] = RUN;
:(before "End Primitive Recipe Implementations")
case RUN: {
//? cout << "recipe " << current_instruction().ingredients.at(0).name << '\n'; //? 1
ostringstream tmp;
tmp << "recipe run" << Next_recipe_number << " [ " << current_instruction().ingredients.at(0).name << " ]";
//? Show_rest_of_stream = true; //? 1
vector<recipe_number> tmp_recipe = load(tmp.str());
// Predefined Scenario Locals In Run.
// End Predefined Scenario Locals In Run.
transform_all();
//? cout << tmp_recipe.at(0) << ' ' << Recipe_number["main"] << '\n'; //? 1
Current_routine->calls.push_front(call(tmp_recipe.at(0)));
continue; // not done with caller; don't increment current_step_index()
}
:(scenario run_multiple)
recipe main [
run [
1:number <- copy 13:literal
]
run [
2:number <- copy 13:literal
]
]
+mem: storing 13 in location 1
+mem: storing 13 in location 2
//: 'memory-should-contain' raises warnings if specific locations aren't as expected
//: Also includes some special support for checking strings.
:(scenario memory_check)
% Hide_warnings = true;
recipe main [
memory-should-contain [
1 <- 13
]
]
+run: checking location 1
+warn: expected location 1 to contain 13 but saw 0
:(before "End Primitive Recipe Declarations")
MEMORY_SHOULD_CONTAIN,
:(before "End Primitive Recipe Numbers")
Recipe_number["memory-should-contain"] = MEMORY_SHOULD_CONTAIN;
:(before "End Primitive Recipe Implementations")
case MEMORY_SHOULD_CONTAIN: {
//? cout << current_instruction().ingredients.at(0).name << '\n'; //? 1
check_memory(current_instruction().ingredients.at(0).name);
break;
}
:(code)
void check_memory(const string& s) {
istringstream in(s);
in >> std::noskipws;
set<long long int> locations_checked;
while (true) {
skip_whitespace_and_comments(in);
if (in.eof()) break;
string lhs = next_word(in);
if (!is_integer(lhs)) {
check_type(lhs, in);
continue;
}
int address = to_integer(lhs);
skip_whitespace_and_comments(in);
string _assign; in >> _assign; assert(_assign == "<-");
skip_whitespace_and_comments(in);
int value = 0; in >> value;
if (locations_checked.find(address) != locations_checked.end())
raise << "duplicate expectation for location " << address << '\n';
trace(Primitive_recipe_depth, "run") << "checking location " << address;
if (Memory[address] != value) {
if (Current_scenario && !Hide_warnings) {
// genuine test in a mu file
raise << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain " << value << " but saw " << Memory[address] << '\n';
}
else {
// just testing scenario support
raise << "expected location " << address << " to contain " << value << " but saw " << Memory[address] << '\n';
}
if (!Hide_warnings) {
Passed = false;
++Num_failures;
}
return;
}
locations_checked.insert(address);
}
}
void check_type(const string& lhs, istream& in) {
reagent x(lhs);
if (x.properties.at(0).second.at(0) == "string") {
x.set_value(to_integer(x.name));
skip_whitespace_and_comments(in);
string _assign = next_word(in);
assert(_assign == "<-");
skip_whitespace_and_comments(in);
string literal = next_word(in);
long long int address = x.value;
// exclude quoting brackets
assert(*literal.begin() == '['); literal.erase(literal.begin());
assert(*--literal.end() == ']'); literal.erase(--literal.end());
check_string(address, literal);
return;
}
raise << "don't know how to check memory for " << lhs << '\n';
}
void check_string(long long int address, const string& literal) {
trace(Primitive_recipe_depth, "run") << "checking string length at " << address;
if (Memory[address] != SIZE(literal)) {
if (Current_scenario && !Hide_warnings)
raise << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << Memory[address] << '\n';
else
raise << "expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << Memory[address] << '\n';
if (!Hide_warnings) {
Passed = false;
++Num_failures;
}
return;
}
++address; // now skip length
for (long long int i = 0; i < SIZE(literal); ++i) {
trace(Primitive_recipe_depth, "run") << "checking location " << address+i;
if (Memory[address+i] != literal.at(i)) {
if (Current_scenario && !Hide_warnings) {
// genuine test in a mu file
raise << "\nF - " << Current_scenario->name << ": expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << Memory[address+i] << '\n';
}
else {
// just testing scenario support
raise << "expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << Memory[address+i] << '\n';
}
if (!Hide_warnings) {
Passed = false;
++Num_failures;
}
return;
}
}
}
:(scenario memory_check_multiple)
% Hide_warnings = true;
recipe main [
memory-should-contain [
1 <- 0
1 <- 0
]
]
+warn: duplicate expectation for location 1
:(scenario memory_check_string_length)
% Hide_warnings = true;
recipe main [
1:number <- copy 3:literal
2:number <- copy 97:literal # 'a'
3:number <- copy 98:literal # 'b'
4:number <- copy 99:literal # 'c'
memory-should-contain [
1:string <- [ab]
]
]
+warn: expected location 1 to contain length 2 of string [ab] but saw 3
:(scenario memory_check_string)
recipe main [
1:number <- copy 3:literal
2:number <- copy 97:literal # 'a'
3:number <- copy 98:literal # 'b'
4:number <- copy 99:literal # 'c'
memory-should-contain [
1:string <- [abc]
]
]
+run: checking string length at 1
+run: checking location 2
+run: checking location 3
+run: checking location 4
:(code)
//: 'trace-should-contain' is like the '+' lines in our scenarios so far
// Like runs of contiguous '+' lines, order is important. The trace checks
// that the lines are present *and* in the specified sequence. (There can be
// other lines in between.)
//
// Be careful not to mix setting Hide_warnings and checking the trace in .mu
// files. It'll work in C++ scenarios, but the test failure gets silently
// hidden in mu scenarios.
:(scenario trace_check_warns_on_failure)
% Hide_warnings = true;
recipe main [
trace-should-contain [
a: b
a: d
]
]
+warn: missing [b] in trace layer a
:(before "End Primitive Recipe Declarations")
TRACE_SHOULD_CONTAIN,
:(before "End Primitive Recipe Numbers")
Recipe_number["trace-should-contain"] = TRACE_SHOULD_CONTAIN;
:(before "End Primitive Recipe Implementations")
case TRACE_SHOULD_CONTAIN: {
check_trace(current_instruction().ingredients.at(0).name);
break;
}
:(code)
// simplified version of check_trace_contents() that emits warnings rather
// than just printing to stderr
bool check_trace(const string& expected) {
//? cerr << "AAA " << expected << '\n'; //? 1
Trace_stream->newline();
vector<trace_line> expected_lines = parse_trace(expected);
//? cerr << "BBB " << SIZE(expected_lines) << '\n'; //? 1
if (expected_lines.empty()) return true;
long long int curr_expected_line = 0;
for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
if (expected_lines.at(curr_expected_line).label != p->label) continue;
if (expected_lines.at(curr_expected_line).contents != trim(p->contents)) continue;
// match
++curr_expected_line;
if (curr_expected_line == SIZE(expected_lines)) {
//? cerr << "ZZZ\n"; //? 1
return true;
}
}
raise << "missing [" << expected_lines.at(curr_expected_line).contents << "] "
<< "in trace layer " << expected_lines.at(curr_expected_line).label << '\n';
Passed = false;
return false;
}
vector<trace_line> parse_trace(const string& expected) {
vector<string> buf = split(expected, "\n");
vector<trace_line> result;
for (long long int i = 0; i < SIZE(buf); ++i) {
buf.at(i) = trim(buf.at(i));
if (buf.at(i).empty()) continue;
long long int delim = buf.at(i).find(": ");
result.push_back(trace_line(trim(buf.at(i).substr(0, delim)), trim(buf.at(i).substr(delim+2))));
}
return result;
}
:(scenario trace_check_warns_on_failure_in_later_line)
% Hide_warnings = true;
recipe main [
run [
trace [a], [b]
]
trace-should-contain [
a: b
a: d
]
]
+warn: missing [d] in trace layer a
:(scenario trace_check_passes_silently)
% Hide_warnings = true;
recipe main [
run [
trace [a], [b]
]
trace-should-contain [
a: b
]
]
-warn: missing [b] in trace layer a
//: 'trace-should-not-contain' is like the '-' lines in our scenarios so far
//: Each trace line is separately checked for absense. Order is *not*
//: important, so you can't say things like "B should not exist after A."
:(scenario trace_negative_check_warns_on_failure)
% Hide_warnings = true;
recipe main [
run [
trace [a], [b]
]
trace-should-not-contain [
a: b
]
]
+warn: unexpected [b] in trace layer a
:(before "End Primitive Recipe Declarations")
TRACE_SHOULD_NOT_CONTAIN,
:(before "End Primitive Recipe Numbers")
Recipe_number["trace-should-not-contain"] = TRACE_SHOULD_NOT_CONTAIN;
:(before "End Primitive Recipe Implementations")
case TRACE_SHOULD_NOT_CONTAIN: {
check_trace_missing(current_instruction().ingredients.at(0).name);
break;
}
:(code)
// simplified version of check_trace_contents() that emits warnings rather
// than just printing to stderr
bool check_trace_missing(const string& in) {
Trace_stream->newline();
vector<trace_line> lines = parse_trace(in);
for (long long int i = 0; i < SIZE(lines); ++i) {
if (trace_count(lines.at(i).label, lines.at(i).contents) != 0) {
raise << "unexpected [" << lines.at(i).contents << "] in trace layer " << lines.at(i).label << '\n';
Passed = false;
return false;
}
}
return true;
}
:(scenario trace_negative_check_passes_silently)
% Hide_warnings = true;
recipe main [
trace-should-not-contain [
a: b
]
]
-warn: unexpected [b] in trace layer a
:(scenario trace_negative_check_warns_on_any_unexpected_line)
% Hide_warnings = true;
recipe main [
run [
trace [a], [d]
]
trace-should-not-contain [
a: b
a: d
]
]
+warn: unexpected [d] in trace layer a
//:: Helpers
:(code)
// just for the scenarios running scenarios in C++ layers
void run_mu_scenario(const string& form) {
istringstream in(form);
in >> std::noskipws;
string _scenario = next_word(in);
//? cout << _scenario << '\n'; //? 1
assert(_scenario == "scenario");
scenario s = parse_scenario(in);
run_mu_scenario(s);
}
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;
}
}