diff --git a/lib/std/event/channel.zig b/lib/std/event/channel.zig
index 2bcf6a4c5001b113f436a2d9f4395b4bb914c60f..fd70f73aabf6fee17480c3050a63ce788eb56c47 100644
--- a/lib/std/event/channel.zig
+++ b/lib/std/event/channel.zig
@@ -267,17 +267,16 @@ pub fn Channel(comptime T: type) type {
 }
 
 test "std.event.Channel" {
+    if (!std.io.is_async) return error.SkipZigTest;
+
     // https://github.com/ziglang/zig/issues/1908
     if (builtin.single_threaded) return error.SkipZigTest;
 
     // https://github.com/ziglang/zig/issues/3251
     if (builtin.os == .freebsd) return error.SkipZigTest;
 
-    // TODO provide a way to run tests in evented I/O mode
-    if (!std.io.is_async) return error.SkipZigTest;
-
     var channel: Channel(i32) = undefined;
-    channel.init([0]i32{});
+    channel.init(&[0]i32{});
     defer channel.deinit();
 
     var handle = async testChannelGetter(&channel);
diff --git a/lib/std/event/group.zig b/lib/std/event/group.zig
index 2668096615d50205c6f69ac5c6f97c8fe5c9fa08..98ebdbd1f86daf6d0090acc14c43c9e61b68c7a9 100644
--- a/lib/std/event/group.zig
+++ b/lib/std/event/group.zig
@@ -22,7 +22,7 @@ pub fn Group(comptime ReturnType: type) type {
         const AllocStack = std.atomic.Stack(Node);
 
         pub const Node = struct {
-            bytes: []const u8 = [0]u8{},
+            bytes: []const u8 = &[0]u8{},
             handle: anyframe->ReturnType,
         };
 
diff --git a/lib/std/event/lock.zig b/lib/std/event/lock.zig
index a95c5bf7e2425c31141f5e586bc7d781fe1e2ea7..e1b3495e5c152ab93ca596fef23b611c5cd5c448 100644
--- a/lib/std/event/lock.zig
+++ b/lib/std/event/lock.zig
@@ -117,21 +117,21 @@ pub const Lock = struct {
 };
 
 test "std.event.Lock" {
+    if (!std.io.is_async) return error.SkipZigTest;
+
     // TODO https://github.com/ziglang/zig/issues/1908
     if (builtin.single_threaded) return error.SkipZigTest;
 
     // TODO https://github.com/ziglang/zig/issues/3251
     if (builtin.os == .freebsd) return error.SkipZigTest;
 
-    // TODO provide a way to run tests in evented I/O mode
-    if (!std.io.is_async) return error.SkipZigTest;
-
     var lock = Lock.init();
     defer lock.deinit();
 
     _ = async testLock(&lock);
 
-    testing.expectEqualSlices(i32, [1]i32{3 * @intCast(i32, shared_test_data.len)} ** shared_test_data.len, shared_test_data);
+    const expected_result = [1]i32{3 * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;
+    testing.expectEqualSlices(i32, &expected_result, &shared_test_data);
 }
 
 async fn testLock(lock: *Lock) void {
diff --git a/lib/std/fs/watch.zig b/lib/std/fs/watch.zig
index d7a298aa5df0a8d479bd7c9294b17a980bbd1d77..c904f110e2f5475ca0b23c3f94f5aa39a294d4f9 100644
--- a/lib/std/fs/watch.zig
+++ b/lib/std/fs/watch.zig
@@ -615,12 +615,11 @@ pub fn Watch(comptime V: type) type {
 const test_tmp_dir = "std_event_fs_test";
 
 test "write a file, watch it, write it again" {
-    // TODO provide a way to run tests in evented I/O mode
-    if (!std.io.is_async) return error.SkipZigTest;
+    // TODO re-enable this test
+    if (true) return error.SkipZigTest;
 
     const allocator = std.heap.page_allocator;
 
-    // TODO move this into event loop too
     try os.makePath(allocator, test_tmp_dir);
     defer os.deleteTree(test_tmp_dir) catch {};
 
diff --git a/lib/std/net/test.zig b/lib/std/net/test.zig
index 2dd11b391ec9dc92d745e21274d6d0fce0d25a1e..703a804bfb276ea2de833dbd81a3c550c9ca32d0 100644
--- a/lib/std/net/test.zig
+++ b/lib/std/net/test.zig
@@ -81,17 +81,15 @@ test "resolve DNS" {
 }
 
 test "listen on a port, send bytes, receive bytes" {
+    if (!std.io.is_async) return error.SkipZigTest;
+
     if (std.builtin.os != .linux) {
         // TODO build abstractions for other operating systems
         return error.SkipZigTest;
     }
-    if (std.io.mode != .evented) {
-        // TODO add ability to run tests in non-blocking I/O mode
-        return error.SkipZigTest;
-    }
 
     // TODO doing this at comptime crashed the compiler
-    const localhost = net.Address.parseIp("127.0.0.1", 0);
+    const localhost = try net.Address.parseIp("127.0.0.1", 0);
 
     var server = net.StreamServer.init(net.StreamServer.Options{});
     defer server.deinit();