aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/behavior.zig2
-rw-r--r--test/behavior/basic.zig90
-rw-r--r--test/behavior/memcpy.zig44
-rw-r--r--test/behavior/memset.zig146
4 files changed, 192 insertions, 90 deletions
diff --git a/test/behavior.zig b/test/behavior.zig
index b6fe8d120f..70293bf45d 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -177,6 +177,8 @@ test {
_ = @import("behavior/math.zig");
_ = @import("behavior/maximum_minimum.zig");
_ = @import("behavior/member_func.zig");
+ _ = @import("behavior/memcpy.zig");
+ _ = @import("behavior/memset.zig");
_ = @import("behavior/merge_error_sets.zig");
_ = @import("behavior/muladd.zig");
_ = @import("behavior/namespace_depends_on_compile_var.zig");
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 06b1fdda64..437b1b1373 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -353,96 +353,6 @@ 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();
- try comptime testMemcpyMemset();
-}
-
-fn testMemcpyMemset() !void {
- var foo: [20]u8 = undefined;
- var bar: [20]u8 = undefined;
-
- @memset(&foo, 'A');
- @memcpy(&bar, &foo);
-
- try expect(bar[0] == 'A');
- try expect(bar[11] == 'A');
- try expect(bar[19] == 'A');
-}
-
test "variable is allowed to be a pointer to an opaque type" {
var x: i32 = 1234;
_ = hereIsAnOpaqueType(@ptrCast(*OpaqueA, &x));
diff --git a/test/behavior/memcpy.zig b/test/behavior/memcpy.zig
new file mode 100644
index 0000000000..1d99a7163b
--- /dev/null
+++ b/test/behavior/memcpy.zig
@@ -0,0 +1,44 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const expect = std.testing.expect;
+
+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();
+ try comptime testMemcpyMemset();
+}
+
+fn testMemcpyMemset() !void {
+ var foo: [20]u8 = undefined;
+ var bar: [20]u8 = undefined;
+
+ @memset(&foo, 'A');
+ @memcpy(&bar, &foo);
+
+ try expect(bar[0] == 'A');
+ try expect(bar[11] == 'A');
+ try expect(bar[19] == 'A');
+}
+
+test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
+ 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;
+
+ try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
+ try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();
+}
+
+fn testMemcpyBothSinglePtrArrayOneIsNullTerminated() !void {
+ var buf: [100]u8 = undefined;
+ const suffix = "hello";
+ @memcpy(buf[buf.len - suffix.len ..], suffix);
+ try expect(buf[95] == 'h');
+ try expect(buf[96] == 'e');
+ try expect(buf[97] == 'l');
+ try expect(buf[98] == 'l');
+ try expect(buf[99] == 'o');
+}
diff --git a/test/behavior/memset.zig b/test/behavior/memset.zig
new file mode 100644
index 0000000000..2cc390a3c9
--- /dev/null
+++ b/test/behavior/memset.zig
@@ -0,0 +1,146 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const expect = std.testing.expect;
+
+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 "memset with bool element" {
+ 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) return error.SkipZigTest;
+
+ var buf: [5]bool = undefined;
+ @memset(&buf, true);
+ try expect(buf[2]);
+ try expect(buf[4]);
+}
+
+test "memset with 1-byte struct element" {
+ 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) return error.SkipZigTest;
+
+ const S = struct { x: bool };
+ var buf: [5]S = undefined;
+ @memset(&buf, .{ .x = true });
+ try expect(buf[2].x);
+ try expect(buf[4].x);
+}
+
+test "memset with 1-byte array element" {
+ 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) return error.SkipZigTest;
+
+ const A = [1]bool;
+ var buf: [5]A = undefined;
+ @memset(&buf, .{true});
+ try expect(buf[2][0]);
+ try expect(buf[4][0]);
+}
+
+test "memset with large array element, runtime known" {
+ 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) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
+ const A = [128]u64;
+ var buf: [5]A = undefined;
+ var runtime_known_element = [_]u64{0} ** 128;
+ @memset(&buf, runtime_known_element);
+ for (buf[0]) |elem| try expect(elem == 0);
+ for (buf[1]) |elem| try expect(elem == 0);
+ for (buf[2]) |elem| try expect(elem == 0);
+ for (buf[3]) |elem| try expect(elem == 0);
+ for (buf[4]) |elem| try expect(elem == 0);
+}
+
+test "memset with large array element, comptime known" {
+ 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) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
+ const A = [128]u64;
+ var buf: [5]A = undefined;
+ const comptime_known_element = [_]u64{0} ** 128;
+ @memset(&buf, comptime_known_element);
+ for (buf[0]) |elem| try expect(elem == 0);
+ for (buf[1]) |elem| try expect(elem == 0);
+ for (buf[2]) |elem| try expect(elem == 0);
+ for (buf[3]) |elem| try expect(elem == 0);
+ for (buf[4]) |elem| try expect(elem == 0);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-28 04:10:48 +0000