lib/tracy/src/cli/args/stats.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const std = @import("std");
 2 const tracy = @import("../../root.zig");
 3 const scalar = @import("scalar.zig");
 4 const types = @import("types.zig");
 5 
 6 pub fn parse(args: []const []const u8) !types.StatsArgs {
 7     if (args.len == 0) return error.InvalidArguments;
 8     var parsed = types.StatsArgs{ .path = args[0] };
 9     var index: usize = 1;
10     while (index < args.len) : (index += 1) {
11         if (std.mem.eql(u8, args[index], "--format")) {
12             index += 1;
13             if (index >= args.len) return error.InvalidArguments;
14             if (std.mem.eql(u8, args[index], "text")) {
15                 parsed.format = .text;
16             } else if (std.mem.eql(u8, args[index], "jsonl")) {
17                 parsed.format = .jsonl;
18             } else {
19                 return error.UnsupportedFormat;
20             }
21         } else if (std.mem.eql(u8, args[index], "--top")) {
22             index += 1;
23             if (index >= args.len) return error.InvalidArguments;
24             parsed.options.top = try scalar.parsePositiveUsize(args[index]);
25         } else if (std.mem.eql(u8, args[index], "--sort")) {
26             index += 1;
27             if (index >= args.len) return error.InvalidArguments;
28             parsed.options.sort = tracy.stats.Sort.fromName(args[index]) orelse return error.UnsupportedSort;
29         } else if (std.mem.eql(u8, args[index], "--min-total-ns")) {
30             index += 1;
31             if (index >= args.len) return error.InvalidArguments;
32             parsed.options.min_total_ns = try scalar.parseU64(args[index]);
33         } else if (std.mem.eql(u8, args[index], "--min-self-ns")) {
34             index += 1;
35             if (index >= args.len) return error.InvalidArguments;
36             parsed.options.min_self_ns = try scalar.parseU64(args[index]);
37         } else if (std.mem.eql(u8, args[index], "--thread")) {
38             index += 1;
39             if (index >= args.len) return error.InvalidArguments;
40             parsed.options.thread = try scalar.parseU64(args[index]);
41         } else {
42             return error.UnknownArgument;
43         }
44     }
45     return parsed;
46 }
47 
48 test "stats args parse filters and sort" {
49     const parsed = try parse(&.{
50         "events.jsonl",
51         "--format",
52         "jsonl",
53         "--top",
54         "12",
55         "--sort",
56         "threads",
57         "--min-total-ns",
58         "100",
59         "--min-self-ns",
60         "20",
61         "--thread",
62         "7",
63     });
64     try std.testing.expectEqualStrings("events.jsonl", parsed.path);
65     try std.testing.expectEqual(types.Format.jsonl, parsed.format);
66     try std.testing.expectEqual(@as(usize, 12), parsed.options.top);
67     try std.testing.expectEqual(tracy.stats.Sort.threads, parsed.options.sort);
68     try std.testing.expectEqual(@as(u64, 100), parsed.options.min_total_ns);
69     try std.testing.expectEqual(@as(u64, 20), parsed.options.min_self_ns);
70     try std.testing.expectEqual(@as(?u64, 7), parsed.options.thread);
71 }