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 class F = S with M1<A>; | |
24 abstract class G = S with M1, M2; | |
25 class 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 checkSimpleClass(var cls) { | |
34 Expect.isNotNull(cls); | |
35 Expect.isTrue(cls is ClassMirror); | |
36 Expect.isFalse(isMixinApplication(cls)); | |
37 Expect.isFalse(cls.isNameSynthetic); | |
38 Expect.isFalse(isObject(cls)); | |
39 Expect.isTrue(isObject(cls.superclass)); | |
40 Expect.equals(0, cls.superinterfaces.length); | |
41 | |
42 Expect.isTrue(isObject(getSuperclass(cls))); | |
43 Expect.isTrue(getAppliedMixins(cls).isEmpty); | |
44 Expect.isTrue(getExplicitInterfaces(cls).isEmpty); | |
45 } | |
46 | |
47 // class A {} | |
48 var A = library.declarations[#A]; | |
49 checkSimpleClass(A); | |
50 | |
51 // class S {} | |
52 var S = library.declarations[#S]; | |
53 checkSimpleClass(S); | |
54 | |
55 // class M1 {} | |
56 var M1 = library.declarations[#M1]; | |
57 checkSimpleClass(M1); | |
58 | |
59 // class M2 {} | |
60 var M2 = library.declarations[#M2]; | |
61 checkSimpleClass(M2); | |
62 | |
63 // class C extends S with M1<A> {} | |
64 var C = library.declarations[#C]; | |
65 Expect.isNotNull(C); | |
66 Expect.isTrue(C is ClassMirror); | |
67 Expect.isFalse(isMixinApplication(C)); | |
68 Expect.isFalse(isObject(C)); | |
69 Expect.equals(0, C.superinterfaces.length); | |
70 var C_super = C.superclass; | |
71 Expect.isNotNull(C_super); | |
72 Expect.isTrue(C_super is ClassMirror); | |
73 Expect.isTrue(isMixinApplication(C_super)); | |
74 Expect.isTrue(C_super.isNameSynthetic); | |
75 Expect.equals(1, C_super.superinterfaces.length); | |
76 Expect.isTrue(containsType(M1, [A], C_super.superinterfaces)); | |
77 Expect.isTrue(isInstance(M1, [A], C_super.mixin)); | |
78 Expect.isFalse(isObject(C_super)); | |
79 Expect.isTrue(isSameDeclaration(S, C_super.superclass)); | |
80 | |
81 Expect.isTrue(isSameDeclaration(S, getSuperclass(C))); | |
82 Expect.isTrue(isSameDeclarationList([M1], getAppliedMixins(C))); | |
83 Expect.isTrue(getExplicitInterfaces(C).isEmpty); | |
84 | |
85 // D extends S with M1, M2 {} | |
86 var D = library.declarations[#D]; | |
87 Expect.isNotNull(D); | |
88 Expect.isTrue(D is ClassMirror); | |
89 Expect.isFalse(isMixinApplication(D)); | |
90 Expect.isFalse(isObject(D)); | |
91 Expect.equals(0, D.superinterfaces.length); | |
92 var D_super = D.superclass; | |
93 Expect.isNotNull(D_super); | |
94 Expect.isTrue(D_super is ClassMirror); | |
95 Expect.isTrue(isMixinApplication(D_super)); | |
96 Expect.isTrue(D_super.isNameSynthetic); | |
97 Expect.equals(1, D_super.superinterfaces.length); | |
98 Expect.isTrue(containsDeclaration(M2, D_super.superinterfaces)); | |
99 Expect.isTrue(isSameDeclaration(M2, D_super.mixin)); | |
100 Expect.isFalse(isObject(D_super)); | |
101 Expect.isFalse(isSameDeclaration(S, D_super.superclass)); | |
102 var D_super_super = D_super.superclass; | |
103 Expect.isNotNull(D_super_super); | |
104 Expect.isTrue(D_super_super is ClassMirror); | |
105 Expect.isTrue(isMixinApplication(D_super_super)); | |
106 Expect.isTrue(D_super_super.isNameSynthetic); | |
107 Expect.equals(1, D_super_super.superinterfaces.length); | |
108 Expect.isTrue(containsDeclaration(M1, D_super_super.superinterfaces)); | |
109 Expect.isTrue(isSameDeclaration(M1, D_super_super.mixin)); | |
110 Expect.isFalse(isObject(D_super_super)); | |
111 Expect.isTrue(isSameDeclaration(S, D_super_super.superclass)); | |
112 | |
113 Expect.isTrue(isSameDeclaration(S, getSuperclass(D))); | |
114 Expect.isTrue(isSameDeclarationList([M1, M2], getAppliedMixins(D))); | |
115 Expect.isTrue(getExplicitInterfaces(D).isEmpty); | |
116 | |
117 // class E extends S with M2, M1 implements A, M1 {} | |
118 var E = library.declarations[#E]; | |
119 Expect.isNotNull(E); | |
120 Expect.isTrue(E is ClassMirror); | |
121 Expect.isFalse(isMixinApplication(E)); | |
122 Expect.isFalse(isObject(E)); | |
123 Expect.equals(2, E.superinterfaces.length); | |
124 Expect.isTrue(containsDeclaration(A, E.superinterfaces)); | |
125 Expect.isTrue(containsDeclaration(M1, E.superinterfaces)); | |
126 var E_super = E.superclass; | |
127 Expect.isNotNull(E_super); | |
128 Expect.isTrue(E_super is ClassMirror); | |
129 Expect.isTrue(isMixinApplication(E_super)); | |
130 Expect.isTrue(E_super.isNameSynthetic); | |
131 Expect.equals(1, E_super.superinterfaces.length); | |
132 Expect.isTrue(containsDeclaration(M1, E_super.superinterfaces)); | |
133 Expect.isTrue(isSameDeclaration(M1, E_super.mixin)); | |
134 Expect.isFalse(isObject(E_super)); | |
135 Expect.isFalse(isSameDeclaration(S, E_super.superclass)); | |
136 var E_super_super = E_super.superclass; | |
137 Expect.isNotNull(E_super_super); | |
138 Expect.isTrue(E_super_super is ClassMirror); | |
139 Expect.isTrue(isMixinApplication(E_super_super)); | |
140 Expect.isTrue(E_super_super.isNameSynthetic); | |
141 Expect.equals(1, E_super_super.superinterfaces.length); | |
142 Expect.isTrue(containsDeclaration(M2, E_super_super.superinterfaces)); | |
143 Expect.isTrue(isSameDeclaration(M2, E_super_super.mixin)); | |
144 Expect.isFalse(isObject(E_super_super)); | |
145 Expect.isTrue(isSameDeclaration(S, E_super_super.superclass)); | |
146 | |
147 Expect.isTrue(isSameDeclaration(S, getSuperclass(E))); | |
148 Expect.isTrue(isSameDeclarationList([M2, M1], getAppliedMixins(E))); | |
149 Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(E))); | |
150 | |
151 // class E2 extends E {} | |
152 var E2 = library.declarations[#E2]; | |
153 Expect.isTrue(isSameDeclaration(E, getSuperclass(E2))); | |
154 Expect.isTrue(getAppliedMixins(E2).isEmpty); | |
155 Expect.isTrue(getExplicitInterfaces(E2).isEmpty); | |
156 | |
157 // class F = S with M1<A>; | |
158 var F = library.declarations[#F]; | |
159 Expect.isNotNull(F); | |
160 Expect.isTrue(F is ClassMirror); | |
161 Expect.isFalse(F.isAbstract); | |
162 Expect.isTrue(isMixinApplication(F)); | |
163 Expect.isFalse(F.isNameSynthetic); | |
164 Expect.equals(#F, F.simpleName); | |
165 Expect.isFalse(isObject(F)); | |
166 Expect.equals(1, F.superinterfaces.length); | |
167 Expect.isTrue(containsDeclaration(M1, F.superinterfaces)); | |
168 Expect.isTrue(isInstance(M1, [A], F.mixin)); | |
169 var F_super = F.superclass; | |
170 Expect.isNotNull(F_super); | |
171 Expect.isTrue(F_super is ClassMirror); | |
172 Expect.isFalse(isMixinApplication(F_super)); | |
173 Expect.isFalse(isObject(F_super)); | |
174 Expect.isTrue(isSameDeclaration(S, F_super)); | |
175 | |
176 Expect.isTrue(isSameDeclaration(S, getSuperclass(F))); | |
177 Expect.isTrue(isSameDeclarationList([M1], getAppliedMixins(F))); | |
178 Expect.isTrue(getExplicitInterfaces(F).isEmpty); | |
179 | |
180 // typedef G = abstract S with M1, M2; | |
181 var G = library.declarations[#G]; | |
182 Expect.isNotNull(G); | |
183 Expect.isTrue(G is ClassMirror); | |
184 Expect.isTrue(G.isAbstract); | |
185 Expect.isTrue(isMixinApplication(G)); | |
186 Expect.isFalse(G.isNameSynthetic); | |
187 Expect.equals(#G, G.simpleName); | |
188 Expect.isFalse(isObject(G)); | |
189 Expect.equals(1, G.superinterfaces.length); | |
190 Expect.isTrue(containsDeclaration(M2, G.superinterfaces)); | |
191 Expect.isTrue(isSameDeclaration(M2, G.mixin)); | |
192 var G_super = G.superclass; | |
193 Expect.isNotNull(G_super); | |
194 Expect.isTrue(G_super is ClassMirror); | |
195 Expect.isTrue(isMixinApplication(G_super)); | |
196 Expect.equals(1, G_super.superinterfaces.length); | |
197 Expect.isTrue(containsDeclaration(M1, G_super.superinterfaces)); | |
198 Expect.isTrue(isSameDeclaration(M1, G_super.mixin)); | |
199 Expect.isFalse(isObject(G_super)); | |
200 Expect.isTrue(isSameDeclaration(S, G_super.superclass)); | |
201 | |
202 Expect.isTrue(isSameDeclaration(S, getSuperclass(G))); | |
203 Expect.isTrue(isSameDeclarationList([M1, M2], getAppliedMixins(G))); | |
204 Expect.isTrue(getExplicitInterfaces(G).isEmpty); | |
205 | |
206 // typedef H = S with M2, M1 implements A, M1; | |
207 var H = library.declarations[#H]; | |
208 Expect.isNotNull(H); | |
209 Expect.isTrue(H is ClassMirror); | |
210 Expect.isFalse(H.isAbstract); | |
211 Expect.isTrue(isMixinApplication(H)); | |
212 Expect.isFalse(H.isNameSynthetic); | |
213 Expect.equals(#H, H.simpleName); | |
214 Expect.isFalse(isObject(H)); | |
215 Expect.equals(3, H.superinterfaces.length); | |
216 Expect.isTrue(containsDeclaration(A, H.superinterfaces)); | |
217 Expect.isTrue(containsDeclaration(M1, H.superinterfaces)); | |
218 Expect.isFalse(containsDeclaration(M2, H.superinterfaces)); | |
219 Expect.isTrue(isSameDeclaration(M1, H.mixin)); | |
220 var H_super = H.superclass; | |
221 Expect.isNotNull(H_super); | |
222 Expect.isTrue(H_super is ClassMirror); | |
223 Expect.isTrue(isMixinApplication(H_super)); | |
224 Expect.equals(1, H_super.superinterfaces.length); | |
225 Expect.isTrue(containsDeclaration(M2, H_super.superinterfaces)); | |
226 Expect.isTrue(isSameDeclaration(M2, H_super.mixin)); | |
227 Expect.isFalse(isObject(H_super)); | |
228 Expect.isTrue(isSameDeclaration(S, H_super.superclass)); | |
229 | |
230 Expect.isTrue(isSameDeclaration(S, getSuperclass(H))); | |
231 Expect.isTrue(isSameDeclarationList([M2, M1], getAppliedMixins(H))); | |
232 Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(H))); | |
233 | |
234 // class H2 extends H {} | |
235 var H2 = library.declarations[#H2]; | |
236 Expect.isTrue(isSameDeclaration(H, getSuperclass(H2))); | |
237 Expect.isTrue(getAppliedMixins(H2).isEmpty); | |
238 Expect.isTrue(getExplicitInterfaces(H2).isEmpty); | |
239 })); | |
240 } | |
OLD | NEW |