Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1699)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: test/codegen/lib/mirrors/invoke_named_test.dart

Issue 2265533002: Add mirrors tests (Closed) Base URL: https://github.com/dart-lang/dev_compiler.git@master
Patch Set: Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « test/codegen/lib/mirrors/invoke_import_test.dart ('k') | test/codegen/lib/mirrors/invoke_natives_malicious_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/codegen/lib/mirrors/invoke_named_test.dart
diff --git a/test/codegen/lib/mirrors/invoke_named_test.dart b/test/codegen/lib/mirrors/invoke_named_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..feee0ab1a4c67aab3f62ea0486c699acbeacde73
--- /dev/null
+++ b/test/codegen/lib/mirrors/invoke_named_test.dart
@@ -0,0 +1,297 @@
+// 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 test.invoke_named_test;
+
+import 'dart:mirrors';
+
+import 'dart:async' show Future;
+
+import 'package:expect/expect.dart';
+import 'invoke_test.dart';
+
+// TODO(ahe): Remove this variable (http://dartbug.com/12863).
+bool isDart2js = false;
+
+class C {
+ a(a, {b:'B', c}) => "$a-$b-$c";
+ b({a:'A', b, c}) => "$a-$b-$c";
+ c(a, [b, c='C']) => "$a-$b-$c";
+ d([a, b='B', c='C']) => "$a-$b-$c";
+ e(a, b, c) => "$a-$b-$c";
+}
+
+class D {
+ static a(a, {b:'B', c}) => "$a-$b-$c";
+ static b({a:'A', b, c}) => "$a-$b-$c";
+ static c(a, [b, c='C']) => "$a-$b-$c";
+ static d([a, b='B', c='C']) => "$a-$b-$c";
+ static e(a, b, c) => "$a-$b-$c";
+}
+
+class E {
+ var field;
+ E(a, {b:'B', c}) : this.field = "$a-$b-$c";
+ E.b({a:'A', b, c}) : this.field = "$a-$b-$c";
+ E.c(a, [b, c='C']) : this.field = "$a-$b-$c";
+ E.d([a, b='B', c='C']) : this.field = "$a-$b-$c";
+ E.e(a, b, c) : this.field = "$a-$b-$c";
+}
+
+a(a, {b:'B', c}) => "$a-$b-$c";
+b({a:'A', b, c}) => "$a-$b-$c";
+c(a, [b, c='C']) => "$a-$b-$c";
+d([a, b='B', c='C']) => "$a-$b-$c";
+e(a, b, c) => "$a-$b-$c";
+
+testSyncInvoke(ObjectMirror om) {
+ InstanceMirror result;
+
+ result = om.invoke(const Symbol('a'), ['X']);
+ Expect.equals('X-B-null', result.reflectee);
+ result = om.invoke(const Symbol('a'), ['X'], {const Symbol('b') : 'Y'});
+ Expect.equals('X-Y-null', result.reflectee);
+ result = om.invoke(const Symbol('a'), ['X'], {const Symbol('c') : 'Z', const Symbol('b') : 'Y'});
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => om.invoke(const Symbol('a'), []),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('a'), ['X', 'Y']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('a'), ['X'], {const Symbol('undef') : 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = om.invoke(const Symbol('b'), []);
+ Expect.equals('A-null-null', result.reflectee);
+ result = om.invoke(const Symbol('b'), [], {const Symbol('a') : 'X'});
+ Expect.equals('X-null-null', result.reflectee);
+ result = om.invoke(const Symbol('b'), [], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => om.invoke(const Symbol('b'), ['X']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('b'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = om.invoke(const Symbol('c'), ['X']);
+ Expect.equals('X-null-C', result.reflectee);
+ result = om.invoke(const Symbol('c'), ['X', 'Y']);
+ Expect.equals('X-Y-C', result.reflectee);
+ result = om.invoke(const Symbol('c'), ['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => om.invoke(const Symbol('c'), []),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('c'), ['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('c'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = om.invoke(const Symbol('d'), []);
+ Expect.equals('null-B-C', result.reflectee);
+ result = om.invoke(const Symbol('d'), ['X']);
+ Expect.equals('X-B-C', result.reflectee);
+ result = om.invoke(const Symbol('d'), ['X', 'Y']);
+ Expect.equals('X-Y-C', result.reflectee);
+ result = om.invoke(const Symbol('d'), ['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => om.invoke(const Symbol('d'), ['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('d'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = om.invoke(const Symbol('e'), ['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => om.invoke(const Symbol('e'), ['X']),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('e'), ['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => om.invoke(const Symbol('e'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+}
+
+testSyncNewInstance() {
+ ClassMirror cm = reflectClass(E);
+ InstanceMirror result;
+
+ result = cm.newInstance(const Symbol(''), ['X']);
+ Expect.equals('X-B-null', result.reflectee.field);
+ result = cm.newInstance(const Symbol(''), ['X'], {const Symbol('b') : 'Y'});
+ Expect.equals('X-Y-null', result.reflectee.field);
+ result = cm.newInstance(const Symbol(''), ['X'], {const Symbol('c') : 'Z', const Symbol('b') : 'Y'});
+ Expect.equals('X-Y-Z', result.reflectee.field);
+ Expect.throws(() => cm.newInstance(const Symbol(''), []),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol(''), ['X', 'Y']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol(''), ['X'], {const Symbol('undef') : 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = cm.newInstance(const Symbol('b'), []);
+ Expect.equals('A-null-null', result.reflectee.field);
+ result = cm.newInstance(const Symbol('b'), [], {const Symbol('a') : 'X'});
+ Expect.equals('X-null-null', result.reflectee.field);
+ result = cm.newInstance(const Symbol('b'), [], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
+ Expect.equals('X-Y-Z', result.reflectee.field);
+ Expect.throws(() => cm.newInstance(const Symbol('b'), ['X']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol('b'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = cm.newInstance(const Symbol('c'), ['X']);
+ Expect.equals('X-null-C', result.reflectee.field);
+ result = cm.newInstance(const Symbol('c'), ['X', 'Y']);
+ Expect.equals('X-Y-C', result.reflectee.field);
+ result = cm.newInstance(const Symbol('c'), ['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee.field);
+ Expect.throws(() => cm.newInstance(const Symbol('c'), []),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol('c'), ['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol('c'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = cm.newInstance(const Symbol('d'), []);
+ Expect.equals('null-B-C', result.reflectee.field);
+ result = cm.newInstance(const Symbol('d'), ['X']);
+ Expect.equals('X-B-C', result.reflectee.field);
+ result = cm.newInstance(const Symbol('d'), ['X', 'Y']);
+ Expect.equals('X-Y-C', result.reflectee.field);
+ result = cm.newInstance(const Symbol('d'), ['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee.field);
+ Expect.throws(() => cm.newInstance(const Symbol('d'), ['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol('d'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ result = cm.newInstance(const Symbol('e'), ['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee.field);
+ Expect.throws(() => cm.newInstance(const Symbol('e'), ['X']),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol('e'), ['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.newInstance(const Symbol('e'), ['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+}
+
+testSyncApply() {
+ ClosureMirror cm;
+ InstanceMirror result;
+
+ cm = reflect(a);
+ result = cm.apply(['X']);
+ Expect.equals('X-B-null', result.reflectee);
+ result = cm.apply(['X'], {const Symbol('b') : 'Y'});
+ Expect.equals('X-Y-null', result.reflectee);
+ result = cm.apply(['X'], {const Symbol('c') : 'Z', const Symbol('b') : 'Y'});
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => cm.apply([]),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => cm.apply(['X', 'Y']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.apply(['X'], {const Symbol('undef') : 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ cm = reflect(b);
+ result = cm.apply([]);
+ Expect.equals('A-null-null', result.reflectee);
+ result = cm.apply([], {const Symbol('a') : 'X'});
+ Expect.equals('X-null-null', result.reflectee);
+ result = cm.apply([], {const Symbol('b') :'Y', const Symbol('c') :'Z', const Symbol('a') :'X'});
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => cm.apply(['X']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.apply(['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ cm = reflect(c);
+ result = cm.apply(['X']);
+ Expect.equals('X-null-C', result.reflectee);
+ result = cm.apply(['X', 'Y']);
+ Expect.equals('X-Y-C', result.reflectee);
+ result = cm.apply(['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => cm.apply([]),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => cm.apply(['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.apply(['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ cm = reflect(d);
+ result = cm.apply([]);
+ Expect.equals('null-B-C', result.reflectee);
+ result = cm.apply(['X']);
+ Expect.equals('X-B-C', result.reflectee);
+ result = cm.apply(['X', 'Y']);
+ Expect.equals('X-Y-C', result.reflectee);
+ result = cm.apply(['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => cm.apply(['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.apply(['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+
+ cm = reflect(e);
+ result = cm.apply(['X', 'Y', 'Z']);
+ Expect.equals('X-Y-Z', result.reflectee);
+ Expect.throws(() => cm.apply(['X']),
+ isNoSuchMethodError,
+ 'Insufficient positional arguments');
+ Expect.throws(() => cm.apply(['X', 'Y', 'Z', 'W']),
+ isNoSuchMethodError,
+ 'Extra positional arguments');
+ Expect.throws(() => cm.apply(['X'], {const Symbol('undef'): 'Y'}),
+ isNoSuchMethodError,
+ 'Unmatched named argument');
+}
+
+main() {
+ isDart2js = true; /// 01: ok
+
+ testSyncInvoke(reflect(new C())); // InstanceMirror
+
+ if (isDart2js) return;
+
+ testSyncInvoke(reflectClass(D)); // ClassMirror
+ LibraryMirror lib = reflectClass(D).owner;
+ testSyncInvoke(lib); // LibraryMirror
+
+ testSyncNewInstance();
+
+ testSyncApply();
+}
« no previous file with comments | « test/codegen/lib/mirrors/invoke_import_test.dart ('k') | test/codegen/lib/mirrors/invoke_natives_malicious_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698