ut.meta.types source code

1 module ut.meta.types;
2 
3 
4 import ut.meta;
5 
6 
7 @("empty")
8 @safe pure unittest {
9     alias mod = Module!"modules.empty";
10     typeNames!mod.should == [];
11 }
12 
13 
14 @("imports")
15 @safe pure unittest {
16     alias mod = Module!"modules.imports";
17     typeNames!mod.should == [];
18 }
19 
20 
21 @("types")
22 @safe pure unittest {
23     alias mod = Module!"modules.types";
24     typeNames!mod.shouldBeSameSetAs(
25         [
26             "String",
27             "Enum",
28             "Class",
29             "Interface",
30             "AbstractClass",
31             "MiddleClass",
32             "LeafClass",
33         ]
34     );
35 }
36 
37 
38 @("problems")
39 @safe pure unittest {
40     alias mod = Module!"modules.problems";
41     typeNames!mod.should == [];
42 }
43 
44 
45 @("variables")
46 @safe pure unittest {
47     alias mod = Module!"modules.variables";
48     typeNames!mod.should == ["Struct"];
49 }
50 
51 
52 @("isEnum")
53 @safe pure unittest {
54     static import modules.types;
55     import std.meta: Filter, AliasSeq;
56 
57     alias mod = Module!"modules.types";
58     alias aggregates = mod.Aggregates;
59     alias enums = Filter!(isEnum, aggregates);
60     static assert(is(enums == AliasSeq!(modules.types.Enum)), enums.stringof);
61 }
62 
63 
64 @("isStruct")
65 @safe pure unittest {
66     static import modules.types;
67     import std.meta: Filter, AliasSeq;
68 
69     alias mod = Module!"modules.types";
70     alias aggregates = mod.Aggregates;
71     alias structs = Filter!(isStruct, aggregates);
72     static assert(is(structs == AliasSeq!(modules.types.String)), structs.stringof);
73 }
74 
75 
76 @("isInterface")
77 @safe pure unittest {
78     static import modules.types;
79     import std.meta: Filter, AliasSeq;
80 
81     alias mod = Module!"modules.types";
82     alias aggregates = mod.Aggregates;
83     alias interfaces = Filter!(isInterface, aggregates);
84     static assert(is(interfaces == AliasSeq!(modules.types.Interface)), interfaces.stringof);
85 }
86 
87 
88 @("isClass")
89 @safe pure unittest {
90     static import modules.types;
91     import std.meta: Filter, AliasSeq;
92 
93     alias mod = Module!"modules.types";
94     alias aggregates = mod.Aggregates;
95     alias classes = Filter!(isClass, aggregates);
96     alias expected = AliasSeq!(
97         modules.types.Class,
98         modules.types.AbstractClass,
99         modules.types.MiddleClass,
100         modules.types.LeafClass,
101     );
102     static assert(is(classes == expected), classes.stringof);
103 }
104 
105 
106 @("isOOP")
107 @safe pure unittest {
108     static import modules.types;
109     import std.meta: Filter, AliasSeq;
110 
111     alias mod = Module!"modules.types";
112     alias aggregates = mod.Aggregates;
113     alias classes = Filter!(isOOP, aggregates);
114     alias expected = AliasSeq!(
115         modules.types.Class,
116         modules.types.Interface,
117         modules.types.AbstractClass,
118         modules.types.MiddleClass,
119         modules.types.LeafClass,
120     );
121     static assert(is(classes == expected), classes.stringof);
122 }
123 
124 
125 private string[] typeNames(alias module_)() {
126     import std.meta: staticMap;
127     enum name(alias Symbol) = __traits(identifier, Symbol);
128     enum names = staticMap!(name, module_.Aggregates);
129     return [names];
130 }