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); }