diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 2483bbea69..7e59ce052e 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -33,10 +33,10 @@ test "correct size of packed structs" {
 }
 
 test "flags in packed structs" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
     const Flags1 = packed struct {
-        // byte 0
+        // first 8 bits
         b0_0: u1,
         b0_1: u1,
         b0_2: u1,
@@ -46,7 +46,7 @@ test "flags in packed structs" {
         b0_6: u1,
         b0_7: u1,
 
-        // partial byte 1 (but not 8 bits)
+        // 7 more bits
         b1_0: u1,
         b1_1: u1,
         b1_2: u1,
@@ -55,12 +55,12 @@ test "flags in packed structs" {
         b1_5: u1,
         b1_6: u1,
 
-        // some padding to fill to size 3
+        // some padding to fill to 24 bits
         _: u9,
     };
 
-    try expectEqual(3, @sizeOf(Flags1));
-    try expectEqual(3 * 8, @bitSizeOf(Flags1));
+    try expectEqual(@sizeOf(u24), @sizeOf(Flags1));
+    try expectEqual(24, @bitSizeOf(Flags1));
 
     const Flags2 = packed struct {
         // byte 0
@@ -86,8 +86,8 @@ test "flags in packed structs" {
         _: u10,
     };
 
-    try expectEqual(4, @sizeOf(Flags2));
-    try expectEqual(8 + 7 + 10, @bitSizeOf(Flags2));
+    try expectEqual(@sizeOf(u25), @sizeOf(Flags2));
+    try expectEqual(25, @bitSizeOf(Flags2));
 
     const Flags3 = packed struct {
         // byte 0
@@ -114,30 +114,30 @@ test "flags in packed structs" {
         _: u16, // it works, if the padding is 8-based
     };
 
-    try expectEqual(4, @sizeOf(Flags3));
-    try expectEqual(4 * 8, @bitSizeOf(Flags3));
+    try expectEqual(@sizeOf(u32), @sizeOf(Flags3));
+    try expectEqual(32, @bitSizeOf(Flags3));
 }
 
 test "arrays in packed structs" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
     const T1 = packed struct { array: [3][3]u8 };
     const T2 = packed struct { array: [9]u8 };
 
-    try expectEqual(9, @sizeOf(T1));
-    try expectEqual(9 * 8, @bitSizeOf(T1));
-    try expectEqual(9, @sizeOf(T2));
-    try expectEqual(9 * 8, @bitSizeOf(T2));
+    try expectEqual(@sizeOf(u72), @sizeOf(T1));
+    try expectEqual(72, @bitSizeOf(T1));
+    try expectEqual(@sizeOf(u72), @sizeOf(T2));
+    try expectEqual(72, @bitSizeOf(T2));
 }
 
 test "consistent size of packed structs" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
     const TxData1 = packed struct { data: u8, _23: u23, full: bool = false };
     const TxData2 = packed struct { data: u9, _22: u22, full: bool = false };
 
     const register_size_bits = 32;
-    const register_size_bytes = register_size_bits / 8;
+    const register_size_bytes = @sizeOf(u32);
 
     try expectEqual(register_size_bits, @bitSizeOf(TxData1));
     try expectEqual(register_size_bytes, @sizeOf(TxData1));
@@ -151,7 +151,7 @@ test "consistent size of packed structs" {
     const TxData6 = packed struct { a: u24, b: u32 };
 
     const expectedBitSize = 56;
-    const expectedByteSize = expectedBitSize / 8;
+    const expectedByteSize = @sizeOf(u56);
 
     try expectEqual(expectedBitSize, @bitSizeOf(TxData3));
     try expectEqual(expectedByteSize, @sizeOf(TxData3));
@@ -167,7 +167,12 @@ test "consistent size of packed structs" {
 }
 
 test "correct sizeOf and offsets in packed structs" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const PStruct = packed struct {
         bool_a: bool,
@@ -234,7 +239,7 @@ test "correct sizeOf and offsets in packed structs" {
 
     try expectEqual(16, @offsetOf(S, "b"));
     try expectEqual(128, @bitOffsetOf(S, "b"));
-    try expectEqual(20, @sizeOf(S));
+    try expectEqual(@sizeOf(u160), @sizeOf(S));
 }
 
 test "nested packed structs" {