tiny.profiling.report.chart

1const std = @import("std");2const zen = @import("zen");34const Allocator = std.mem.Allocator;56pub const Format = *const fn (Allocator, f64) Allocator.Error![]u8;78pub const Point = struct {9    label: []const u8,10    value: ?f64,11    low: ?f64 = null,12    high: ?f64 = null,13};1415pub const LineOptions = struct {16    width: f64 = 260,17    height: f64 = 64,18    ticks: bool = false,19    format: Format,20};2122pub const StripOptions = struct {23    width: f64 = 220,24    height: f64 = 40,25    format: Format,26};2728pub const SequenceOptions = struct {29    width: f64 = 220,30    height: f64 = 40,31    index_origin: u64 = 0,32    format: Format,33};3435pub const XyPoint = struct {36    x: f64,37    y: f64,38    label: []const u8,39};4041pub const XyOptions = struct {42    width: f64 = 210,43    height: f64 = 72,44};4546const max_strip_dots = 512;47const max_sequence_points = 512;4849const Domain = struct {50    min: f64,51    max: f64,5253    fn observe(self: *Domain, value: ?f64) void {54        const actual = value orelse return;55        if (!std.math.isFinite(actual)) return;56        if (actual < self.min) self.min = actual;57        if (actual > self.max) self.max = actual;58    }5960    fn seen(self: Domain) bool {61        return self.min <= self.max;62    }6364    fn span(self: Domain) f64 {65        return if (self.max > self.min) self.max - self.min else 1;66    }67};6869const empty_domain = Domain{ .min = std.math.inf(f64), .max = -std.math.inf(f64) };7071pub fn line(allocator: Allocator, points: []const Point, options: LineOptions) Allocator.Error![]u8 {72    var out: std.ArrayList(u8) = .empty;73    var domain = empty_domain;74    var defined: usize = 0;75    for (points) |point| {76        if (point.value != null) defined += 1;77        domain.observe(point.value);78        domain.observe(point.low);79        domain.observe(point.high);80    }81    try openSvg(&out, allocator, options.width, options.height, "chart-line-figure");82    if (defined == 0) {83        try emptyText(&out, allocator, options.width, options.height);84        try out.appendSlice(allocator, "</svg>");85        return try out.toOwnedSlice(allocator);86    }8788    const pad_left: f64 = if (options.ticks) 64 else 8;89    const pad_right: f64 = 8;90    const pad_y: f64 = 7;91    const plot = Plot{92        .x0 = pad_left,93        .x1 = options.width - pad_right,94        .y0 = pad_y,95        .y1 = options.height - pad_y,96        .domain = domain,97        .count = points.len,98    };99100    if (options.ticks) try lineTicks(&out, allocator, plot, options.format);101    try lineBand(&out, allocator, points, plot);102    try linePath(&out, allocator, points, plot);103    try lineDots(&out, allocator, points, plot, options.format);104    try out.appendSlice(allocator, "</svg>");105    return try out.toOwnedSlice(allocator);106}107108pub fn strip(109    allocator: Allocator,110    samples: []const u64,111    median: ?f64,112    low: ?f64,113    high: ?f64,114    options: StripOptions,115) Allocator.Error![]u8 {116    var out: std.ArrayList(u8) = .empty;117    var domain = empty_domain;118    for (samples) |sample| domain.observe(@floatFromInt(sample));119    domain.observe(median);120    domain.observe(low);121    domain.observe(high);122    try openSvg(&out, allocator, options.width, options.height, "chart-strip-figure");123    if (!domain.seen()) {124        try emptyText(&out, allocator, options.width, options.height);125        try out.appendSlice(allocator, "</svg>");126        return try out.toOwnedSlice(allocator);127    }128129    const plot = Plot{130        .x0 = 8,131        .x1 = options.width - 8,132        .y0 = 5,133        .y1 = options.height - 5,134        .domain = domain,135        .count = samples.len,136    };137138    if (low != null and high != null) {139        const band_x0 = plot.xValue(low.?);140        const band_x1 = plot.xValue(high.?);141        try appendFmt(&out, allocator, "<rect class=\"chart-band\" x=\"{d:.2}\" y=\"{d:.2}\" width=\"{d:.2}\" height=\"{d:.2}\"/>", .{142            @min(band_x0, band_x1),143            plot.y0,144            @abs(band_x1 - band_x0),145            plot.y1 - plot.y0,146        });147    }148    if (median) |actual| {149        const x = plot.xValue(actual);150        try appendFmt(&out, allocator, "<line class=\"chart-median\" x1=\"{d:.2}\" y1=\"{d:.2}\" x2=\"{d:.2}\" y2=\"{d:.2}\"><title>median ", .{ x, plot.y0, x, plot.y1 });151        try appendEscapedText(&out, allocator, try options.format(allocator, actual));152        try out.appendSlice(allocator, "</title></line>");153    }154155    const stride = if (samples.len > max_strip_dots) samples.len / max_strip_dots + 1 else 1;156    const middle = (plot.y0 + plot.y1) / 2;157    const amplitude = (plot.y1 - plot.y0) / 2 - 3;158    const observation_fmt =159        "<circle class=\"chart-sample\" cx=\"{d:.2}\" cy=\"{d:.2}\" r=\"2\">" ++160        "<title>observation {d}: ";161    var index: usize = 0;162    while (index < samples.len) : (index += stride) {163        const value: f64 = @floatFromInt(samples[index]);164        const offsets = [_]f64{ 0, -0.5, 0.5, -1, 1 };165        const jitter = offsets[index % offsets.len] * amplitude;166        try appendFmt(&out, allocator, observation_fmt, .{167            plot.xValue(value),168            middle + jitter,169            index,170        });171        try appendEscapedText(&out, allocator, try options.format(allocator, value));172        try out.appendSlice(allocator, "</title></circle>");173    }174    try out.appendSlice(allocator, "</svg>");175    return try out.toOwnedSlice(allocator);176}177178pub fn sequence(179    allocator: Allocator,180    samples: []const u64,181    median: ?f64,182    low: ?f64,183    high: ?f64,184    options: SequenceOptions,185) Allocator.Error![]u8 {186    var out: std.ArrayList(u8) = .empty;187    var domain = empty_domain;188    for (samples) |sample| domain.observe(@floatFromInt(sample));189    domain.observe(median);190    domain.observe(low);191    domain.observe(high);192    try openSvg(&out, allocator, options.width, options.height, "chart-sequence-figure");193    if (samples.len == 0) {194        try emptyText(&out, allocator, options.width, options.height);195        try out.appendSlice(allocator, "</svg>");196        return try out.toOwnedSlice(allocator);197    }198    const indices = try sequenceIndices(allocator, samples);199    defer allocator.free(indices);200    const plot = Plot{201        .x0 = 8,202        .x1 = options.width - 8,203        .y0 = 5,204        .y1 = options.height - 5,205        .domain = domain,206        .count = samples.len,207    };208    try sequenceSummary(&out, allocator, plot, median, low, high, options.format);209    try sequencePath(&out, allocator, plot, samples, indices);210    try sequenceDots(&out, allocator, plot, samples, indices, options);211    try out.appendSlice(allocator, "</svg>");212    return try out.toOwnedSlice(allocator);213}214215fn sequenceIndices(allocator: Allocator, samples: []const u64) Allocator.Error![]usize {216    var indices: std.ArrayList(usize) = .empty;217    errdefer indices.deinit(allocator);218    try indices.ensureTotalCapacity(allocator, @min(samples.len, max_sequence_points));219    if (samples.len <= max_sequence_points) {220        for (samples, 0..) |_, index| indices.appendAssumeCapacity(index);221        return try indices.toOwnedSlice(allocator);222    }223    indices.appendAssumeCapacity(0);224    const bucket_count = (max_sequence_points - 2) / 2;225    const interior = samples.len - 2;226    const base_width = interior / bucket_count;227    const wide_buckets = interior % bucket_count;228    var start: usize = 1;229    for (0..bucket_count) |bucket| {230        const stop = start + base_width + @intFromBool(bucket < wide_buckets);231        var min_index = start;232        var max_index = start;233        for (start + 1..stop) |index| {234            if (samples[index] < samples[min_index]) min_index = index;235            if (samples[index] > samples[max_index]) max_index = index;236        }237        indices.appendAssumeCapacity(@min(min_index, max_index));238        if (min_index != max_index) indices.appendAssumeCapacity(@max(min_index, max_index));239        start = stop;240    }241    indices.appendAssumeCapacity(samples.len - 1);242    std.debug.assert(indices.items.len <= max_sequence_points);243    return try indices.toOwnedSlice(allocator);244}245246fn sequenceSummary(247    out: *std.ArrayList(u8),248    allocator: Allocator,249    plot: Plot,250    median: ?f64,251    low: ?f64,252    high: ?f64,253    format: Format,254) Allocator.Error!void {255    if (low != null and high != null) {256        const y0 = plot.yValue(@max(low.?, high.?));257        const y1 = plot.yValue(@min(low.?, high.?));258        try appendFmt(out, allocator, "<rect class=\"chart-band\" x=\"{d:.2}\" y=\"{d:.2}\" " ++259            "width=\"{d:.2}\" height=\"{d:.2}\"/>", .{260            plot.x0,261            y0,262            plot.x1 - plot.x0,263            y1 - y0,264        });265    }266    if (median) |value| {267        const y = plot.yValue(value);268        try appendFmt(out, allocator, "<line class=\"chart-median\" x1=\"{d:.2}\" y1=\"{d:.2}\" " ++269            "x2=\"{d:.2}\" y2=\"{d:.2}\"><title>median ", .{270            plot.x0,271            y,272            plot.x1,273            y,274        });275        try appendEscapedText(out, allocator, try format(allocator, value));276        try out.appendSlice(allocator, "</title></line>");277    }278}279280fn sequencePath(281    out: *std.ArrayList(u8),282    allocator: Allocator,283    plot: Plot,284    samples: []const u64,285    indices: []const usize,286) Allocator.Error!void {287    if (indices.len < 2) return;288    try out.appendSlice(allocator, "<path class=\"chart-line\" d=\"");289    for (indices, 0..) |index, path_index| {290        try appendFmt(out, allocator, "{s}{d:.2} {d:.2} ", .{291            if (path_index == 0) "M" else "L",292            plot.xIndex(index),293            plot.yValue(@floatFromInt(samples[index])),294        });295    }296    try out.appendSlice(allocator, "\"/>");297}298299fn sequenceDots(300    out: *std.ArrayList(u8),301    allocator: Allocator,302    plot: Plot,303    samples: []const u64,304    indices: []const usize,305    options: SequenceOptions,306) Allocator.Error!void {307    const point_fmt =308        "<circle class=\"chart-dot chart-sequence-sample\" cx=\"{d:.2}\" " ++309        "cy=\"{d:.2}\" r=\"2\"><title>sample {d}: ";310    for (indices) |index| {311        const value: f64 = @floatFromInt(samples[index]);312        const display_index = std.math.add(313            u64,314            options.index_origin,315            @intCast(index),316        ) catch std.math.maxInt(u64);317        try appendFmt(out, allocator, point_fmt, .{318            plot.xIndex(index),319            plot.yValue(value),320            display_index,321        });322        try appendEscapedText(out, allocator, try options.format(allocator, value));323        try out.appendSlice(allocator, "</title></circle>");324    }325}326327pub fn xy(allocator: Allocator, points: []const XyPoint, options: XyOptions) Allocator.Error![]u8 {328    var out: std.ArrayList(u8) = .empty;329    try openSvg(&out, allocator, options.width, options.height, "chart-xy-figure");330    if (points.len == 0) {331        try emptyText(&out, allocator, options.width, options.height);332        try out.appendSlice(allocator, "</svg>");333        return try out.toOwnedSlice(allocator);334    }335336    var x_domain = empty_domain;337    var y_domain = empty_domain;338    y_domain.observe(0);339    for (points) |point| {340        x_domain.observe(point.x);341        y_domain.observe(point.y);342    }343    const plot = Plot{344        .x0 = 8,345        .x1 = options.width - 8,346        .y0 = 7,347        .y1 = options.height - 7,348        .domain = y_domain,349        .count = points.len,350    };351352    const zero_y = plot.yValue(0);353    try appendFmt(&out, allocator, "<line class=\"chart-grid\" x1=\"{d:.2}\" y1=\"{d:.2}\" x2=\"{d:.2}\" y2=\"{d:.2}\"/>", .{ plot.x0, zero_y, plot.x1, zero_y });354355    const order = try allocator.alloc(usize, points.len);356    for (order, 0..) |*slot, point_index| slot.* = point_index;357    std.mem.sort(usize, order, points, xyBefore);358359    if (points.len >= 2) {360        try out.appendSlice(allocator, "<path class=\"chart-line\" d=\"");361        for (order, 0..) |point_index, path_index| {362            const point = points[point_index];363            try appendFmt(&out, allocator, "{s}{d:.2} {d:.2} ", .{364                if (path_index == 0) "M" else "L",365                xyX(plot, x_domain, point.x),366                plot.yValue(point.y),367            });368        }369        try out.appendSlice(allocator, "\"/>");370    }371    for (order) |point_index| {372        const point = points[point_index];373        try appendFmt(&out, allocator, "<circle class=\"chart-dot\" cx=\"{d:.2}\" cy=\"{d:.2}\" r=\"2.5\"><title>", .{374            xyX(plot, x_domain, point.x),375            plot.yValue(point.y),376        });377        try appendEscapedText(&out, allocator, point.label);378        try out.appendSlice(allocator, "</title></circle>");379    }380    try out.appendSlice(allocator, "</svg>");381    return try out.toOwnedSlice(allocator);382}383384fn xyX(plot: Plot, x_domain: Domain, value: f64) f64 {385    if (x_domain.max == x_domain.min) return (plot.x0 + plot.x1) / 2;386    const fraction = (value - x_domain.min) / x_domain.span();387    return plot.x0 + fraction * (plot.x1 - plot.x0);388}389390fn xyBefore(points: []const XyPoint, left: usize, right: usize) bool {391    return points[left].x < points[right].x;392}393394const Plot = struct {395    x0: f64,396    x1: f64,397    y0: f64,398    y1: f64,399    domain: Domain,400    count: usize,401402    fn xIndex(self: Plot, index: usize) f64 {403        if (self.count <= 1) return (self.x0 + self.x1) / 2;404        const fraction = @as(f64, @floatFromInt(index)) / @as(f64, @floatFromInt(self.count - 1));405        return self.x0 + fraction * (self.x1 - self.x0);406    }407408    fn xValue(self: Plot, value: f64) f64 {409        if (self.domain.max == self.domain.min) return (self.x0 + self.x1) / 2;410        const fraction = (value - self.domain.min) / self.domain.span();411        return self.x0 + fraction * (self.x1 - self.x0);412    }413414    fn yValue(self: Plot, value: f64) f64 {415        if (self.domain.max == self.domain.min) return (self.y0 + self.y1) / 2;416        const fraction = (value - self.domain.min) / self.domain.span();417        return self.y1 - fraction * (self.y1 - self.y0);418    }419};420421fn openSvg(out: *std.ArrayList(u8), allocator: Allocator, width: f64, height: f64, class: []const u8) Allocator.Error!void {422    try appendFmt(out, allocator, "<svg class=\"{s}\" viewBox=\"0 0 {d:.0} {d:.0}\" width=\"{d:.0}\" height=\"{d:.0}\" role=\"img\">", .{423        class,424        width,425        height,426        width,427        height,428    });429}430431fn emptyText(out: *std.ArrayList(u8), allocator: Allocator, width: f64, height: f64) Allocator.Error!void {432    try appendFmt(out, allocator, "<text class=\"chart-empty\" x=\"{d:.0}\" y=\"{d:.0}\" text-anchor=\"middle\">no data</text>", .{433        width / 2,434        height / 2 + 4,435    });436}437438fn lineTicks(out: *std.ArrayList(u8), allocator: Allocator, plot: Plot, format: Format) Allocator.Error!void {439    const rows = [_]f64{ plot.domain.max, (plot.domain.max + plot.domain.min) / 2, plot.domain.min };440    for (rows) |value| {441        const y = plot.yValue(value);442        try appendFmt(out, allocator, "<line class=\"chart-grid\" x1=\"{d:.2}\" y1=\"{d:.2}\" x2=\"{d:.2}\" y2=\"{d:.2}\"/>", .{ plot.x0, y, plot.x1, y });443        try appendFmt(out, allocator, "<text class=\"chart-tick\" x=\"{d:.2}\" y=\"{d:.2}\" text-anchor=\"end\">", .{ plot.x0 - 6, y + 3 });444        try appendEscapedText(out, allocator, try format(allocator, value));445        try out.appendSlice(allocator, "</text>");446    }447}448449fn lineBand(out: *std.ArrayList(u8), allocator: Allocator, points: []const Point, plot: Plot) Allocator.Error!void {450    var start: usize = 0;451    while (start < points.len) {452        while (start < points.len and !banded(points[start])) start += 1;453        if (start >= points.len) return;454        var stop = start;455        while (stop < points.len and banded(points[stop])) stop += 1;456        if (stop - start >= 2) {457            try out.appendSlice(allocator, "<path class=\"chart-band\" d=\"");458            var index = start;459            while (index < stop) : (index += 1) {460                try appendFmt(out, allocator, "{s}{d:.2} {d:.2} ", .{ if (index == start) "M" else "L", plot.xIndex(index), plot.yValue(points[index].high.?) });461            }462            index = stop;463            while (index > start) {464                index -= 1;465                try appendFmt(out, allocator, "L{d:.2} {d:.2} ", .{ plot.xIndex(index), plot.yValue(points[index].low.?) });466            }467            try out.appendSlice(allocator, "Z\"/>");468        }469        start = stop;470    }471}472473fn banded(point: Point) bool {474    return point.value != null and point.low != null and point.high != null;475}476477fn linePath(out: *std.ArrayList(u8), allocator: Allocator, points: []const Point, plot: Plot) Allocator.Error!void {478    var start: usize = 0;479    while (start < points.len) {480        while (start < points.len and points[start].value == null) start += 1;481        if (start >= points.len) return;482        var stop = start;483        while (stop < points.len and points[stop].value != null) stop += 1;484        if (stop - start >= 2) {485            try out.appendSlice(allocator, "<path class=\"chart-line\" d=\"");486            var index = start;487            while (index < stop) : (index += 1) {488                try appendFmt(out, allocator, "{s}{d:.2} {d:.2} ", .{ if (index == start) "M" else "L", plot.xIndex(index), plot.yValue(points[index].value.?) });489            }490            try out.appendSlice(allocator, "\"/>");491        }492        start = stop;493    }494}495496fn lineDots(out: *std.ArrayList(u8), allocator: Allocator, points: []const Point, plot: Plot, format: Format) Allocator.Error!void {497    for (points, 0..) |point, index| {498        const value = point.value orelse continue;499        try appendFmt(out, allocator, "<circle class=\"chart-dot\" cx=\"{d:.2}\" cy=\"{d:.2}\" r=\"2.5\"><title>", .{500            plot.xIndex(index),501            plot.yValue(value),502        });503        try appendEscapedText(out, allocator, point.label);504        try out.appendSlice(allocator, ": ");505        try appendEscapedText(out, allocator, try format(allocator, value));506        if (point.low != null and point.high != null) {507            try out.appendSlice(allocator, " (");508            try appendEscapedText(out, allocator, try format(allocator, point.low.?));509            try out.appendSlice(allocator, " .. ");510            try appendEscapedText(out, allocator, try format(allocator, point.high.?));511            try out.appendSlice(allocator, ")");512        }513        try out.appendSlice(allocator, "</title></circle>");514    }515}516517fn appendFmt(out: *std.ArrayList(u8), allocator: Allocator, comptime fmt: []const u8, args: anytype) Allocator.Error!void {518    const text = try std.fmt.allocPrint(allocator, fmt, args);519    defer allocator.free(text);520    try out.appendSlice(allocator, text);521}522523fn appendEscapedText(out: *std.ArrayList(u8), allocator: Allocator, text: []const u8) Allocator.Error!void {524    try zen.html.appendEscaped(out, allocator, text);525}526527fn formatRaw(allocator: Allocator, value: f64) Allocator.Error![]u8 {528    return std.fmt.allocPrint(allocator, "{d:.1}", .{value});529}530531test "chart line renders band path and dots" {532    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);533    defer arena_state.deinit();534    const allocator = arena_state.allocator();535    const points = [_]Point{536        .{ .label = "run a", .value = 10, .low = 9, .high = 11 },537        .{ .label = "run b", .value = 20, .low = 18, .high = 22 },538        .{ .label = "run c", .value = 15, .low = 14, .high = 16 },539    };540    const svg = try line(allocator, &points, .{ .format = formatRaw });541    try std.testing.expectEqual(@as(usize, 3), std.mem.count(u8, svg, "chart-dot"));542    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-band"));543    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-line\""));544    try std.testing.expect(std.mem.indexOf(u8, svg, "run b: 20.0 (18.0 .. 22.0)") != null);545}546547test "chart line skips gaps and handles empty series" {548    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);549    defer arena_state.deinit();550    const allocator = arena_state.allocator();551    const gapped = [_]Point{552        .{ .label = "a", .value = 5 },553        .{ .label = "b", .value = null },554        .{ .label = "c", .value = 6 },555    };556    const svg = try line(allocator, &gapped, .{ .format = formatRaw });557    try std.testing.expectEqual(@as(usize, 2), std.mem.count(u8, svg, "chart-dot"));558    try std.testing.expectEqual(@as(usize, 0), std.mem.count(u8, svg, "chart-line\""));559560    const empty = try line(allocator, &.{}, .{ .format = formatRaw });561    try std.testing.expect(std.mem.indexOf(u8, empty, "no data") != null);562}563564test "chart line single point centers a dot" {565    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);566    defer arena_state.deinit();567    const allocator = arena_state.allocator();568    const points = [_]Point{.{ .label = "only", .value = 42 }};569    const svg = try line(allocator, &points, .{ .format = formatRaw, .ticks = true });570    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-dot"));571    try std.testing.expectEqual(@as(usize, 3), std.mem.count(u8, svg, "chart-grid"));572}573574test "chart strip renders samples median and band" {575    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);576    defer arena_state.deinit();577    const allocator = arena_state.allocator();578    const samples = [_]u64{ 100, 120, 110, 130, 105 };579    const svg = try strip(allocator, &samples, 110, 104, 126, .{ .format = formatRaw });580    try std.testing.expectEqual(@as(usize, 5), std.mem.count(u8, svg, "chart-sample"));581    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-median"));582    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-band"));583    try std.testing.expect(std.mem.indexOf(u8, svg, "observation 0: 100.0") != null);584585    const empty = try strip(allocator, &.{}, null, null, null, .{ .format = formatRaw });586    try std.testing.expect(std.mem.indexOf(u8, empty, "no data") != null);587}588589test "chart sequence renders acquisition order with summary context" {590    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);591    defer arena_state.deinit();592    const allocator = arena_state.allocator();593    const samples = [_]u64{ 130, 100, 120, 110 };594    const svg = try sequence(595        allocator,596        &samples,597        115,598        105,599        125,600        .{ .format = formatRaw, .index_origin = 7 },601    );602    try std.testing.expectEqual(@as(usize, 4), std.mem.count(u8, svg, "chart-sequence-sample"));603    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-median"));604    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-band"));605    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-line\""));606    const first = std.mem.indexOf(u8, svg, "sample 7: 130.0").?;607    const second = std.mem.indexOf(u8, svg, "sample 8: 100.0").?;608    try std.testing.expect(first < second);609}610611test "chart sequence bounds points and preserves extrema" {612    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);613    defer arena_state.deinit();614    const allocator = arena_state.allocator();615    var samples = @as([2000]u64, @splat(100));616    samples[1000] = 999;617    samples[1200] = 1;618    const svg = try sequence(allocator, &samples, null, null, null, .{ .format = formatRaw });619    const points = std.mem.count(u8, svg, "chart-sequence-sample");620    try std.testing.expect(points <= max_sequence_points);621    try std.testing.expect(std.mem.indexOf(u8, svg, "sample 0: 100.0") != null);622    try std.testing.expect(std.mem.indexOf(u8, svg, "sample 1000: 999.0") != null);623    try std.testing.expect(std.mem.indexOf(u8, svg, "sample 1200: 1.0") != null);624    try std.testing.expect(std.mem.indexOf(u8, svg, "sample 1999: 100.0") != null);625}626627test "chart xy sorts by x and anchors the zero line" {628    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);629    defer arena_state.deinit();630    const allocator = arena_state.allocator();631    const points = [_]XyPoint{632        .{ .x = 20, .y = 18, .label = "+20% virtual: +18% program" },633        .{ .x = 0, .y = 0, .label = "baseline" },634        .{ .x = 10, .y = -4, .label = "+10% virtual: -4% program" },635    };636    const svg = try xy(allocator, &points, .{});637    try std.testing.expectEqual(@as(usize, 3), std.mem.count(u8, svg, "chart-dot"));638    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-grid"));639    try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, svg, "chart-line\""));640    try std.testing.expect(std.mem.indexOf(u8, svg, "d=\"M8.00") != null);641    try std.testing.expect(std.mem.indexOf(u8, svg, "+20% virtual") != null);642643    const empty = try xy(allocator, &.{}, .{});644    try std.testing.expect(std.mem.indexOf(u8, empty, "no data") != null);645}646647test "chart strip strides oversized sample sets" {648    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);649    defer arena_state.deinit();650    const allocator = arena_state.allocator();651    var samples: [2000]u64 = undefined;652    for (&samples, 0..) |*sample, index| sample.* = index;653    const svg = try strip(allocator, &samples, null, null, null, .{ .format = formatRaw });654    const dots = std.mem.count(u8, svg, "chart-sample");655    try std.testing.expect(dots <= max_strip_dots);656    try std.testing.expect(dots > 400);657}

1pub const chart = @import("chart.zig");