Merge pull request #15278 from ziglang/memcpy-memset

change semantics of `@memcpy` and `@memset`

1 files changed, 72 insertions, 4 deletions

diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index c2e47d7334..d9c3dfb060 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -353,22 +353,90 @@ fn f2(x: bool) []const u8 {
     return (if (x) &fA else &fB)();
 }
 
+test "@memset on array pointers" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) {
+        // TODO: implement memset when element ABI size > 1
+        return error.SkipZigTest;
+    }
+
+    try testMemsetArray();
+    try comptime testMemsetArray();
+}
+
+fn testMemsetArray() !void {
+    {
+        // memset array to non-undefined, ABI size == 1
+        var foo: [20]u8 = undefined;
+        @memset(&foo, 'A');
+        try expect(foo[0] == 'A');
+        try expect(foo[11] == 'A');
+        try expect(foo[19] == 'A');
+    }
+    {
+        // memset array to non-undefined, ABI size > 1
+        var foo: [20]u32 = undefined;
+        @memset(&foo, 1234);
+        try expect(foo[0] == 1234);
+        try expect(foo[11] == 1234);
+        try expect(foo[19] == 1234);
+    }
+}
+
+test "@memset on slices" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) {
+        // TODO: implement memset when element ABI size > 1
+        // TODO: implement memset on slices
+        return error.SkipZigTest;
+    }
+
+    try testMemsetSlice();
+    try comptime testMemsetSlice();
+}
+
+fn testMemsetSlice() !void {
+    {
+        // memset slice to non-undefined, ABI size == 1
+        var array: [20]u8 = undefined;
+        var len = array.len;
+        var slice = array[0..len];
+        @memset(slice, 'A');
+        try expect(slice[0] == 'A');
+        try expect(slice[11] == 'A');
+        try expect(slice[19] == 'A');
+    }
+    {
+        // memset slice to non-undefined, ABI size > 1
+        var array: [20]u32 = undefined;
+        var len = array.len;
+        var slice = array[0..len];
+        @memset(slice, 1234);
+        try expect(slice[0] == 1234);
+        try expect(slice[11] == 1234);
+        try expect(slice[19] == 1234);
+    }
+}
+
 test "memcpy and memset intrinsics" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
 
     try testMemcpyMemset();
-    // TODO add comptime test coverage
-    //comptime try testMemcpyMemset();
+    try comptime testMemcpyMemset();
 }
 
 fn testMemcpyMemset() !void {
     var foo: [20]u8 = undefined;
     var bar: [20]u8 = undefined;
 
-    @memset(&foo, 'A', foo.len);
-    @memcpy(&bar, &foo, bar.len);
+    @memset(&foo, 'A');
+    @memcpy(&bar, &foo);
 
     try expect(bar[0] == 'A');
     try expect(bar[11] == 'A');