1const std = @import("std");
2const builtin = @import("builtin");
3const expect = std.testing.expect;
4
5test "@memset on array pointers" {
6 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
8 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9
10 try testMemsetArray();
11 try comptime testMemsetArray();
12}
13
14fn testMemsetArray() !void {
15 {
16 // memset array to non-undefined, ABI size == 1
17 var foo: [20]u8 = undefined;
18 @memset(&foo, 'A');
19 try expect(foo[0] == 'A');
20 try expect(foo[11] == 'A');
21 try expect(foo[19] == 'A');
22 }
23 {
24 // memset array to non-undefined, ABI size > 1
25 var foo: [20]u32 = undefined;
26 @memset(&foo, 1234);
27 try expect(foo[0] == 1234);
28 try expect(foo[11] == 1234);
29 try expect(foo[19] == 1234);
30 }
31}
32
33test "@memset preserves array sentinel" {
34 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
35 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
36 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
37
38 try testMemsetArraySentinel();
39 try comptime testMemsetArraySentinel();
40}
41
42fn testMemsetArraySentinel() !void {
43 var value: u32 = 42;
44 _ = &value;
45 var array: [3:0]u32 = .{ 1, 2, 3 };
46
47 @memset(&array, value);
48
49 try expect(array[0] == value);
50 try expect(array[1] == value);
51 try expect(array[2] == value);
52 try expect(array[3] == 0);
53}
54
55test "@memset on slices" {
56 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
57 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
58 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
59 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
60
61 try testMemsetSlice();
62 try comptime testMemsetSlice();
63}
64
65fn testMemsetSlice() !void {
66 {
67 // memset slice to non-undefined, ABI size == 1
68 var array: [20]u8 = undefined;
69 var len = array.len;
70 _ = &len;
71 const slice = array[0..len];
72 @memset(slice, 'A');
73 try expect(slice[0] == 'A');
74 try expect(slice[11] == 'A');
75 try expect(slice[19] == 'A');
76 }
77 {
78 // memset slice to non-undefined, ABI size > 1
79 var array: [20]u32 = undefined;
80 var len = array.len;
81 _ = &len;
82 const slice = array[0..len];
83 @memset(slice, 1234);
84 try expect(slice[0] == 1234);
85 try expect(slice[11] == 1234);
86 try expect(slice[19] == 1234);
87 }
88}
89
90test "memset with bool element" {
91 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
92 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
93 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
94
95 var buf: [5]bool = undefined;
96 @memset(&buf, true);
97 try expect(buf[2]);
98 try expect(buf[4]);
99}
100
101test "memset with 1-byte struct element" {
102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
103 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
104 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
105
106 const S = struct { x: bool };
107 var buf: [5]S = undefined;
108 @memset(&buf, .{ .x = true });
109 try expect(buf[2].x);
110 try expect(buf[4].x);
111}
112
113test "memset with 1-byte array element" {
114 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
115 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
116 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
117
118 const A = [1]bool;
119 var buf: [5]A = undefined;
120 @memset(&buf, .{true});
121 try expect(buf[2][0]);
122 try expect(buf[4][0]);
123}
124
125test "memset with large array element, runtime known" {
126 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
128 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
129 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
130 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
131
132 const A = [128]u64;
133 var buf: [5]A = undefined;
134 var runtime_known_element: A = @splat(0);
135 _ = &runtime_known_element;
136 @memset(&buf, runtime_known_element);
137 for (buf[0]) |elem| try expect(elem == 0);
138 for (buf[1]) |elem| try expect(elem == 0);
139 for (buf[2]) |elem| try expect(elem == 0);
140 for (buf[3]) |elem| try expect(elem == 0);
141 for (buf[4]) |elem| try expect(elem == 0);
142}
143
144test "memset with large array element, comptime known" {
145 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
146 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
147 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
148 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
149
150 const A = [128]u64;
151 var buf: [5]A = undefined;
152 const comptime_known_element: A = @splat(0);
153 @memset(&buf, comptime_known_element);
154 for (buf[0]) |elem| try expect(elem == 0);
155 for (buf[1]) |elem| try expect(elem == 0);
156 for (buf[2]) |elem| try expect(elem == 0);
157 for (buf[3]) |elem| try expect(elem == 0);
158 for (buf[4]) |elem| try expect(elem == 0);
159}
160
161test "@memset provides result type" {
162 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
163 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
164 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
165 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
166
167 const S = struct { x: u32 };
168
169 var buf1: [5]S = undefined;
170 @memset(&buf1, .{ .x = @intCast(12) });
171
172 var buf2: [5]S = undefined;
173 @memset(@as([]S, &buf2), .{ .x = @intCast(34) });
174
175 for (buf1) |s| try expect(s.x == 12);
176 for (buf2) |s| try expect(s.x == 34);
177}
178
179test "zero keys with @memset" {
180 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
181 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
182 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
183
184 const Keys = struct {
185 up: bool,
186 down: bool,
187 left: bool,
188 right: bool,
189 var keys: @This() = undefined;
190 };
191 @memset(@as([*]u8, @ptrCast(&Keys.keys))[0..@sizeOf(@TypeOf(Keys.keys))], 0);
192 try expect(!Keys.keys.up);
193 try expect(!Keys.keys.down);
194 try expect(!Keys.keys.left);
195 try expect(!Keys.keys.right);
196}
197
198test "@memset with zero-length array" {
199 var array: [0]usize = undefined;
200 @memset(&array, 0);
201}
202
203test "@memset a global array" {
204 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
205
206 const S = struct {
207 var buf: [1]u32 = .{123};
208 };
209 try expect(S.buf[0] == 123);
210 @memset(&S.buf, 456);
211 try expect(S.buf[0] == 456);
212 @memset(&S.buf, S.buf[0] + 333);
213 try expect(S.buf[0] == 789);
214}
215
216test "@memset array of booleans" {
217 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
218
219 const S = struct {
220 var x: bool = false;
221 var y: [1]bool = undefined;
222 };
223 @memset(&S.y, S.x);
224}