lib/sys/src/test.zig
daab053ee43316e1809a84551d573ddd1e5bf3d2
1 const std = @import("std");
2 const builtin = @import("builtin");
3 const subject = @import("root.zig");
4
5 const allocator = subject.allocator;
6 const ancillary = subject.ancillary;
7 const apple = subject.apple;
8 const audio = subject.audio;
9 const backtrace = subject.backtrace;
10 const capabilities = subject.capabilities;
11 const context = subject.context;
12 const coreaudio = subject.coreaudio;
13 const cuda = subject.cuda;
14 const desktop = subject.desktop;
15 const dynamic = subject.dynamic;
16 const env = subject.env;
17 const errno = subject.errno;
18 const evdev = subject.evdev;
19 const event = subject.event;
20 const fd = subject.fd;
21 const font = subject.font;
22 const fs = subject.fs;
23 const heap = subject.heap;
24 const kvm = subject.kvm;
25 const math = subject.math;
26 const memory = subject.memory;
27 const net = subject.net;
28 const path = subject.path;
29 const panic = subject.panic;
30 const perf = subject.perf;
31 const poll = subject.poll;
32 const process = subject.process;
33 const pty = subject.pty;
34 const pulse = subject.pulse;
35 const random = subject.random;
36 const rseq = subject.rseq;
37 const signal = subject.signal;
38 const stdio = subject.stdio;
39 const std_options = subject.std_options;
40 const terminal = subject.terminal;
41 const thread = subject.thread;
42 const time = subject.time;
43 const timer = subject.timer;
44 const tinyrt = subject.tinyrt;
45 const tls = subject.tls;
46 const vulkan = subject.vulkan;
47 const window_chrome = subject.window_chrome;
48 const x11 = subject.x11;
49
50 test "sys package namespace declares service capability requirements" {
51 std.testing.refAllDecls(subject);
52 _ = @import("atomic/test.zig");
53 _ = @import("apple/test.zig");
54 _ = @import("event/test.zig");
55 _ = @import("font/test.zig");
56 _ = @import("kvm/test.zig");
57 _ = @import("rseq/test.zig");
58 _ = @import("x11/test.zig");
59 try std.testing.expectEqual(capabilities.CapabilityTier.no_libc, allocator.required_capabilities.tier);
60 try std.testing.expect(allocator.required_capabilities.requires(.allocator));
61 try std.testing.expect(ancillary.required_capabilities.requires(.descriptors));
62 try std.testing.expect(ancillary.required_capabilities.requires(.networking));
63 try std.testing.expect(fd.required_capabilities.requires(.descriptors));
64 try std.testing.expect(tinyrt.required_capabilities.requires(.descriptors));
65 try std.testing.expect(tinyrt.required_capabilities.requires(.libc_interop));
66 try std.testing.expect(stdio.required_capabilities.requires(.standard_streams));
67 const net_tier: capabilities.CapabilityTier = switch (builtin.os.tag) {
68 .linux => .no_libc,
69 else => .host,
70 };
71 try std.testing.expectEqual(net_tier, net.required_capabilities.tier);
72 try std.testing.expect(net.required_capabilities.requires(.networking));
73 try std.testing.expect(net.required_capabilities.requires(.process));
74 try std.testing.expect(net.required_capabilities.requires(.random));
75 try std.testing.expect(event.required_capabilities.requires(.event_loop));
76 try std.testing.expect(poll.required_capabilities.requires(.event_loop));
77 try std.testing.expect(poll.required_capabilities.requires(.descriptors));
78 try std.testing.expect(memory.required_capabilities.requires(.memory_mapping));
79 try std.testing.expect(kvm.required_capabilities.requires(.virtualization));
80 try std.testing.expect(time.required_capabilities.requires(.time));
81
82 const random_tier: capabilities.CapabilityTier = switch (builtin.os.tag) {
83 .linux => .no_libc,
84 else => .host,
85 };
86 try std.testing.expectEqual(random_tier, random.required_capabilities.tier);
87 try std.testing.expect(random.required_capabilities.requires(.process));
88 try std.testing.expectEqual(capabilities.CapabilityTier.host, apple.required_capabilities.tier);
89 try std.testing.expect(apple.required_capabilities.requires(.platform_frameworks));
90 try std.testing.expect(!apple.required_capabilities.requires(.libc_interop));
91 try std.testing.expectEqual(capabilities.CapabilityTier.host, fs.required_capabilities.tier);
92 try std.testing.expect(fs.required_capabilities.requires(.filesystem));
93 try std.testing.expectEqual(capabilities.CapabilityTier.host, font.required_capabilities.tier);
94 try std.testing.expect(font.required_capabilities.requires(.filesystem));
95 try std.testing.expect(font.required_capabilities.requires(.environment));
96 try std.testing.expect(process.required_capabilities.requires(.process));
97 try std.testing.expect(pty.required_capabilities.requires(.terminal));
98 try std.testing.expect(env.required_capabilities.requires(.environment));
99 try std.testing.expect(thread.required_capabilities.requires(.threads));
100 try std.testing.expect(dynamic.required_capabilities.requires(.dynamic_loading));
101 try std.testing.expect(cuda.required_capabilities.requires(.dynamic_loading));
102 try std.testing.expect(vulkan.required_capabilities.requires(.dynamic_loading));
103 try std.testing.expect(random.required_capabilities.requires(.random));
104 }
105
106 test "fd read preserves Linux PTY child exit" {
107 if (comptime builtin.os.tag != .linux) return error.SkipZigTest;
108
109 const pair = pty.open() catch |err| switch (err) {
110 error.FileNotFound, error.AccessDenied => return error.SkipZigTest,
111 else => return err,
112 };
113 defer fd.close(pair.master);
114 var slave_owned = true;
115 defer if (slave_owned) fd.close(pair.slave);
116
117 var io_state = std.Io.Threaded.init(std.testing.allocator, .{});
118 defer io_state.deinit();
119 const io = io_state.io();
120 const slave_file = std.Io.File{
121 .handle = pair.slave,
122 .flags = .{ .nonblocking = false },
123 };
124 var child = try process.spawn(io, .{
125 .argv = &.{ "/bin/sh", "-c", "exit 0" },
126 .stdin = .{ .file = slave_file },
127 .stdout = .{ .file = slave_file },
128 .stderr = .{ .file = slave_file },
129 });
130 var child_owned = true;
131 defer if (child_owned) process.killAndReap(&child, io);
132
133 fd.close(pair.slave);
134 slave_owned = false;
135 const termination = try process.wait(&child, io);
136 child_owned = false;
137 try std.testing.expectEqual(@as(i64, 0), process.exitCode(termination));
138
139 var buffer: [1]u8 = undefined;
140 try std.testing.expectError(error.InputOutput, fd.read(pair.master, &buffer));
141 }
142
143 test {
144 _ = @import("fs.zig");
145 }
146
147 test {
148 _ = @import("process/tracing/test.zig");
149 _ = @import("process/inspect/test.zig");
150 }