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(cls.isObject); |
| 39 Expect.isTrue(cls.superclass.isObject); |
| 40 Expect.equals(0, cls.superinterfaces.length); |
| 41 |
| 42 Expect.isTrue(getSuperclass(cls).isObject); |
| 43 Expect.isTrue(getAppliedMixins(cls).isEmpty); |
| 44 Expect.isTrue(getExplicitInterfaces(cls).isEmpty); |
| 45 } |
| 46 |
| 47 // class A {} |
| 48 var A = library.classes['A']; |
| 49 checkSimpleClass(A); |
| 50 |
| 51 // class S {} |
| 52 var S = library.classes['S']; |
| 53 checkSimpleClass(S); |
| 54 |
| 55 // class M1 {} |
| 56 var M1 = library.classes['M1']; |
| 57 checkSimpleClass(M1); |
| 58 |
| 59 // class M2 {} |
| 60 var M2 = library.classes['M2']; |
| 61 checkSimpleClass(M2); |
| 62 |
| 63 // class C extends S with M1<A> {} |
| 64 var C = library.classes['C']; |
| 65 Expect.isNotNull(C); |
| 66 Expect.isTrue(C is ClassMirror); |
| 67 Expect.isFalse(isMixinApplication(C)); |
| 68 Expect.isFalse(C.isObject); |
| 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(C_super.isObject); |
| 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.classes['D']; |
| 87 Expect.isNotNull(D); |
| 88 Expect.isTrue(D is ClassMirror); |
| 89 Expect.isFalse(isMixinApplication(D)); |
| 90 Expect.isFalse(D.isObject); |
| 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(D_super.isObject); |
| 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(D_super_super.isObject); |
| 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.classes['E']; |
| 119 Expect.isNotNull(E); |
| 120 Expect.isTrue(E is ClassMirror); |
| 121 Expect.isFalse(isMixinApplication(E)); |
| 122 Expect.isFalse(E.isObject); |
| 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(E_super.isObject); |
| 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(E_super_super.isObject); |
| 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.classes['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.classes['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(F.isObject); |
| 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(F_super.isObject); |
| 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.classes['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(G.isObject); |
| 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(G_super.isObject); |
| 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.classes['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(H.isObject); |
| 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(H_super.isObject); |
| 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.classes['H2']; |
| 236 Expect.isTrue(isSameDeclaration(H, getSuperclass(H2))); |
| 237 Expect.isTrue(getAppliedMixins(H2).isEmpty); |
| 238 Expect.isTrue(getExplicitInterfaces(H2).isEmpty); |
| 239 })); |
| 240 } |
OLD | NEW |