master
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 on slices" {
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 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
38
39 try testMemsetSlice();
40 try comptime testMemsetSlice();
41}
42
43fn testMemsetSlice() !void {
44 {
45 // memset slice to non-undefined, ABI size == 1
46 var array: [20]u8 = undefined;
47 var len = array.len;
48 _ = &len;
49 const slice = array[0..len];
50 @memset(slice, 'A');
51 try expect(slice[0] == 'A');
52 try expect(slice[11] == 'A');
53 try expect(slice[19] == 'A');
54 }
55 {
56 // memset slice to non-undefined, ABI size > 1
57 var array: [20]u32 = undefined;
58 var len = array.len;
59 _ = &len;
60 const slice = array[0..len];
61 @memset(slice, 1234);
62 try expect(slice[0] == 1234);
63 try expect(slice[11] == 1234);
64 try expect(slice[19] == 1234);
65 }
66}
67
68test "memset with bool element" {
69 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
71 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
72
73 var buf: [5]bool = undefined;
74 @memset(&buf, true);
75 try expect(buf[2]);
76 try expect(buf[4]);
77}
78
79test "memset with 1-byte struct element" {
80 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
81 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
82 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
84
85 const S = struct { x: bool };
86 var buf: [5]S = undefined;
87 @memset(&buf, .{ .x = true });
88 try expect(buf[2].x);
89 try expect(buf[4].x);
90}
91
92test "memset with 1-byte array element" {
93 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
94 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
95 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
96 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
97
98 const A = [1]bool;
99 var buf: [5]A = undefined;
100 @memset(&buf, .{true});
101 try expect(buf[2][0]);
102 try expect(buf[4][0]);
103}
104
105test "memset with large array element, runtime known" {
106 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
107 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
108 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
109 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
110 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
111
112 const A = [128]u64;
113 var buf: [5]A = undefined;
114 var runtime_known_element = [_]u64{0} ** 128;
115 _ = &runtime_known_element;
116 @memset(&buf, runtime_known_element);
117 for (buf[0]) |elem| try expect(elem == 0);
118 for (buf[1]) |elem| try expect(elem == 0);
119 for (buf[2]) |elem| try expect(elem == 0);
120 for (buf[3]) |elem| try expect(elem == 0);
121 for (buf[4]) |elem| try expect(elem == 0);
122}
123
124test "memset with large array element, comptime known" {
125 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
126 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
128 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
129
130 const A = [128]u64;
131 var buf: [5]A = undefined;
132 const comptime_known_element = [_]u64{0} ** 128;
133 @memset(&buf, comptime_known_element);
134 for (buf[0]) |elem| try expect(elem == 0);
135 for (buf[1]) |elem| try expect(elem == 0);
136 for (buf[2]) |elem| try expect(elem == 0);
137 for (buf[3]) |elem| try expect(elem == 0);
138 for (buf[4]) |elem| try expect(elem == 0);
139}
140
141test "@memset provides result type" {
142 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
143 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
144 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
145 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
146
147 const S = struct { x: u32 };
148
149 var buf1: [5]S = undefined;
150 @memset(&buf1, .{ .x = @intCast(12) });
151
152 var buf2: [5]S = undefined;
153 @memset(@as([]S, &buf2), .{ .x = @intCast(34) });
154
155 for (buf1) |s| try expect(s.x == 12);
156 for (buf2) |s| try expect(s.x == 34);
157}
158
159test "zero keys with @memset" {
160 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
161 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
163
164 const Keys = struct {
165 up: bool,
166 down: bool,
167 left: bool,
168 right: bool,
169 var keys: @This() = undefined;
170 };
171 @memset(@as([*]u8, @ptrCast(&Keys.keys))[0..@sizeOf(@TypeOf(Keys.keys))], 0);
172 try expect(!Keys.keys.up);
173 try expect(!Keys.keys.down);
174 try expect(!Keys.keys.left);
175 try expect(!Keys.keys.right);
176}
177
178test "@memset with zero-length array" {
179 var array: [0]usize = undefined;
180 @memset(&array, 0);
181}
182
183test "@memset a global array" {
184 const S = struct {
185 var buf: [1]u32 = .{123};
186 };
187 try expect(S.buf[0] == 123);
188 @memset(&S.buf, 456);
189 try expect(S.buf[0] == 456);
190 @memset(&S.buf, S.buf[0] + 333);
191 try expect(S.buf[0] == 789);
192}