lib/tracy/src/cli/args/memory.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.MemoryArgs {
 7     if (args.len == 0) return error.InvalidArguments;
 8     var parsed = types.MemoryArgs{ .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], "--occurrences")) {
26             index += 1;
27             if (index >= args.len) return error.InvalidArguments;
28             parsed.options.occurrences = try scalar.parsePositiveUsize(args[index]);
29         } else if (std.mem.eql(u8, args[index], "--sort")) {
30             index += 1;
31             if (index >= args.len) return error.InvalidArguments;
32             parsed.options.sort = tracy.memory.Sort.fromName(args[index]) orelse return error.UnsupportedSort;
33         } else if (std.mem.eql(u8, args[index], "--min-live-bytes")) {
34             index += 1;
35             if (index >= args.len) return error.InvalidArguments;
36             parsed.options.min_live_bytes = try scalar.parseU64(args[index]);
37         } else if (std.mem.eql(u8, args[index], "--name")) {
38             index += 1;
39             if (index >= args.len) return error.InvalidArguments;
40             parsed.options.name = args[index];
41         } else {
42             return error.UnknownArgument;
43         }
44     }
45     return parsed;
46 }
47 
48 test "memory args parse filters and sort" {
49     const parsed = try parse(&.{
50         "events.jsonl",
51         "--format",
52         "jsonl",
53         "--top",
54         "12",
55         "--occurrences",
56         "7",
57         "--sort",
58         "lifetime-tail",
59         "--min-live-bytes",
60         "100",
61         "--name",
62         "arena",
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(@as(usize, 7), parsed.options.occurrences);
68     try std.testing.expectEqual(tracy.memory.Sort.lifetime_tail, parsed.options.sort);
69     try std.testing.expectEqual(@as(u64, 100), parsed.options.min_live_bytes);
70     try std.testing.expectEqualStrings("arena", parsed.options.name.?);
71 }