167 lines
7.5 KiB
C++
167 lines
7.5 KiB
C++
#include "harness.hpp"
|
|
#include <plot/plot/ticks.hpp>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
|
|
/// Fails if any colon-separated field of a clock label reaches its radix: minutes
|
|
/// and seconds must stay below 60 and hours below 24 (a value that rounds up to
|
|
/// 24 h takes the day shape instead), so "1:60" or "24:00:00" cannot slip through.
|
|
void check_no_field_reaches_its_radix(const std::string& label) {
|
|
const std::size_t colons = static_cast<std::size_t>(std::count(label.begin(), label.end(), ':'));
|
|
if (colons == 0) return; // decimal shapes have no fields
|
|
// Two colons mean h:mm:ss, one means m:ss: only the former starts with hours.
|
|
const int first_radix = colons >= 2 ? 24 : 60;
|
|
std::string clock = label;
|
|
if (!clock.empty() && (clock[0] == '-' || clock[0] == '+')) clock.erase(0, 1);
|
|
std::size_t start = 0;
|
|
std::size_t field = 0;
|
|
while (start <= clock.size()) {
|
|
const std::size_t colon = clock.find(':', start);
|
|
const std::string part =
|
|
clock.substr(start, colon == std::string::npos ? std::string::npos : colon - start);
|
|
if (!part.empty()) {
|
|
const int value = std::atoi(part.c_str());
|
|
PLOT_CHECK(value >= 0 && value < (field == 0 ? first_radix : 60));
|
|
}
|
|
if (colon == std::string::npos) break;
|
|
start = colon + 1;
|
|
++field;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
PLOT_TEST(nice_ticks_are_powers_of_ten_times_125) {
|
|
std::vector<plot::Tick> t;
|
|
plot::generate_ticks({0.0, 1.0}, /*px=*/500.0f, /*min_px=*/60.0f, t);
|
|
PLOT_CHECK(!t.empty());
|
|
for (auto& tick : t) PLOT_CHECK(std::fabs(tick.value * 5.0 - std::round(tick.value * 5.0)) < 1e-9);
|
|
// spacing of major ticks >= min_px
|
|
PLOT_CHECK(static_cast<double>(t.size()) <= 500.0 / 60.0 + 2.0);
|
|
}
|
|
PLOT_TEST(ticks_are_monotonic_and_cover_range) {
|
|
std::vector<plot::Tick> t;
|
|
plot::generate_ticks({-3.7, 91.2}, 800.0f, 60.0f, t);
|
|
for (size_t i = 1; i < t.size(); ++i) PLOT_CHECK(t[i].value > t[i-1].value);
|
|
PLOT_CHECK(t.front().value <= 0.0);
|
|
PLOT_CHECK(t.back().value >= 90.0);
|
|
}
|
|
PLOT_TEST(si_formatting) {
|
|
char b[32];
|
|
plot::format_si(0.0000015, b, sizeof b); PLOT_CHECK(std::string(b) == "1.5\xC2\xB5s" || std::string(b).find("1.5") == 0);
|
|
plot::format_si(2.5e9, b, sizeof b); PLOT_CHECK(std::string(b).find("2.5") == 0);
|
|
plot::format_si(1234.0, b, sizeof b); PLOT_CHECK(std::string(b).find("1.23") == 0);
|
|
plot::format_si(0.0, b, sizeof b); PLOT_CHECK(std::string(b) == "0");
|
|
}
|
|
PLOT_TEST(degenerate_ranges_do_not_hang) {
|
|
std::vector<plot::Tick> t;
|
|
plot::generate_ticks({5.0, 5.0}, 500.0f, 60.0f, t); // must not loop forever
|
|
PLOT_CHECK(t.size() <= 64);
|
|
plot::generate_ticks({0.0, 0.0}, 0.0f, 60.0f, t);
|
|
plot::generate_ticks({1e300, 1e300}, 500.0f, 60.0f, t);
|
|
}
|
|
|
|
PLOT_TEST(hostile_tick_inputs_clear_the_output) {
|
|
std::vector<plot::Tick> t{{1.0, true, "stale"}};
|
|
plot::generate_ticks({10.0, -10.0}, 500.0f, 60.0f, t); // inverted
|
|
PLOT_CHECK(t.empty());
|
|
plot::generate_ticks({0.0, std::nan("")}, 500.0f, 60.0f, t); // non-finite max
|
|
PLOT_CHECK(t.empty());
|
|
plot::generate_ticks({std::nan(""), 1.0}, 500.0f, 60.0f, t);
|
|
PLOT_CHECK(t.empty());
|
|
plot::generate_ticks({0.0, 1.0}, 500.0f, 0.0f, t); // min_px <= 0
|
|
PLOT_CHECK(t.empty());
|
|
// Span overflows to infinity: the step would be inf, so nothing is emitted
|
|
// and, crucially, the loop never runs.
|
|
plot::generate_ticks({-1e308, 1e308}, 500.0f, 60.0f, t);
|
|
PLOT_CHECK(t.empty());
|
|
}
|
|
|
|
PLOT_TEST(minor_ticks_subdivide_and_the_total_is_capped) {
|
|
std::vector<plot::Tick> t;
|
|
plot::generate_ticks({0.0, 1.0}, 500.0f, 60.0f, t, /*include_minors=*/true);
|
|
PLOT_CHECK(t.size() > 10); // minors really added
|
|
for (size_t i = 1; i < t.size(); ++i) PLOT_CHECK(t[i].value > t[i-1].value);
|
|
// The major step is 0.2 (leading digit 2), so minors are quartered at 0.05.
|
|
for (const plot::Tick& tick : t) {
|
|
const double scale = tick.major ? 5.0 : 20.0;
|
|
PLOT_CHECK(std::fabs(tick.value * scale - std::round(tick.value * scale)) < 1e-9);
|
|
PLOT_CHECK(tick.major ? !tick.label.empty() : tick.label.empty());
|
|
}
|
|
// A range dense enough to want millions of minors stops at the hard cap.
|
|
std::vector<plot::Tick> capped;
|
|
plot::generate_ticks({0.0, 1e9}, 1e6f, 1.0f, capped, /*include_minors=*/true);
|
|
PLOT_CHECK(capped.size() == plot::kMaxTicks);
|
|
}
|
|
|
|
PLOT_TEST(si_labels_are_utf8_and_never_overrun) {
|
|
char b[32];
|
|
plot::format_si(0.0000015, b, sizeof b);
|
|
PLOT_CHECK(std::string(b) == "1.5\xC2\xB5"); // U+00B5, not the Greek mu
|
|
plot::format_si(1234.0, b, sizeof b);
|
|
PLOT_CHECK(std::string(b) == "1.23k");
|
|
plot::format_si(-1234.0, b, sizeof b);
|
|
PLOT_CHECK(std::string(b) == "-1.23k");
|
|
plot::format_si(2.5e9, b, sizeof b);
|
|
PLOT_CHECK(std::string(b) == "2.5G");
|
|
plot::format_si(1.5e-6, b, sizeof b, "s");
|
|
PLOT_CHECK(std::string(b) == "1.5\xC2\xB5s"); // a caller-supplied unit suffix
|
|
plot::format_si(std::nan(""), b, sizeof b); // never silently dropped
|
|
PLOT_CHECK(std::string(b) == "nan");
|
|
plot::format_si(std::numeric_limits<double>::infinity(), b, sizeof b);
|
|
PLOT_CHECK(std::string(b) == "inf");
|
|
|
|
// A short buffer truncates; the string is always terminated inside it and
|
|
// nothing is ever written at or past `n`.
|
|
for (plot::usize n = 1; n <= 8; ++n) {
|
|
char small[8];
|
|
for (char& c : small) c = '#';
|
|
plot::format_si(-1234.567, small, n);
|
|
PLOT_CHECK(std::strlen(small) < n);
|
|
PLOT_CHECK(small[std::strlen(small)] == '\0');
|
|
}
|
|
}
|
|
|
|
PLOT_TEST(format_time_shapes) {
|
|
char b[32];
|
|
plot::format_time(0.5, b, sizeof b); PLOT_CHECK(std::string(b) == "500ms");
|
|
plot::format_time(1.5, b, sizeof b); PLOT_CHECK(std::string(b) == "1.5s");
|
|
plot::format_time(90.0, b, sizeof b); PLOT_CHECK(std::string(b) == "1:30");
|
|
plot::format_time(3661.0, b, sizeof b); PLOT_CHECK(std::string(b) == "1:01:01");
|
|
plot::format_time(-90.0, b, sizeof b); PLOT_CHECK(std::string(b) == "-1:30");
|
|
plot::format_time(86400.0, b, sizeof b); PLOT_CHECK(std::string(b) == "1d");
|
|
plot::format_time(std::nan(""), b, sizeof b); PLOT_CHECK(std::string(b) == "nan");
|
|
}
|
|
|
|
PLOT_TEST(format_time_never_lets_a_field_reach_its_radix) {
|
|
char b[32];
|
|
// Rounding the seconds leftover on its own used to print 119.5 s as "1:60";
|
|
// every field now comes from one rounded whole-second count.
|
|
plot::format_time(119.5, b, sizeof b); PLOT_CHECK(std::string(b) == "2:00");
|
|
plot::format_time(3599.5, b, sizeof b); PLOT_CHECK(std::string(b) == "1:00:00");
|
|
plot::format_time(59.4999, b, sizeof b); PLOT_CHECK(std::string(b) == "59.5s");
|
|
plot::format_time(59.5, b, sizeof b); PLOT_CHECK(std::string(b) == "1:00");
|
|
plot::format_time(60.0, b, sizeof b); PLOT_CHECK(std::string(b) == "1:00");
|
|
// At 24 h the day field appears, so the hour field never reaches 24.
|
|
plot::format_time(86399.4, b, sizeof b); PLOT_CHECK(std::string(b) == "23:59:59");
|
|
plot::format_time(86399.5, b, sizeof b); PLOT_CHECK(std::string(b) == "1d");
|
|
plot::format_time(86400.0, b, sizeof b); PLOT_CHECK(std::string(b) == "1d");
|
|
|
|
// Sweep the boundary neighbourhoods and check every emitted field.
|
|
const double values[] = {0.4, 0.9995, 1.0, 59.4, 59.4999, 59.5, 59.9, 60.0, 90.0, 119.5, 3599.4,
|
|
3599.5, 3599.9, 86399.4, 86399.5, 86399.9, 86400.0, 172800.0, -119.5,
|
|
-3599.5, -86399.5};
|
|
for (const double v : values) {
|
|
plot::format_time(v, b, sizeof b);
|
|
const std::string label(b);
|
|
PLOT_CHECK(!label.empty());
|
|
check_no_field_reaches_its_radix(label);
|
|
}
|
|
}
|