Commit 1ec8a7ab4c5346839ee9aa002aadee91d72903fe | zig

author	Travis Staloch <twostepted@gmail.com> 2025-08-31 12:38:35-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-08-31 19:29:02-07:00
log	1ec8a7ab4c5346839ee9aa002aadee91d72903fe
tree	0276a37f77bf6c24c370f89e443de7d1e3b6d262
parent	4c01a6553a1efef727b4f1cf7bb8dd9e53bd3cd5

Io.Writer.Allocating: test new *Aligned methods

* added initAligned()
* added missing @alignCast in toArrayListAligned()

1 files changed, 28 insertions(+), 4 deletions(-)

lib
- std
  - Io
    Writer.zig

lib/std/Io/Writer.zig+28-4

 @@ -2541,13 +2541,17 @@ pub const Allocating = struct {
     alignment: std.mem.Alignment,
     pub fn init(allocator: Allocator) Allocating {
+        return .initAligned(allocator, .of(u8));
+    }
+    pub fn initAligned(allocator: Allocator, alignment: std.mem.Alignment) Allocating {
         return .{
             .allocator = allocator,
             .writer = .{
                 .buffer = &.{},
                 .vtable = &vtable,
             },
-            .alignment = .of(u8),
+            .alignment = alignment,
         };
     }
 @@ -2775,16 +2779,36 @@ pub const Allocating = struct {
         a.ensureUnusedCapacity(minimum_len) catch return error.WriteFailed;
     }
-    test Allocating {
+    fn testAllocating(comptime alignment: std.mem.Alignment) !void {
-        var a: Allocating = .init(testing.allocator);
+        var a: Allocating = .initAligned(testing.allocator, alignment);
         defer a.deinit();
         const w = &a.writer;
         const x: i32 = 42;
         const y: i32 = 1234;
         try w.print("x: {}\ny: {}\n", .{ x, y });
+        const expected = "x: 42\ny: 1234\n";
+        try testing.expectEqualSlices(u8, expected, a.written());
+        // exercise *Aligned methods
+        var l = a.toArrayListAligned(alignment);
+        defer l.deinit(testing.allocator);
+        try testing.expectEqualSlices(u8, expected, l.items);
+        a = .fromArrayListAligned(testing.allocator, alignment, &l);
+        try testing.expectEqualSlices(u8, expected, a.written());
+        const slice: []align(alignment.toByteUnits()) u8 = @alignCast(try a.toOwnedSlice());
+        try testing.expectEqualSlices(u8, expected, slice);
+        a = .initOwnedSliceAligned(testing.allocator, alignment, slice);
+        try testing.expectEqualSlices(u8, expected, a.writer.buffer);
+    }
-        try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", a.written());
+    test Allocating {
+        try testAllocating(.fromByteUnits(1));
+        try testAllocating(.fromByteUnits(4));
+        try testAllocating(.fromByteUnits(8));
+        try testAllocating(.fromByteUnits(16));
+        try testAllocating(.fromByteUnits(32));
+        try testAllocating(.fromByteUnits(64));
     }
 };