| // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| library mirrors_mixin_test; |
| |
| import 'package:expect/expect.dart'; |
| import 'package:async_helper/async_helper.dart'; |
| import 'mirror_system_helper.dart'; |
| |
| const String CLASS_SOURCE = ''' |
| class A {} |
| |
| class S {} |
| class M1<T> {} |
| class M2 {} |
| |
| class C extends S with M1<A> {} |
| class D extends S with M1, M2 {} |
| class E extends S with M2, M1 implements A, M1 {} |
| class E2 extends E {} |
| |
| class F = S with M1<A>; |
| abstract class G = S with M1, M2; |
| class H = S with M2, M1 implements A, M1; |
| class H2 extends H {} |
| '''; |
| |
| void main() { |
| asyncTest(() => createMirrorSystem(CLASS_SOURCE).then((MirrorSystem mirrors) { |
| LibraryMirror library = mirrors.libraries[SOURCE_URI]; |
| |
| checkSimpleClass(var cls) { |
| Expect.isNotNull(cls); |
| Expect.isTrue(cls is ClassMirror); |
| Expect.isFalse(isMixinApplication(cls)); |
| Expect.isFalse(cls.isNameSynthetic); |
| Expect.isFalse(isObject(cls)); |
| Expect.isTrue(isObject(cls.superclass)); |
| Expect.equals(0, cls.superinterfaces.length); |
| |
| Expect.isTrue(isObject(getSuperclass(cls))); |
| Expect.isTrue(getAppliedMixins(cls).isEmpty); |
| Expect.isTrue(getExplicitInterfaces(cls).isEmpty); |
| } |
| |
| // class A {} |
| var A = library.declarations[#A]; |
| checkSimpleClass(A); |
| |
| // class S {} |
| var S = library.declarations[#S]; |
| checkSimpleClass(S); |
| |
| // class M1 {} |
| var M1 = library.declarations[#M1]; |
| checkSimpleClass(M1); |
| |
| // class M2 {} |
| var M2 = library.declarations[#M2]; |
| checkSimpleClass(M2); |
| |
| // class C extends S with M1<A> {} |
| var C = library.declarations[#C]; |
| Expect.isNotNull(C); |
| Expect.isTrue(C is ClassMirror); |
| Expect.isFalse(isMixinApplication(C)); |
| Expect.isFalse(isObject(C)); |
| Expect.equals(0, C.superinterfaces.length); |
| var C_super = C.superclass; |
| Expect.isNotNull(C_super); |
| Expect.isTrue(C_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(C_super)); |
| Expect.isTrue(C_super.isNameSynthetic); |
| Expect.equals(1, C_super.superinterfaces.length); |
| Expect.isTrue(containsType(M1, [A], C_super.superinterfaces)); |
| Expect.isTrue(isInstance(M1, [A], C_super.mixin)); |
| Expect.isFalse(isObject(C_super)); |
| Expect.isTrue(isSameDeclaration(S, C_super.superclass)); |
| |
| Expect.isTrue(isSameDeclaration(S, getSuperclass(C))); |
| Expect.isTrue(isSameDeclarationList([M1], getAppliedMixins(C))); |
| Expect.isTrue(getExplicitInterfaces(C).isEmpty); |
| |
| // D extends S with M1, M2 {} |
| var D = library.declarations[#D]; |
| Expect.isNotNull(D); |
| Expect.isTrue(D is ClassMirror); |
| Expect.isFalse(isMixinApplication(D)); |
| Expect.isFalse(isObject(D)); |
| Expect.equals(0, D.superinterfaces.length); |
| var D_super = D.superclass; |
| Expect.isNotNull(D_super); |
| Expect.isTrue(D_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(D_super)); |
| Expect.isTrue(D_super.isNameSynthetic); |
| Expect.equals(1, D_super.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M2, D_super.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M2, D_super.mixin)); |
| Expect.isFalse(isObject(D_super)); |
| Expect.isFalse(isSameDeclaration(S, D_super.superclass)); |
| var D_super_super = D_super.superclass; |
| Expect.isNotNull(D_super_super); |
| Expect.isTrue(D_super_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(D_super_super)); |
| Expect.isTrue(D_super_super.isNameSynthetic); |
| Expect.equals(1, D_super_super.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M1, D_super_super.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M1, D_super_super.mixin)); |
| Expect.isFalse(isObject(D_super_super)); |
| Expect.isTrue(isSameDeclaration(S, D_super_super.superclass)); |
| |
| Expect.isTrue(isSameDeclaration(S, getSuperclass(D))); |
| Expect.isTrue(isSameDeclarationList([M1, M2], getAppliedMixins(D))); |
| Expect.isTrue(getExplicitInterfaces(D).isEmpty); |
| |
| // class E extends S with M2, M1 implements A, M1 {} |
| var E = library.declarations[#E]; |
| Expect.isNotNull(E); |
| Expect.isTrue(E is ClassMirror); |
| Expect.isFalse(isMixinApplication(E)); |
| Expect.isFalse(isObject(E)); |
| Expect.equals(2, E.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(A, E.superinterfaces)); |
| Expect.isTrue(containsDeclaration(M1, E.superinterfaces)); |
| var E_super = E.superclass; |
| Expect.isNotNull(E_super); |
| Expect.isTrue(E_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(E_super)); |
| Expect.isTrue(E_super.isNameSynthetic); |
| Expect.equals(1, E_super.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M1, E_super.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M1, E_super.mixin)); |
| Expect.isFalse(isObject(E_super)); |
| Expect.isFalse(isSameDeclaration(S, E_super.superclass)); |
| var E_super_super = E_super.superclass; |
| Expect.isNotNull(E_super_super); |
| Expect.isTrue(E_super_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(E_super_super)); |
| Expect.isTrue(E_super_super.isNameSynthetic); |
| Expect.equals(1, E_super_super.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M2, E_super_super.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M2, E_super_super.mixin)); |
| Expect.isFalse(isObject(E_super_super)); |
| Expect.isTrue(isSameDeclaration(S, E_super_super.superclass)); |
| |
| Expect.isTrue(isSameDeclaration(S, getSuperclass(E))); |
| Expect.isTrue(isSameDeclarationList([M2, M1], getAppliedMixins(E))); |
| Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(E))); |
| |
| // class E2 extends E {} |
| var E2 = library.declarations[#E2]; |
| Expect.isTrue(isSameDeclaration(E, getSuperclass(E2))); |
| Expect.isTrue(getAppliedMixins(E2).isEmpty); |
| Expect.isTrue(getExplicitInterfaces(E2).isEmpty); |
| |
| // class F = S with M1<A>; |
| var F = library.declarations[#F]; |
| Expect.isNotNull(F); |
| Expect.isTrue(F is ClassMirror); |
| Expect.isFalse(F.isAbstract); |
| Expect.isTrue(isMixinApplication(F)); |
| Expect.isFalse(F.isNameSynthetic); |
| Expect.equals(#F, F.simpleName); |
| Expect.isFalse(isObject(F)); |
| Expect.equals(1, F.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M1, F.superinterfaces)); |
| Expect.isTrue(isInstance(M1, [A], F.mixin)); |
| var F_super = F.superclass; |
| Expect.isNotNull(F_super); |
| Expect.isTrue(F_super is ClassMirror); |
| Expect.isFalse(isMixinApplication(F_super)); |
| Expect.isFalse(isObject(F_super)); |
| Expect.isTrue(isSameDeclaration(S, F_super)); |
| |
| Expect.isTrue(isSameDeclaration(S, getSuperclass(F))); |
| Expect.isTrue(isSameDeclarationList([M1], getAppliedMixins(F))); |
| Expect.isTrue(getExplicitInterfaces(F).isEmpty); |
| |
| // typedef G = abstract S with M1, M2; |
| var G = library.declarations[#G]; |
| Expect.isNotNull(G); |
| Expect.isTrue(G is ClassMirror); |
| Expect.isTrue(G.isAbstract); |
| Expect.isTrue(isMixinApplication(G)); |
| Expect.isFalse(G.isNameSynthetic); |
| Expect.equals(#G, G.simpleName); |
| Expect.isFalse(isObject(G)); |
| Expect.equals(1, G.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M2, G.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M2, G.mixin)); |
| var G_super = G.superclass; |
| Expect.isNotNull(G_super); |
| Expect.isTrue(G_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(G_super)); |
| Expect.equals(1, G_super.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M1, G_super.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M1, G_super.mixin)); |
| Expect.isFalse(isObject(G_super)); |
| Expect.isTrue(isSameDeclaration(S, G_super.superclass)); |
| |
| Expect.isTrue(isSameDeclaration(S, getSuperclass(G))); |
| Expect.isTrue(isSameDeclarationList([M1, M2], getAppliedMixins(G))); |
| Expect.isTrue(getExplicitInterfaces(G).isEmpty); |
| |
| // typedef H = S with M2, M1 implements A, M1; |
| var H = library.declarations[#H]; |
| Expect.isNotNull(H); |
| Expect.isTrue(H is ClassMirror); |
| Expect.isFalse(H.isAbstract); |
| Expect.isTrue(isMixinApplication(H)); |
| Expect.isFalse(H.isNameSynthetic); |
| Expect.equals(#H, H.simpleName); |
| Expect.isFalse(isObject(H)); |
| Expect.equals(3, H.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(A, H.superinterfaces)); |
| Expect.isTrue(containsDeclaration(M1, H.superinterfaces)); |
| Expect.isFalse(containsDeclaration(M2, H.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M1, H.mixin)); |
| var H_super = H.superclass; |
| Expect.isNotNull(H_super); |
| Expect.isTrue(H_super is ClassMirror); |
| Expect.isTrue(isMixinApplication(H_super)); |
| Expect.equals(1, H_super.superinterfaces.length); |
| Expect.isTrue(containsDeclaration(M2, H_super.superinterfaces)); |
| Expect.isTrue(isSameDeclaration(M2, H_super.mixin)); |
| Expect.isFalse(isObject(H_super)); |
| Expect.isTrue(isSameDeclaration(S, H_super.superclass)); |
| |
| Expect.isTrue(isSameDeclaration(S, getSuperclass(H))); |
| Expect.isTrue(isSameDeclarationList([M2, M1], getAppliedMixins(H))); |
| Expect.isTrue(isSameDeclarationSet([A, M1], getExplicitInterfaces(H))); |
| |
| // class H2 extends H {} |
| var H2 = library.declarations[#H2]; |
| Expect.isTrue(isSameDeclaration(H, getSuperclass(H2))); |
| Expect.isTrue(getAppliedMixins(H2).isEmpty); |
| Expect.isTrue(getExplicitInterfaces(H2).isEmpty); |
| })); |
| } |