Index: tests/compiler/dart2js/mirrors_mixin_test.dart |
diff --git a/tests/compiler/dart2js/mirrors_mixin_test.dart b/tests/compiler/dart2js/mirrors_mixin_test.dart |
new file mode 100644 |
index 0000000000000000000000000000000000000000..954e907c2f1917d337b865e2018ac9fd5cbdc312 |
--- /dev/null |
+++ b/tests/compiler/dart2js/mirrors_mixin_test.dart |
@@ -0,0 +1,262 @@ |
+// 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 {} |
+ |
+typedef F = S with M1<A>; |
+typedef G = abstract S with M1, M2; |
+typedef 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]; |
+ |
+ // class A {} |
+ var A = library.classes['A']; |
+ 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.
|
+ Expect.isTrue(A is ClassMirror); |
+ Expect.isFalse(isMixinApplication(A)); |
+ Expect.isFalse(A.isObject); |
+ Expect.isTrue(A.superclass.isObject); |
+ Expect.equals(0, A.superinterfaces.length); |
+ |
+ Expect.isTrue(getExtends(A).isObject); |
+ Expect.isTrue(getWith(A).isEmpty); |
+ Expect.isTrue(getImplements(A).isEmpty); |
+ |
+ // class S {} |
+ var S = library.classes['S']; |
+ Expect.isNotNull(S); |
+ Expect.isTrue(S is ClassMirror); |
+ Expect.isFalse(isMixinApplication(S)); |
+ Expect.isFalse(S.isObject); |
+ Expect.isTrue(S.superclass.isObject); |
+ Expect.equals(0, S.superinterfaces.length); |
+ |
+ Expect.isTrue(getExtends(S).isObject); |
+ Expect.isTrue(getWith(S).isEmpty); |
+ Expect.isTrue(getImplements(S).isEmpty); |
+ |
+ // class M1 {} |
+ var M1 = library.classes['M1']; |
+ Expect.isNotNull(M1); |
+ Expect.isTrue(M1 is ClassMirror); |
+ Expect.isFalse(isMixinApplication(M1)); |
+ Expect.isFalse(M1.isObject); |
+ Expect.isTrue(M1.superclass.isObject); |
+ Expect.equals(0, M1.superinterfaces.length); |
+ |
+ Expect.isTrue(getExtends(M1).isObject); |
+ Expect.isTrue(getWith(M1).isEmpty); |
+ Expect.isTrue(getImplements(M1).isEmpty); |
+ |
+ // class M2 {} |
+ var M2 = library.classes['M2']; |
+ Expect.isNotNull(M2); |
+ Expect.isTrue(M2 is ClassMirror); |
+ Expect.isFalse(isMixinApplication(M2)); |
+ Expect.isFalse(M2.isObject); |
+ Expect.isTrue(M2.superclass.isObject); |
+ Expect.equals(0, M2.superinterfaces.length); |
+ |
+ Expect.isTrue(getExtends(M2).isObject); |
+ Expect.isTrue(getWith(M2).isEmpty); |
+ Expect.isTrue(getImplements(M2).isEmpty); |
+ |
+ // class C extends S with M1<A> {} |
+ var C = library.classes['C']; |
+ Expect.isNotNull(C); |
+ Expect.isTrue(C is ClassMirror); |
+ Expect.isFalse(isMixinApplication(C)); |
+ Expect.isFalse(C.isObject); |
+ 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.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.
|
+ Expect.equals(1, C_super.superinterfaces.length); |
+ Expect.isTrue(containsType(M1, [A], C_super.superinterfaces)); |
+ Expect.isTrue(isType(M1, [A], C_super.mixin)); |
+ Expect.isFalse(C_super.isObject); |
+ Expect.isTrue(sameDecl(S, C_super.superclass)); |
+ |
+ Expect.isTrue(sameDecl(S, getExtends(C))); |
+ Expect.isTrue(sameDeclList([M1], getWith(C))); |
+ Expect.isTrue(getImplements(C).isEmpty); |
+ |
+ // D extends S with M1, M2 {} |
+ var D = library.classes['D']; |
+ Expect.isNotNull(D); |
+ Expect.isTrue(D is ClassMirror); |
+ Expect.isFalse(isMixinApplication(D)); |
+ Expect.isFalse(D.isObject); |
+ 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.isFalse(!D_super.isNameSynthetic); |
+ Expect.equals(1, D_super.superinterfaces.length); |
+ Expect.isTrue(containsDecl(M2, D_super.superinterfaces)); |
+ Expect.isTrue(sameDecl(M2, D_super.mixin)); |
+ Expect.isFalse(D_super.isObject); |
+ Expect.isFalse(sameDecl(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.isFalse(!D_super_super.isNameSynthetic); |
+ Expect.equals(1, D_super_super.superinterfaces.length); |
+ Expect.isTrue(containsDecl(M1, D_super_super.superinterfaces)); |
+ Expect.isTrue(sameDecl(M1, D_super_super.mixin)); |
+ Expect.isFalse(D_super_super.isObject); |
+ Expect.isTrue(sameDecl(S, D_super_super.superclass)); |
+ |
+ Expect.isTrue(sameDecl(S, getExtends(D))); |
+ Expect.isTrue(sameDeclList([M1, M2], getWith(D))); |
+ Expect.isTrue(getImplements(D).isEmpty); |
+ |
+ // class E extends S with M2, M1 implements A, M1 {} |
+ var E = library.classes['E']; |
+ Expect.isNotNull(E); |
+ Expect.isTrue(E is ClassMirror); |
+ Expect.isFalse(isMixinApplication(E)); |
+ Expect.isFalse(E.isObject); |
+ Expect.equals(2, E.superinterfaces.length); |
+ Expect.isTrue(containsDecl(A, E.superinterfaces)); |
+ Expect.isTrue(containsDecl(M1, E.superinterfaces)); |
+ var E_super = E.superclass; |
+ Expect.isNotNull(E_super); |
+ Expect.isTrue(E_super is ClassMirror); |
+ Expect.isTrue(isMixinApplication(E_super)); |
+ Expect.isFalse(!E_super.isNameSynthetic); |
+ Expect.equals(1, E_super.superinterfaces.length); |
+ Expect.isTrue(containsDecl(M1, E_super.superinterfaces)); |
+ Expect.isTrue(sameDecl(M1, E_super.mixin)); |
+ Expect.isFalse(E_super.isObject); |
+ Expect.isFalse(sameDecl(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.isFalse(!E_super_super.isNameSynthetic); |
+ Expect.equals(1, E_super_super.superinterfaces.length); |
+ Expect.isTrue(containsDecl(M2, E_super_super.superinterfaces)); |
+ Expect.isTrue(sameDecl(M2, E_super_super.mixin)); |
+ Expect.isFalse(E_super_super.isObject); |
+ Expect.isTrue(sameDecl(S, E_super_super.superclass)); |
+ |
+ Expect.isTrue(sameDecl(S, getExtends(E))); |
+ Expect.isTrue(sameDeclList([M2, M1], getWith(E))); |
+ Expect.isTrue(sameDeclSet([A, M1], getImplements(E))); |
+ |
+ // class E2 extends E {} |
+ var E2 = library.classes['E2']; |
+ Expect.isTrue(sameDecl(E, getExtends(E2))); |
+ Expect.isTrue(getWith(E2).isEmpty); |
+ Expect.isTrue(getImplements(E2).isEmpty); |
+ |
+ // typedef F = S with M1<A>; |
+ var F = library.classes['F']; |
+ Expect.isNotNull(F); |
+ Expect.isTrue(F is ClassMirror); |
+ Expect.isFalse(F.isAbstract); |
+ Expect.isTrue(isMixinApplication(F)); |
+ Expect.isTrue(!F.isNameSynthetic); |
+ Expect.equals('F', F.simpleName); |
+ Expect.isFalse(F.isObject); |
+ Expect.equals(1, F.superinterfaces.length); |
+ Expect.isTrue(containsDecl(M1, F.superinterfaces)); |
+ Expect.isTrue(isType(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(F_super.isObject); |
+ Expect.isTrue(sameDecl(S, F_super)); |
+ |
+ Expect.isTrue(sameDecl(S, getExtends(F))); |
+ Expect.isTrue(sameDeclList([M1], getWith(F))); |
+ Expect.isTrue(getImplements(F).isEmpty); |
+ |
+ // typedef G = abstract S with M1, M2; |
+ var G = library.classes['G']; |
+ Expect.isNotNull(G); |
+ Expect.isTrue(G is ClassMirror); |
+ Expect.isTrue(G.isAbstract); |
+ Expect.isTrue(isMixinApplication(G)); |
+ Expect.isTrue(!G.isNameSynthetic); |
+ Expect.equals('G', G.simpleName); |
+ Expect.isFalse(G.isObject); |
+ Expect.equals(1, G.superinterfaces.length); |
+ Expect.isTrue(containsDecl(M2, G.superinterfaces)); |
+ Expect.isTrue(sameDecl(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(containsDecl(M1, G_super.superinterfaces)); |
+ Expect.isTrue(sameDecl(M1, G_super.mixin)); |
+ Expect.isFalse(G_super.isObject); |
+ Expect.isTrue(sameDecl(S, G_super.superclass)); |
+ |
+ Expect.isTrue(sameDecl(S, getExtends(G))); |
+ Expect.isTrue(sameDeclList([M1, M2], getWith(G))); |
+ Expect.isTrue(getImplements(G).isEmpty); |
+ |
+ // typedef H = S with M2, M1 implements A, M1; |
+ var H = library.classes['H']; |
+ Expect.isNotNull(H); |
+ Expect.isTrue(H is ClassMirror); |
+ Expect.isFalse(H.isAbstract); |
+ Expect.isTrue(isMixinApplication(H)); |
+ Expect.isTrue(!H.isNameSynthetic); |
+ Expect.equals('H', H.simpleName); |
+ Expect.isFalse(H.isObject); |
+ Expect.equals(3, H.superinterfaces.length); |
+ Expect.isTrue(containsDecl(A, H.superinterfaces)); |
+ Expect.isTrue(containsDecl(M1, H.superinterfaces)); |
+ Expect.isFalse(containsDecl(M2, H.superinterfaces)); |
+ Expect.isTrue(sameDecl(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(containsDecl(M2, H_super.superinterfaces)); |
+ Expect.isTrue(sameDecl(M2, H_super.mixin)); |
+ Expect.isFalse(H_super.isObject); |
+ Expect.isTrue(sameDecl(S, H_super.superclass)); |
+ |
+ Expect.isTrue(sameDecl(S, getExtends(H))); |
+ Expect.isTrue(sameDeclList([M2, M1], getWith(H))); |
+ Expect.isTrue(sameDeclSet([A, M1], getImplements(H))); |
+ |
+ // class H2 extends H {} |
+ var H2 = library.classes['H2']; |
+ Expect.isTrue(sameDecl(H, getExtends(H2))); |
+ Expect.isTrue(getWith(H2).isEmpty); |
+ Expect.isTrue(getImplements(H2).isEmpty); |
+ })); |
+} |