Add test for ClassMirror.mixin. Rename the mixin application test.

tests/lib/mirrors/mixin_test.dart

 // 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.
 
-// This test uses the multi-test "ok" feature to create two positive tests from
-// one file. One of these tests fail on dart2js, but pass on the VM, or vice
-// versa.
-// TODO(ahe): When both implementations agree, remove the multi-test parts.
-
-library test.mixin_test;
+library test.mixin;
 
 import 'dart:mirrors';
 
 import 'package:expect/expect.dart';
 
-import 'model.dart';
-import 'stringify.dart';
+class Super {}
+class Mixin {}
+class Mixin2 {}
+class Mixin3 {}
 
-class Mixin {
-  int i;
-  m() {}
-}
-
-class Mixin2 {
-  int i2;
-  m2() {}
-}
-
-typedef MixinApplication = C with Mixin;
-typedef MixinApplicationA = C with Mixin, Mixin2;
-
-typedef UnusedMixinApplication = C with Mixin;
-
-class Subclass extends C with Mixin {
-  f() {}
-}
-
-class Subclass2 extends MixinApplication {
-  g() {}
-}
-
-class SubclassA extends C with Mixin, Mixin2 {
-  fa() {}
-}
-
-class Subclass2A extends MixinApplicationA {
-  ga() {}
-}
-
-checkClass(Type type, List<String> expectedSuperclasses) {
-  int i = 0;
-  for (var cls = reflectClass(type); cls != null; cls = cls.superclass) {
-    expect(expectedSuperclasses[i++], cls);
-  }
-  Expect.equals(i, expectedSuperclasses.length, '$type');
-}
-
-expectSame(ClassMirror a, ClassMirror b) {
-  Expect.equals(a, b);
-  expect(stringify(a), b);
-  expect(stringify(b), a);
-}
-
-testMixin() {
-  checkClass(Mixin, [
-      'Class(s(Mixin) in s(test.mixin_test), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  expect(
-      '{i: Variable(s(i) in s(Mixin)),'
-      ' m: Method(s(m) in s(Mixin))}',
-      reflectClass(Mixin).members);
-
-  expect('{Mixin: Method(s(Mixin) in s(Mixin), constructor)}',
-         reflectClass(Mixin).constructors);
-}
-
-testMixin2() {
-  checkClass(Mixin2, [
-      'Class(s(Mixin2) in s(test.mixin_test), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  expect(
-      '{i2: Variable(s(i2) in s(Mixin2)),'
-      ' m2: Method(s(m2) in s(Mixin2))}',
-      reflectClass(Mixin2).members);
-
-  expect('{Mixin2: Method(s(Mixin2) in s(Mixin2), constructor)}',
-         reflectClass(Mixin2).constructors);
-}
-
-testMixinApplication() {
-  checkClass(MixinApplication, [
-      'Class(s(MixinApplication) in s(test.mixin_test), top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  String owner = 'Mixin';
-  owner = 'MixinApplication'; /// 01: ok
-  expect(
-      '{i: Variable(s(i) in s($owner)),'
-      ' m: Method(s(m) in s($owner))}',
-      reflectClass(MixinApplication).members);
-
-  expect('{MixinApplication: Method(s(MixinApplication) in s(MixinApplication),'
-         ' constructor)}',
-         reflectClass(MixinApplication).constructors);
-
-  expectSame(reflectClass(C), reflectClass(MixinApplication).superclass);
-}
-
-testMixinApplicationA() {
-  // TODO(ahe): I don't think an anonymous mixin has an owner.
-  String owner = ' in s(test.mixin_test)';
-  owner = ''; /// 01: ok
-  checkClass(MixinApplicationA, [
-      'Class(s(MixinApplicationA) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin)$owner, top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  owner = 'Mixin2';
-  owner = 'MixinApplicationA'; /// 01: ok
-  expect(
-      '{i2: Variable(s(i2) in s($owner)),'
-      ' m2: Method(s(m2) in s($owner))}',
-      reflectClass(MixinApplicationA).members);
-
-  expect(
-      '{MixinApplicationA: Method(s(MixinApplicationA) in s(MixinApplicationA),'
-      ' constructor)}',
-      reflectClass(MixinApplicationA).constructors);
-
-  expect(
-      '{i: Variable(s(i) in s(Mixin)),'
-      ' m: Method(s(m) in s(Mixin))}',
-      reflectClass(MixinApplicationA).superclass.members);
-
-  String name = 'test.model.C with test.mixin_test.Mixin';
-  name = 'Mixin'; /// 01: ok
-  expect(
-      '{$name:'
-      ' Method(s($name)'
-      ' in s($name), constructor)}',
-      reflectClass(MixinApplicationA).superclass.constructors);
-
-  expectSame(
-      reflectClass(C),
-      reflectClass(MixinApplicationA).superclass.superclass);
-}
-
-testUnusedMixinApplication() {
-  checkClass(UnusedMixinApplication, [
-      'Class(s(UnusedMixinApplication) in s(test.mixin_test), top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  String owner = 'Mixin';
-  owner = 'UnusedMixinApplication'; /// 01: ok
-  expect(
-      '{i: Variable(s(i) in s($owner)),'
-      ' m: Method(s(m) in s($owner))}',
-      reflectClass(UnusedMixinApplication).members);
-
-  expect(
-      '{UnusedMixinApplication: Method(s(UnusedMixinApplication)'
-      ' in s(UnusedMixinApplication), constructor)}',
-      reflectClass(UnusedMixinApplication).constructors);
-
-  expectSame(reflectClass(C), reflectClass(UnusedMixinApplication).superclass);
-}
-
-testSubclass() {
-  String owner = ' in s(test.mixin_test)';
-  owner = ''; /// 01: ok
-  checkClass(Subclass, [
-      'Class(s(Subclass) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin)$owner, top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  expect(
-      '{f: Method(s(f) in s(Subclass))}',
-      reflectClass(Subclass).members);
-
-  expect(
-      '{Subclass: Method(s(Subclass) in s(Subclass), constructor)}',
-      reflectClass(Subclass).constructors);
-
-  expect(
-      '{i: Variable(s(i) in s(Mixin)),'
-      ' m: Method(s(m) in s(Mixin))}',
-      reflectClass(Subclass).superclass.members);
-
-  String name = 'test.model.C with test.mixin_test.Mixin';
-  name = 'Mixin'; /// 01: ok
-  expect(
-      '{$name:'
-      ' Method(s($name)'
-      ' in s($name), constructor)}',
-      reflectClass(Subclass).superclass.constructors);
-
-  expectSame(
-      reflectClass(C),
-      reflectClass(Subclass).superclass.superclass);
-}
-
-testSubclass2() {
-  checkClass(Subclass2, [
-      'Class(s(Subclass2) in s(test.mixin_test), top-level)',
-      'Class(s(MixinApplication) in s(test.mixin_test), top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  expect(
-      '{g: Method(s(g) in s(Subclass2))}',
-      reflectClass(Subclass2).members);
-
-  expect(
-      '{Subclass2: Method(s(Subclass2) in s(Subclass2), constructor)}',
-      reflectClass(Subclass2).constructors);
-
-  expectSame(
-      reflectClass(MixinApplication),
-      reflectClass(Subclass2).superclass);
-}
-
-testSubclassA() {
-  // TODO(ahe): I don't think an anonymous mixin has an owner.
-  String owner = ' in s(test.mixin_test)';
-  owner = ''; /// 01: ok
-  checkClass(SubclassA, [
-      'Class(s(SubclassA) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin, test.mixin_test.Mixin2)'
-      '$owner, top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin)$owner, top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  expect(
-      '{fa: Method(s(fa) in s(SubclassA))}',
-      reflectClass(SubclassA).members);
-
-  expect(
-      '{SubclassA: Method(s(SubclassA) in s(SubclassA), constructor)}',
-      reflectClass(SubclassA).constructors);
-
-  expect(
-      '{i2: Variable(s(i2) in s(Mixin2)),'
-      ' m2: Method(s(m2) in s(Mixin2))}',
-      reflectClass(SubclassA).superclass.members);
-
-  String name =
-      'test.model.C with test.mixin_test.Mixin, test.mixin_test.Mixin2';
-  name = 'Mixin2'; /// 01: ok
-  expect(
-      '{$name: Method(s($name) in s($name), constructor)}',
-      reflectClass(SubclassA).superclass.constructors);
-
-  expect(
-      '{i: Variable(s(i) in s(Mixin)),'
-      ' m: Method(s(m) in s(Mixin))}',
-      reflectClass(SubclassA).superclass.superclass.members);
-
-  name = 'test.model.C with test.mixin_test.Mixin';
-  name = 'Mixin'; /// 01: ok
-  expect(
-      '{$name:'
-      ' Method(s($name)'
-      ' in s($name), constructor)}',
-      reflectClass(SubclassA).superclass.superclass.constructors);
-
-  expectSame(
-      reflectClass(C),
-      reflectClass(SubclassA).superclass.superclass.superclass);
-}
-
-testSubclass2A() {
-  // TODO(ahe): I don't think an anonymous mixin has an owner.
-  String owner = ' in s(test.mixin_test)';
-  owner = ''; /// 01: ok
-  checkClass(Subclass2A, [
-      'Class(s(Subclass2A) in s(test.mixin_test), top-level)',
-      'Class(s(MixinApplicationA) in s(test.mixin_test), top-level)',
-      'Class(s(test.model.C with test.mixin_test.Mixin)$owner,'
-      ' top-level)',
-      'Class(s(C) in s(test.model), top-level)',
-      'Class(s(B) in s(test.model), top-level)',
-      'Class(s(A) in s(test.model), top-level)',
-      'Class(s(Object) in s(dart.core), top-level)',
-  ]);
-
-  expect(
-      '{ga: Method(s(ga) in s(Subclass2A))}',
-      reflectClass(Subclass2A).members);
-
-  expect(
-      '{Subclass2A: Method(s(Subclass2A) in s(Subclass2A), constructor)}',
-      reflectClass(Subclass2A).constructors);
-
-  expectSame(reflectClass(MixinApplicationA),
-             reflectClass(Subclass2A).superclass);
-}
+typedef MixinApplication = Super with Mixin;
+class Class extends Super with Mixin {}
+class MultipleMixins extends Super with Mixin, Mixin2, Mixin3 {}
 
 main() {
-  testMixin();
-  testMixin2();
-  testMixinApplication();
-  testMixinApplicationA();
-  testUnusedMixinApplication();
-  testSubclass();
-  testSubclass2();
-  testSubclassA();
-  testSubclass2A();
+  Expect.equals(reflectClass(Mixin),
+                reflectClass(MixinApplication).mixin);
+  Expect.equals(reflectClass(Super),
+                reflectClass(MixinApplication).superclass.mixin);
+
+  Expect.equals(reflectClass(Class),
+                reflectClass(Class).mixin);
+  Expect.equals(reflectClass(Mixin),
+                reflectClass(Class).superclass.mixin);
+  Expect.equals(reflectClass(Super),
+                reflectClass(Class).superclass.superclass.mixin);
+
+  Expect.equals(reflectClass(MultipleMixins),
+                reflectClass(MultipleMixins).mixin);
+  Expect.equals(reflectClass(Mixin3),
+                reflectClass(MultipleMixins).superclass.mixin);
+  Expect.equals(reflectClass(Mixin2),
+                reflectClass(MultipleMixins).superclass.superclass.mixin);
+  Expect.equals(reflectClass(Mixin),
+                reflectClass(MultipleMixins).superclass.superclass.superclass
+                    .mixin);
+  Expect.equals(reflectClass(Super),
+                reflectClass(MultipleMixins).superclass.superclass.superclass
+                    .superclass.mixin);
 }