1const std = @import("std");
2const builtin = @import("builtin");
3const expect = std.testing.expect;
4const expectEqual = std.testing.expectEqual;
5const mem = std.mem;
6
7fn initStaticArray() [10]i32 {
8 var array: [10]i32 = undefined;
9 array[0] = 1;
10 array[4] = 2;
11 array[7] = 3;
12 array[9] = 4;
13 return array;
14}
15const static_array = initStaticArray();
16test "init static array to undefined" {
17 // This test causes `initStaticArray()` to be codegen'd, and the
18 // C backend does not yet support returning arrays, so it fails
19 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
20 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21
22 try expect(static_array[0] == 1);
23 try expect(static_array[4] == 2);
24 try expect(static_array[7] == 3);
25 try expect(static_array[9] == 4);
26
27 comptime {
28 try expect(static_array[0] == 1);
29 try expect(static_array[4] == 2);
30 try expect(static_array[7] == 3);
31 try expect(static_array[9] == 4);
32 }
33}
34
35const Foo = struct {
36 x: i32,
37
38 fn setFooXMethod(foo: *Foo) void {
39 foo.x = 3;
40 }
41};
42
43fn setFooX(foo: *Foo) void {
44 foo.x = 2;
45}
46
47test "assign undefined to struct" {
48 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
49 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
50
51 comptime {
52 var foo: Foo = undefined;
53 setFooX(&foo);
54 try expect(foo.x == 2);
55 }
56 {
57 var foo: Foo = undefined;
58 setFooX(&foo);
59 try expect(foo.x == 2);
60 }
61}
62
63test "assign undefined to struct with method" {
64 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
65 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
66
67 comptime {
68 var foo: Foo = undefined;
69 foo.setFooXMethod();
70 try expect(foo.x == 3);
71 }
72 {
73 var foo: Foo = undefined;
74 foo.setFooXMethod();
75 try expect(foo.x == 3);
76 }
77}
78
79test "type name of undefined" {
80 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
81 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
82
83 const x = undefined;
84 try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)"));
85}
86
87var buf: []u8 = undefined;
88
89test "reslice of undefined global var slice" {
90 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
91 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
92
93 var stack_buf: [100]u8 = @splat(0);
94 buf = &stack_buf;
95 const x = buf[0..1];
96 try @import("std").testing.expect(x.len == 1 and x[0] == 0);
97}
98
99test "returned undef is 0xaa bytes when runtime safety is enabled" {
100 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
101 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
102 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
103
104 const Rect = struct {
105 x: f32,
106 fn getUndefStruct() @This() {
107 @setRuntimeSafety(true);
108 return undefined;
109 }
110 fn getUndefInt() u32 {
111 @setRuntimeSafety(true);
112 return undefined;
113 }
114 };
115 try std.testing.expect(@as(u32, @bitCast(Rect.getUndefStruct().x)) == 0xAAAAAAAA);
116 try std.testing.expect(Rect.getUndefInt() == 0xAAAAAAAA);
117}