static void update_time (BITui* ui, uint64_t tme) {
if (ui->integration_spl == tme) {
return;
}
ui->integration_spl = tme;
char buf[64];
if (ui->integration_spl < .1 * ui->rate) {
snprintf (buf, 64, "%u [spl]", (unsigned int) ui->integration_spl);
} else {
format_duration (buf, ui->integration_spl / ui->rate);
}
robtk_lbl_set_text (ui->lbl_data[3], buf);
}
static result run(framework_services& fw, const info_t& info, const registered* tests, size_t num_tests, const filter_chain::filter_t* filters, size_t num_filters)
{
services& srv = fw;
try { fw.check_system_requirements(info); }
catch (std::exception& e)
{
throw std::runtime_error(std::string("unit tests did not meet system requirements:\n ") + e.what());
}
filter_chain filter;
try { filter = std::move(filter_chain(filters, num_filters)); }
catch (std::exception& e)
{
srv.printf(print_type::error, "%s\n", e.what());
return result::failure;
}
// sort tests
std::vector<const registered*> sorted_tests;
{
sorted_tests.reserve(num_tests);
auto t = tests;
auto e = t + num_tests;
while (t < e)
sorted_tests.push_back(t++);
std::sort(sorted_tests.begin(), sorted_tests.end(), [](const registered* a, const registered* b)->bool { return *a < *b; } );
}
// prepare formatting used to print results
char fmtname [64]; if (64 < snprintf(fmtname, "%%-%us", info.name_col_width )) oThrow(std::errc::invalid_argument, "name col width too wide");
char fmtstatus[64]; if (64 < snprintf(fmtstatus, "%%-%us", info.status_col_width)) oThrow(std::errc::invalid_argument, "status col width too wide");
char fmttime [64]; if (64 < snprintf(fmttime, "%%-%us", info.time_col_width )) oThrow(std::errc::invalid_argument, "time col width too wide");
char fmtmsg [64]; snprintf(fmtmsg, "%%s\n" );
uint32_t nsucceeded = 0;
uint32_t nfailed = 0;
uint32_t nleaks = 0;
uint32_t nskipped = 0;
std::array<uint32_t, (int)result::count> counts;
fw.pre_iterations(info);
timer whole_run_timer;
for (size_t iteration = 0; iteration < info.num_iterations; iteration++)
{
counts.fill(0);
srv.printf(print_type::normal, "========== %s Run %u ==========\n", info.test_suite_name, iteration + 1);
// table headers
{
srv.printf(print_type::heading, fmtname, "TEST NAME"); separator(srv);
srv.printf(print_type::heading, fmtstatus, "STATUS"); separator(srv);
srv.printf(print_type::heading, fmttime, "TIME"); separator(srv);
srv.printf(print_type::heading, fmtmsg, "STATUS MESSAGE");
}
timer iter_timer;
for (auto test : sorted_tests)
{
if (!test)
continue;
const char* test_name = test->name;
srv.printf(print_type::normal, fmtname, test_name);
separator(srv);
result res = result::filtered;
double test_run_time = 0.0;
if (filter.passes(test_name))
{
srv.trace("========== Begin %s Run %u ==========", test_name, iteration + 1);
// restore initial state
fw.seed_rand(info.random_seed);
// clear status
fw.status("");
fw.pre_test(info, test_name);
timer test_timer;
try
{
test->run(srv);
res = result::success;
}
catch (skip_test& e)
{
res = result::skipped;
srv.status(e.what());
}
catch (test_not_ready& e)
{
res = result::notready;
srv.status(e.what());
}
catch (std::exception& e)
{
res = result::failure;
srv.trace("%s: %s", test_name, e.what());
srv.status(e.what());
}
test_run_time = test_timer.seconds();
fw.post_test(info);
// check for leaks
if (res != result::failure && fw.has_memory_leaks(info))
res = result::leaks;
char duration[64];
format_duration(duration, round(test_run_time));
srv.trace("========== End %s Run %u %s in %s ==========", test_name, iteration + 1, as_string(res), duration);
}
else
{
res = result::skipped;
srv.status("---");
}
counts[(int)res]++;
// print the result
srv.printf(s_result_print_type[(int)res], fmtstatus, as_string(res));
separator(srv);
// print the time taken
{
double runtime = test_run_time;
print_type type = runtime > info.run_time_very_slow ? print_type::error : ((runtime > info.run_time_slow) ? print_type::caution : print_type::normal);
char duration[64];
format_duration(duration, round(runtime), true);
srv.printf(type, fmttime, duration);
separator(srv);
}
// print the status message
{
apply_default_status(srv, res, test->bug);
srv.printf(print_type::normal, fmtmsg, srv.status());
::_flushall();
}
}
::_flushall();
// Summarize results for this iteration and sum total statistics
const uint32_t iter_nsucceeded = counts[(int)result::success];
const uint32_t iter_nfailed = counts[(int)result::failure];
const uint32_t iter_nleaks = counts[(int)result::leaks];
const uint32_t iter_nskipped = counts[(int)result::skipped] + counts[(int)result::filtered] + counts[(int)result::bugged] + counts[(int)result::notready];
if ((iter_nsucceeded + iter_nfailed + iter_nleaks) == 0)
{
srv.printf(print_type::error, "========== Unit Tests: ERROR NO TESTS RUN ==========\n");
break;
}
else
{
char duration[64];
format_duration(duration, round(iter_timer.seconds()));
srv.printf(print_type::heading, "========== Unit Tests: %u succeeded, %u failed, %u leaked, %u skipped in %s ==========\n", iter_nsucceeded, iter_nfailed, iter_nleaks, iter_nskipped, duration);
}
nsucceeded += iter_nsucceeded;
nfailed += iter_nfailed;
nleaks += iter_nleaks;
nskipped += iter_nskipped;
}
if (info.num_iterations != 1)
{
char duration[64];
format_duration(duration, round(whole_run_timer.seconds()));
srv.printf(print_type::heading, "========== %u Iterations: %u succeeded, %u failed, %u leaked, %u skipped in %s ==========\n", info.num_iterations, nsucceeded, nfailed, nleaks, nskipped, duration);
}
if ((nsucceeded + nfailed + nleaks) == 0)
return result::notfound;
if (nfailed > 0)
return result::failure;
if (nleaks > 0)
return result::leaks;
return result::success;
}
void format_string_code(unsigned int format_code, char **dest, char **args)
{
int value;
switch (format_code) {
case FORMAT_COMMA32:
// Pop argument
value = *((sint32*)*args);
*args += 4;
format_comma_separated_integer(dest, value);
break;
case FORMAT_INT32:
// Pop argument
value = *((sint32*)*args);
*args += 4;
format_integer(dest, value);
break;
case FORMAT_COMMA2DP32:
// Pop argument
value = *((sint32*)*args);
*args += 4;
format_comma_separated_fixed_2dp(dest, value);
break;
case FORMAT_COMMA1DP16:
// Pop argument
value = *((sint16*)*args);
*args += 2;
format_comma_separated_fixed_1dp(dest, value);
break;
case FORMAT_COMMA16:
// Pop argument
value = *((sint16*)*args);
*args += 2;
format_comma_separated_integer(dest, value);
break;
case FORMAT_UINT16:
// Pop argument
value = *((uint16*)*args);
*args += 2;
format_integer(dest, value);
break;
case FORMAT_CURRENCY2DP:
// Pop argument
value = *((sint32*)*args);
*args += 4;
format_currency_2dp(dest, value);
break;
case FORMAT_CURRENCY:
// Pop argument
value = *((sint32*)*args);
*args += 4;
format_currency(dest, value);
break;
case FORMAT_STRINGID:
case FORMAT_STRINGID2:
// Pop argument
value = *((uint16*)*args);
*args += 2;
format_string_part(dest, value, args);
(*dest)--;
break;
case FORMAT_STRING:
// Pop argument
value = *((uint32*)*args);
*args += 4;
if (value != 0) {
strcpy(*dest, (char*)value);
*dest += strlen(*dest);
}
break;
case FORMAT_MONTHYEAR:
// Pop argument
value = *((uint16*)*args);
*args += 2;
format_date(dest, value);
break;
case FORMAT_MONTH:
// Pop argument
value = *((uint16*)*args);
*args += 2;
strcpy(*dest, language_get_string(STR_MONTH_MARCH + date_get_month(value)));
*dest += strlen(*dest);
break;
case FORMAT_VELOCITY:
// Pop argument
value = *((sint16*)*args);
*args += 2;
format_velocity(dest, value);
break;
case FORMAT_POP16:
*args += 2;
break;
case FORMAT_PUSH16:
*args -= 2;
break;
case FORMAT_DURATION:
// Pop argument
value = *((uint16*)*args);
*args += 2;
format_duration(dest, value);
break;
case FORMAT_REALTIME:
// Pop argument
value = *((uint16*)*args);
*args += 2;
format_realtime(dest, value);
break;
case FORMAT_LENGTH:
// Pop argument
value = *((sint16*)*args);
*args += 2;
format_length(dest, value);
break;
case FORMAT_SPRITE:
// Pop argument
value = *((uint32*)*args);
*args += 4;
*(*dest)++ = 23;
*((uint32*)(*dest)) = value;
*dest += 4;
break;
}
}
void caltrap_add(int nargs, char **args, int nphysargs, struct entry *e)
{
Date sd, ed;
Time st, et;
int i;
char msg[512], *msgp, *p;
struct entry ent;
if (e->length == INVALID_DURATION)
e->length = 0;
if (e->period == INVALID_DURATION)
e->period = 0;
if (e->type == INVALID_TYPE)
e->type = T_EVENT;
if (nargs < 1 || nargs > 4)
fatalerr_addargno();
assert(nargs <= nphysargs);
/*
* We MUST see a date as the first argument.
*/
sd = parse_date(args[0]);
if (sd == INVALID_DATE)
fatalerr_date(args[0]);
i = 1;
/*
* Now we might see a time.
*/
st = NO_TIME;
if (nargs > i) {
st = parse_time(args[i]);
if (st != INVALID_TIME)
i++;
else
st = NO_TIME;
}
/*
* Now we expect to see a second date or time or both.
*/
if (nargs > i) {
ed = parse_date(args[i]);
if (ed != INVALID_DATE)
i++;
if (nargs > i) {
et = parse_time(args[i]);
if (et == INVALID_TIME)
fatalerr_time(args[i]);
i++;
if (ed == INVALID_DATE) {
/*
* If an end time was specified but no end date, we
* assume ed == sd.
*/
ed = sd;
}
} else
et = 0;
/*
* In this case, we normalise a missing start time to
* midnight.
*/
if (st == NO_TIME)
st = 0;
} else {
/*
* If there was no end time, choose one appropriately. An
* entry specifying just a date as input is taken to last
* exactly one day; an entry specifying just a start
* date+time is taken to be instantaneous.
*/
if (st == NO_TIME) {
st = 0;
ed = sd + 1;
et = 0;
} else {
ed = sd;
et = st;
}
}
if (i < nargs)
fatalerr_extraarg(args[i]);
msgp = e->description;
if (isatty(fileno(stdin))) {
char *dfmt, *tfmt;
dfmt = format_date_full(sd);
tfmt = format_time(st);
printf("New entry will run from %s %s\n", dfmt, tfmt);
sfree(dfmt);
sfree(tfmt);
if (e->period) {
Date td;
Time tt;
td = sd;
tt = st;
add_to_datetime(&td, &tt, e->length);
dfmt = format_date_full(td);
tfmt = format_time(tt);
printf(" to %s %s\n", dfmt, tfmt);
sfree(dfmt);
sfree(tfmt);
dfmt = format_duration(e->period);
printf(" repeating every %s\n", dfmt);
sfree(dfmt);
td = sd;
tt = st;
add_to_datetime(&td, &tt, e->period);
dfmt = format_date_full(td);
tfmt = format_time(tt);
printf("so second occurrence is %s %s\n", dfmt, tfmt);
sfree(dfmt);
sfree(tfmt);
dfmt = format_date_full(ed);
tfmt = format_time(et);
printf(" and stop repeating on %s %s\n", dfmt, tfmt);
sfree(dfmt);
sfree(tfmt);
} else {
dfmt = format_date_full(ed);
tfmt = format_time(et);
printf(" to %s %s\n", dfmt, tfmt);
sfree(dfmt);
sfree(tfmt);
}
if (!msgp) {
printf("Existing entries in the week surrounding the start point:\n");
list_entries(sd - 3, 0, sd + 4, 0);
printf("Now enter message, on a single line,\n"
"or press ^D or ^C to cancel the operation.\n"
"> ");
fflush(stdout);
}
}
if (!msgp) {
if (!fgets(msg, sizeof(msg), stdin))
*msg = '\0';
p = msg + strcspn(msg, "\r\n");
if (!*p) {
printf("\nOperation cancelled.\n");
fflush(stdout);
return;
}
*p = '\0';
msgp = msg;
}
ent.id = -1; /* cause a new id to be allocated */
ent.sd = sd;
ent.st = st;
ent.ed = ed;
ent.et = et;
ent.length = e->length;
ent.period = e->period;
ent.type = e->type;
ent.description = msgp;
db_add_entry(&ent);
}
