1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
const std = @import("std");
const expect = std.testing.expect;
const expectEqualSlices = std.testing.expectEqualSlices;
const expectEqualStrings = std.testing.expectEqualStrings;
const mem = std.mem;
const builtin = @import("builtin");
// can't really run this test but we can make sure it has no compile error
// and generates code
const vram = @as([*]volatile u8, @ptrFromInt(0x20000000))[0..0x8000];
export fn writeToVRam() void {
if (builtin.zig_backend == .stage2_riscv64) return;
vram[0] = 'X';
}
const PackedStruct = packed struct {
a: u8,
b: u8,
};
const PackedUnion = packed union {
a: packed struct(u32) {
a: u8,
b: u24 = 0,
},
b: u32,
};
test "packed struct, enum, union parameters in extern function" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
testPackedStuff(&(PackedStruct{
.a = 1,
.b = 2,
}), &(PackedUnion{ .a = .{ .a = 1 } }));
}
export fn testPackedStuff(a: *const PackedStruct, b: *const PackedUnion) void {
if (false) {
a;
b;
}
}
test "export function alias" {
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
_ = struct {
fn foo_internal() callconv(.c) u32 {
return 123;
}
export const foo_exported = foo_internal;
};
const Import = struct {
extern fn foo_exported() u32;
};
try expect(Import.foo_exported() == 123);
}
|
