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
59
60
61
62
63
64
65
66
67
68
|
const builtin = @import("builtin");
const std = @import("std");
const expect = std.testing.expect;
const mem = std.mem;
const reflection = @This();
test "reflection: function return type, var args, and param types" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
comptime {
const info = @typeInfo(@TypeOf(dummy)).Fn;
try expect(info.return_type.? == i32);
try expect(!info.is_var_args);
try expect(info.args.len == 3);
try expect(info.args[0].arg_type.? == bool);
try expect(info.args[1].arg_type.? == i32);
try expect(info.args[2].arg_type.? == f32);
}
}
fn dummy(a: bool, b: i32, c: f32) i32 {
if (false) {
a;
b;
c;
}
return 1234;
}
test "reflection: @field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
var f = Foo{
.one = 42,
.two = true,
.three = void{},
};
try expect(f.one == f.one);
try expect(@field(f, "o" ++ "ne") == f.one);
try expect(@field(f, "t" ++ "wo") == f.two);
try expect(@field(f, "th" ++ "ree") == f.three);
try expect(@field(Foo, "const" ++ "ant") == Foo.constant);
try expect(@field(Bar, "O" ++ "ne") == Bar.One);
try expect(@field(Bar, "T" ++ "wo") == Bar.Two);
try expect(@field(Bar, "Th" ++ "ree") == Bar.Three);
try expect(@field(Bar, "F" ++ "our") == Bar.Four);
try expect(@field(reflection, "dum" ++ "my")(true, 1, 2) == dummy(true, 1, 2));
@field(f, "o" ++ "ne") = 4;
try expect(f.one == 4);
}
const Foo = struct {
const constant = 52;
one: i32,
two: bool,
three: void,
};
const Bar = union(enum) {
One: void,
Two: i32,
Three: bool,
Four: f64,
};
|
