OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 library mirrors_mixin_test; | |
6 | |
7 import 'package:expect/expect.dart'; | |
8 import 'package:async_helper/async_helper.dart'; | |
9 import 'mirror_system_helper.dart'; | |
10 | |
11 const String CLASS_SOURCE = ''' | |
12 class A {} | |
13 | |
14 class S {} | |
15 class M1<T> {} | |
16 class M2 {} | |
17 | |
18 class C extends S with M1<A> {} | |
19 class D extends S with M1, M2 {} | |
20 class E extends S with M2, M1 implements A, M1 {} | |
21 class E2 extends E {} | |
22 | |
23 typedef F = S with M1<A>; | |
24 typedef G = abstract S with M1, M2; | |
25 typedef H = S with M2, M1 implements A, M1; | |
26 class H2 extends H {} | |
27 '''; | |
28 | |
29 void main() { | |
30 asyncTest(() => createMirrorSystem(CLASS_SOURCE).then((MirrorSystem mirrors) { | |
31 LibraryMirror library = mirrors.libraries[SOURCE_URI]; | |
32 | |
33 // class A {} | |
34 var A = library.classes['A']; | |
35 Expect.isNotNull(A); | |
karlklose
2013/11/05 10:34:18
You could write test methods that takes the expect
Johnni Winther
2013/11/05 11:20:47
Done.
| |
36 Expect.isTrue(A is ClassMirror); | |
37 Expect.isFalse(isMixinApplication(A)); | |
38 Expect.isFalse(A.isObject); | |
39 Expect.isTrue(A.superclass.isObject); | |
40 Expect.equals(0, A.superinterfaces.length); | |
41 | |
42 Expect.isTrue(getExtends(A).isObject); | |
43 Expect.isTrue(getWith(A).isEmpty); | |
44 Expect.isTrue(getImplements(A).isEmpty); | |
45 | |
46 // class S {} | |
47 var S = library.classes['S']; | |
48 Expect.isNotNull(S); | |
49 Expect.isTrue(S is ClassMirror); | |
50 Expect.isFalse(isMixinApplication(S)); | |
51 Expect.isFalse(S.isObject); | |
52 Expect.isTrue(S.superclass.isObject); | |
53 Expect.equals(0, S.superinterfaces.length); | |
54 | |
55 Expect.isTrue(getExtends(S).isObject); | |
56 Expect.isTrue(getWith(S).isEmpty); | |
57 Expect.isTrue(getImplements(S).isEmpty); | |
58 | |
59 // class M1 {} | |
60 var M1 = library.classes['M1']; | |
61 Expect.isNotNull(M1); | |
62 Expect.isTrue(M1 is ClassMirror); | |
63 Expect.isFalse(isMixinApplication(M1)); | |
64 Expect.isFalse(M1.isObject); | |
65 Expect.isTrue(M1.superclass.isObject); | |
66 Expect.equals(0, M1.superinterfaces.length); | |
67 | |
68 Expect.isTrue(getExtends(M1).isObject); | |
69 Expect.isTrue(getWith(M1).isEmpty); | |
70 Expect.isTrue(getImplements(M1).isEmpty); | |
71 | |
72 // class M2 {} | |
73 var M2 = library.classes['M2']; | |
74 Expect.isNotNull(M2); | |
75 Expect.isTrue(M2 is ClassMirror); | |
76 Expect.isFalse(isMixinApplication(M2)); | |
77 Expect.isFalse(M2.isObject); | |
78 Expect.isTrue(M2.superclass.isObject); | |
79 Expect.equals(0, M2.superinterfaces.length); | |
80 | |
81 Expect.isTrue(getExtends(M2).isObject); | |
82 Expect.isTrue(getWith(M2).isEmpty); | |
83 Expect.isTrue(getImplements(M2).isEmpty); | |
84 | |
85 // class C extends S with M1<A> {} | |
86 var C = library.classes['C']; | |
87 Expect.isNotNull(C); | |
88 Expect.isTrue(C is ClassMirror); | |
89 Expect.isFalse(isMixinApplication(C)); | |
90 Expect.isFalse(C.isObject); | |
91 Expect.equals(0, C.superinterfaces.length); | |
92 var C_super = C.superclass; | |
93 Expect.isNotNull(C_super); | |
94 Expect.isTrue(C_super is ClassMirror); | |
95 Expect.isTrue(isMixinApplication(C_super)); | |
96 Expect.isFalse(!C_super.isNameSynthetic); | |
karlklose
2013/11/05 10:34:18
Why this double negation?
Johnni Winther
2013/11/05 11:20:47
An artifact of code motion. Fixed.
| |
97 Expect.equals(1, C_super.superinterfaces.length); | |
98 Expect.isTrue(containsType(M1, [A], C_super.superinterfaces)); | |
99 Expect.isTrue(isType(M1, [A], C_super.mixin)); | |
100 Expect.isFalse(C_super.isObject); | |
101 Expect.isTrue(sameDecl(S, C_super.superclass)); | |
102 | |
103 Expect.isTrue(sameDecl(S, getExtends(C))); | |
104 Expect.isTrue(sameDeclList([M1], getWith(C))); | |
105 Expect.isTrue(getImplements(C).isEmpty); | |
106 | |
107 // D extends S with M1, M2 {} | |
108 var D = library.classes['D']; | |
109 Expect.isNotNull(D); | |
110 Expect.isTrue(D is ClassMirror); | |
111 Expect.isFalse(isMixinApplication(D)); | |
112 Expect.isFalse(D.isObject); | |
113 Expect.equals(0, D.superinterfaces.length); | |
114 var D_super = D.superclass; | |
115 Expect.isNotNull(D_super); | |
116 Expect.isTrue(D_super is ClassMirror); | |
117 Expect.isTrue(isMixinApplication(D_super)); | |
118 Expect.isFalse(!D_super.isNameSynthetic); | |
119 Expect.equals(1, D_super.superinterfaces.length); | |
120 Expect.isTrue(containsDecl(M2, D_super.superinterfaces)); | |
121 Expect.isTrue(sameDecl(M2, D_super.mixin)); | |
122 Expect.isFalse(D_super.isObject); | |
123 Expect.isFalse(sameDecl(S, D_super.superclass)); | |
124 var D_super_super = D_super.superclass; | |
125 Expect.isNotNull(D_super_super); | |
126 Expect.isTrue(D_super_super is ClassMirror); | |
127 Expect.isTrue(isMixinApplication(D_super_super)); | |
128 Expect.isFalse(!D_super_super.isNameSynthetic); | |
129 Expect.equals(1, D_super_super.superinterfaces.length); | |
130 Expect.isTrue(containsDecl(M1, D_super_super.superinterfaces)); | |
131 Expect.isTrue(sameDecl(M1, D_super_super.mixin)); | |
132 Expect.isFalse(D_super_super.isObject); | |
133 Expect.isTrue(sameDecl(S, D_super_super.superclass)); | |
134 | |
135 Expect.isTrue(sameDecl(S, getExtends(D))); | |
136 Expect.isTrue(sameDeclList([M1, M2], getWith(D))); | |
137 Expect.isTrue(getImplements(D).isEmpty); | |
138 | |
139 // class E extends S with M2, M1 implements A, M1 {} | |
140 var E = library.classes['E']; | |
141 Expect.isNotNull(E); | |
142 Expect.isTrue(E is ClassMirror); | |
143 Expect.isFalse(isMixinApplication(E)); | |
144 Expect.isFalse(E.isObject); | |
145 Expect.equals(2, E.superinterfaces.length); | |
146 Expect.isTrue(containsDecl(A, E.superinterfaces)); | |
147 Expect.isTrue(containsDecl(M1, E.superinterfaces)); | |
148 var E_super = E.superclass; | |
149 Expect.isNotNull(E_super); | |
150 Expect.isTrue(E_super is ClassMirror); | |
151 Expect.isTrue(isMixinApplication(E_super)); | |
152 Expect.isFalse(!E_super.isNameSynthetic); | |
153 Expect.equals(1, E_super.superinterfaces.length); | |
154 Expect.isTrue(containsDecl(M1, E_super.superinterfaces)); | |
155 Expect.isTrue(sameDecl(M1, E_super.mixin)); | |
156 Expect.isFalse(E_super.isObject); | |
157 Expect.isFalse(sameDecl(S, E_super.superclass)); | |
158 var E_super_super = E_super.superclass; | |
159 Expect.isNotNull(E_super_super); | |
160 Expect.isTrue(E_super_super is ClassMirror); | |
161 Expect.isTrue(isMixinApplication(E_super_super)); | |
162 Expect.isFalse(!E_super_super.isNameSynthetic); | |
163 Expect.equals(1, E_super_super.superinterfaces.length); | |
164 Expect.isTrue(containsDecl(M2, E_super_super.superinterfaces)); | |
165 Expect.isTrue(sameDecl(M2, E_super_super.mixin)); | |
166 Expect.isFalse(E_super_super.isObject); | |
167 Expect.isTrue(sameDecl(S, E_super_super.superclass)); | |
168 | |
169 Expect.isTrue(sameDecl(S, getExtends(E))); | |
170 Expect.isTrue(sameDeclList([M2, M1], getWith(E))); | |
171 Expect.isTrue(sameDeclSet([A, M1], getImplements(E))); | |
172 | |
173 // class E2 extends E {} | |
174 var E2 = library.classes['E2']; | |
175 Expect.isTrue(sameDecl(E, getExtends(E2))); | |
176 Expect.isTrue(getWith(E2).isEmpty); | |
177 Expect.isTrue(getImplements(E2).isEmpty); | |
178 | |
179 // typedef F = S with M1<A>; | |
180 var F = library.classes['F']; | |
181 Expect.isNotNull(F); | |
182 Expect.isTrue(F is ClassMirror); | |
183 Expect.isFalse(F.isAbstract); | |
184 Expect.isTrue(isMixinApplication(F)); | |
185 Expect.isTrue(!F.isNameSynthetic); | |
186 Expect.equals('F', F.simpleName); | |
187 Expect.isFalse(F.isObject); | |
188 Expect.equals(1, F.superinterfaces.length); | |
189 Expect.isTrue(containsDecl(M1, F.superinterfaces)); | |
190 Expect.isTrue(isType(M1, [A], F.mixin)); | |
191 var F_super = F.superclass; | |
192 Expect.isNotNull(F_super); | |
193 Expect.isTrue(F_super is ClassMirror); | |
194 Expect.isFalse(isMixinApplication(F_super)); | |
195 Expect.isFalse(F_super.isObject); | |
196 Expect.isTrue(sameDecl(S, F_super)); | |
197 | |
198 Expect.isTrue(sameDecl(S, getExtends(F))); | |
199 Expect.isTrue(sameDeclList([M1], getWith(F))); | |
200 Expect.isTrue(getImplements(F).isEmpty); | |
201 | |
202 // typedef G = abstract S with M1, M2; | |
203 var G = library.classes['G']; | |
204 Expect.isNotNull(G); | |
205 Expect.isTrue(G is ClassMirror); | |
206 Expect.isTrue(G.isAbstract); | |
207 Expect.isTrue(isMixinApplication(G)); | |
208 Expect.isTrue(!G.isNameSynthetic); | |
209 Expect.equals('G', G.simpleName); | |
210 Expect.isFalse(G.isObject); | |
211 Expect.equals(1, G.superinterfaces.length); | |
212 Expect.isTrue(containsDecl(M2, G.superinterfaces)); | |
213 Expect.isTrue(sameDecl(M2, G.mixin)); | |
214 var G_super = G.superclass; | |
215 Expect.isNotNull(G_super); | |
216 Expect.isTrue(G_super is ClassMirror); | |
217 Expect.isTrue(isMixinApplication(G_super)); | |
218 Expect.equals(1, G_super.superinterfaces.length); | |
219 Expect.isTrue(containsDecl(M1, G_super.superinterfaces)); | |
220 Expect.isTrue(sameDecl(M1, G_super.mixin)); | |
221 Expect.isFalse(G_super.isObject); | |
222 Expect.isTrue(sameDecl(S, G_super.superclass)); | |
223 | |
224 Expect.isTrue(sameDecl(S, getExtends(G))); | |
225 Expect.isTrue(sameDeclList([M1, M2], getWith(G))); | |
226 Expect.isTrue(getImplements(G).isEmpty); | |
227 | |
228 // typedef H = S with M2, M1 implements A, M1; | |
229 var H = library.classes['H']; | |
230 Expect.isNotNull(H); | |
231 Expect.isTrue(H is ClassMirror); | |
232 Expect.isFalse(H.isAbstract); | |
233 Expect.isTrue(isMixinApplication(H)); | |
234 Expect.isTrue(!H.isNameSynthetic); | |
235 Expect.equals('H', H.simpleName); | |
236 Expect.isFalse(H.isObject); | |
237 Expect.equals(3, H.superinterfaces.length); | |
238 Expect.isTrue(containsDecl(A, H.superinterfaces)); | |
239 Expect.isTrue(containsDecl(M1, H.superinterfaces)); | |
240 Expect.isFalse(containsDecl(M2, H.superinterfaces)); | |
241 Expect.isTrue(sameDecl(M1, H.mixin)); | |
242 var H_super = H.superclass; | |
243 Expect.isNotNull(H_super); | |
244 Expect.isTrue(H_super is ClassMirror); | |
245 Expect.isTrue(isMixinApplication(H_super)); | |
246 Expect.equals(1, H_super.superinterfaces.length); | |
247 Expect.isTrue(containsDecl(M2, H_super.superinterfaces)); | |
248 Expect.isTrue(sameDecl(M2, H_super.mixin)); | |
249 Expect.isFalse(H_super.isObject); | |
250 Expect.isTrue(sameDecl(S, H_super.superclass)); | |
251 | |
252 Expect.isTrue(sameDecl(S, getExtends(H))); | |
253 Expect.isTrue(sameDeclList([M2, M1], getWith(H))); | |
254 Expect.isTrue(sameDeclSet([A, M1], getImplements(H))); | |
255 | |
256 // class H2 extends H {} | |
257 var H2 = library.classes['H2']; | |
258 Expect.isTrue(sameDecl(H, getExtends(H2))); | |
259 Expect.isTrue(getWith(H2).isEmpty); | |
260 Expect.isTrue(getImplements(H2).isEmpty); | |
261 })); | |
262 } | |
OLD | NEW |