Adding package:smoke. This CL includes the intial APIs, a mirror-based

pkg/smoke/test/common.dart

Index: pkg/smoke/test/common.dart
diff --git a/pkg/smoke/test/common.dart b/pkg/smoke/test/common.dart
new file mode 100644
index 0000000000000000000000000000000000000000..d6b1fb29d3babf9b9ceeddac95e982c78eefe826
--- /dev/null
+++ b/pkg/smoke/test/common.dart
@@ -0,0 +1,333 @@
+// Copyright (c) 2014, 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.
+
+/// Common test code that is run by 3 tests: mirrors_test.dart,
+/// mirrors_used_test.dart, and static_test.dart.
+library smoke.test.common;
+
+import 'package:smoke/smoke.dart' as smoke;
+import 'package:unittest/unittest.dart';
+
+main() {
+  test('read value', () {
+    var a = new A();
+    expect(smoke.read(a, #i), 42);
+    expect(smoke.read(a, #j), 44);
+    expect(smoke.read(a, #j2), 44);
+  });
+
+  test('write value', () {
+    var a = new A();
+    smoke.write(a, #i, 43);
+    expect(a.i, 43);
+    smoke.write(a, #j2, 46);
+    expect(a.j, 46);
+    expect(a.j2, 46);
+    expect(smoke.read(a, #j), 46);
+    expect(smoke.read(a, #j2), 46);
+  });
+
+  test('invoke', () {
+    var a = new A();
+
+    smoke.invoke(a, #inc0, []);
+    expect(a.i, 43);
+    expect(smoke.read(a, #i), 43);
+    expect(() => smoke.invoke(a, #inc0, [2]), throws);
+    expect(a.i, 43);
+    expect(() => smoke.invoke(a, #inc0, [1, 2, 3]), throws);
+    expect(a.i, 43);
+
+    expect(() => smoke.invoke(a, #inc1, []), throws);
+    expect(a.i, 43);
+    smoke.invoke(a, #inc1, [4]);
+    expect(a.i, 47);
+
+    smoke.invoke(a, #inc2, []);
+    expect(a.i, 37);
+    smoke.invoke(a, #inc2, [4]);
+    expect(a.i, 41);
+
+    expect(() => smoke.invoke(a, #inc1, [4, 5]), throws);
+    expect(a.i, 41);
+  });
+
+  test('read and invoke function', () {
+    var a = new A();
+    expect(a.i, 42);
+    var f = smoke.read(a, #inc1);
+    f(4);
+    expect(a.i, 46);
+    Function.apply(f, [4]);
+    expect(a.i, 50);
+  });
+
+  test('invoke with adjust', () {
+    var a = new A();
+    smoke.invoke(a, #inc0, [], adjust: true);
+    expect(a.i, 43);
+    smoke.invoke(a, #inc0, [2], adjust: true);
+    expect(a.i, 44);
+    smoke.invoke(a, #inc0, [1, 2, 3], adjust: true);
+    expect(a.i, 45);
+
+    smoke.invoke(a, #inc1, [], adjust: true); // treat as null (-10)
+    expect(a.i, 35);
+    smoke.invoke(a, #inc1, [4], adjust: true);
+    expect(a.i, 39);
+
+    smoke.invoke(a, #inc2, [], adjust: true); // default is null (-10)
+    expect(a.i, 29);
+    smoke.invoke(a, #inc2, [4, 5], adjust: true);
+    expect(a.i, 33);
+  });
+
+  test('has getter', () {
+    expect(smoke.hasGetter(A, #i), isTrue);
+    expect(smoke.hasGetter(A, #j2), isTrue);
+    expect(smoke.hasGetter(A, #inc2), isTrue);
+    expect(smoke.hasGetter(B, #a), isTrue);
+    expect(smoke.hasGetter(B, #i), isFalse);
+    expect(smoke.hasGetter(B, #f), isTrue);
+    expect(smoke.hasGetter(D, #i), isTrue);
+
+    expect(smoke.hasGetter(E, #x), isFalse);
+    expect(smoke.hasGetter(E, #y), isTrue);
+    expect(smoke.hasGetter(E, #z), isFalse); // don't consider noSuchMethod
+  });
+
+  test('has setter', () {
+    expect(smoke.hasSetter(A, #i), isTrue);
+    expect(smoke.hasSetter(A, #j2), isTrue);
+    expect(smoke.hasSetter(A, #inc2), isFalse);
+    expect(smoke.hasSetter(B, #a), isTrue);
+    expect(smoke.hasSetter(B, #i), isFalse);
+    expect(smoke.hasSetter(B, #f), isFalse);
+    expect(smoke.hasSetter(D, #i), isTrue);
+
+    // TODO(sigmund): should we support declaring a setter with no getter?
+    // expect(smoke.hasSetter(E, #x), isTrue);
+    expect(smoke.hasSetter(E, #y), isFalse);
+    expect(smoke.hasSetter(E, #z), isFalse); // don't consider noSuchMethod
+  });
+
+  test('no such method', () {
+    expect(smoke.hasNoSuchMethod(A), isFalse);
+    expect(smoke.hasNoSuchMethod(E), isTrue);
+    expect(smoke.hasNoSuchMethod(E2), isTrue);
+  });
+
+  test('has instance method', () {
+    expect(smoke.hasInstanceMethod(A, #inc0), isTrue);
+    expect(smoke.hasInstanceMethod(A, #inc3), isFalse);
+    expect(smoke.hasInstanceMethod(C, #inc), isTrue);
+    expect(smoke.hasInstanceMethod(D, #inc), isTrue);
+    expect(smoke.hasInstanceMethod(D, #inc0), isTrue);
+    expect(smoke.hasInstanceMethod(F, #staticMethod), isFalse);
+    expect(smoke.hasInstanceMethod(F2, #staticMethod), isFalse);
+  });
+
+  test('has static method', () {
+    expect(smoke.hasStaticMethod(A, #inc0), isFalse);
+    expect(smoke.hasStaticMethod(C, #inc), isFalse);
+    expect(smoke.hasStaticMethod(D, #inc), isFalse);
+    expect(smoke.hasStaticMethod(D, #inc0), isFalse);
+    expect(smoke.hasStaticMethod(F, #staticMethod), isTrue);
+    expect(smoke.hasStaticMethod(F2, #staticMethod), isFalse);
+  });
+
+  test('get declaration', () {
+    var d = smoke.getDeclaration(B, #a);
+    expect(d.name, #a);
+    expect(d.isProperty, isTrue);
+    expect(d.isMethod, isFalse);
+    expect(d.isFinal, isFalse);
+    expect(d.isStatic, isFalse);
+    expect(d.annotations, []);
+    expect(d.type, A);
+
+    d = smoke.getDeclaration(B, #w);
+    expect(d.name, #w);
+    expect(d.isProperty, isTrue);
+    expect(d.isMethod, isFalse);
+    expect(d.isFinal, isFalse);
+    expect(d.isStatic, isFalse);
+    expect(d.annotations, []);
+    expect(d.type, int);
+
+    d = smoke.getDeclaration(A, #inc1);
+    expect(d.name, #inc1);
+    expect(d.isProperty, isFalse);
+    expect(d.isMethod, isTrue);
+    expect(d.isFinal, isFalse);
+    expect(d.isStatic, isFalse);
+    expect(d.annotations, []);
+    expect(d.type, Function);
+
+    d = smoke.getDeclaration(F, #staticMethod);
+    expect(d.name, #staticMethod);
+    expect(d.isProperty, isFalse);
+    expect(d.isMethod, isTrue);
+    expect(d.isFinal, isFalse);
+    expect(d.isStatic, isTrue);
+    expect(d.annotations, []);
+    expect(d.type, Function);
+
+    d = smoke.getDeclaration(G, #b);
+    expect(d.name, #b);
+    expect(d.isProperty, isTrue);
+    expect(d.isMethod, isFalse);
+    expect(d.isFinal, isFalse);
+    expect(d.isStatic, isFalse);
+    expect(d.annotations, [const Annot()]);
+    expect(d.type, int);
+
+    d = smoke.getDeclaration(G, #d);
+    expect(d.name, #d);
+    expect(d.isProperty, isTrue);
+    expect(d.isMethod, isFalse);
+    expect(d.isFinal, isFalse);
+    expect(d.isStatic, isFalse);
+    expect(d.annotations, [32]);
+    expect(d.type, int);
+  });
+
+  group('query', () {
+    test('default', () {
+      var options = new smoke.QueryOptions();
+      var res = smoke.query(A, options);
+      expect(res.map((e) => e.name), [#i, #j, #j2]);
+    });
+
+    test('properties and methods', () {
+      var options = new smoke.QueryOptions(includeMethods: true);
+      var res = smoke.query(A, options);
+      expect(res.map((e) => e.name), [#i, #j, #j2, #inc0, #inc1, #inc2]);
+    });
+
+    test('inherited properties', () {
+      var options = new smoke.QueryOptions(includeInherited: true);
+      var res = smoke.query(D, options);
+      expect(res.map((e) => e.name), [#x, #y, #b, #i, #j, #j2, #x2, #i2]);
+    });
+
+    test('exact annotation', () {
+      var options = new smoke.QueryOptions(includeInherited: true,
+          withAnnotations: const [a1]);
+      var res = smoke.query(H, options);
+      expect(res.map((e) => e.name), [#b, #f, #g]);
+
+      options = new smoke.QueryOptions(includeInherited: true,
+          withAnnotations: const [a2]);
+      res = smoke.query(H, options);
+      expect(res.map((e) => e.name), [#d, #h]);
+
+      options = new smoke.QueryOptions(includeInherited: true,
+          withAnnotations: const [a1, a2]);
+      res = smoke.query(H, options);
+      expect(res.map((e) => e.name), [#b, #d, #f, #g, #h]);
+    });
+
+    test('type annotation', () {
+      var options = new smoke.QueryOptions(includeInherited: true,
+          withAnnotations: const [Annot]);
+      var res = smoke.query(H, options);
+      expect(res.map((e) => e.name), [#b, #f, #g]);
+    });
+
+    test('mixed annotations (type and exact)', () {
+      var options = new smoke.QueryOptions(includeInherited: true,
+          withAnnotations: const [a2, Annot]);
+      var res = smoke.query(H, options);
+      expect(res.map((e) => e.name), [#b, #d, #f, #g, #h]);
+    });
+
+    test('symbol to name', () {
+      expect(smoke.symbolToName(#i), 'i');
+    });
+
+    test('name to symbol', () {
+      expect(smoke.nameToSymbol('i'), #i);
+    });
+  });
+}
+
+class A {
+  int i = 42;
+  int j = 44;
+  int get j2 => j;
+  void set j2(int v) { j = v; }
+  void inc0() { i++; }
+  void inc1(int v) { i = i + (v == null ? -10 : v); }
+  void inc2([int v]) { i = i + (v == null ? -10 : v); }
+}
+
+class B {
+  final int f = 3;
+  int _w;
+  int get w => _w;
+  set w(int v) { _w = v; }
+
+  String z;
+  A a;
+
+  B(this._w, this.z, this.a);
+}
+
+class C {
+  int x;
+  String y;
+  B b;
+
+  inc(int n) {
+    x = x + n;
+  }
+  dec(int n) {
+    x = x - n;
+  }
+
+  C(this.x, this.y, this.b);
+}
+
+
+class D extends C with A {
+  int get x2 => x;
+  int get i2 => i;
+
+  D(x, y, b) : super(x, y, b);
+}
+
+class E {
+  set x(int v) { }
+  int get y => 1;
+
+  noSuchMethod(i) => y;
+}
+
+class E2 extends E {}
+
+class F {
+  static int staticMethod(A a) => a.i;
+}
+
+class F2 extends F {}
+
+class Annot { const Annot(); }
+const a1 = const Annot();
+const a2 = 32;
+
+
+class G {
+  int a;
+  @a1 int b;
+  int c;
+  @a2 int d;
+}
+
+class H extends G {
+  int e;
+  @a1 int f;
+  @a1 int g;
+  @a2 int h;
+}