| // Copyright (c) 2015, 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. |
| |
| define(['dart_sdk'], function(dart_sdk) { |
| const assert = chai.assert; |
| const async = dart_sdk.async; |
| const core = dart_sdk.core; |
| const collection = dart_sdk.collection; |
| const dart = dart_sdk.dart; |
| const dartx = dart.dartx; |
| |
| dart.trapRuntimeErrors(false); |
| |
| suite('ignore', () => { |
| "use strict"; |
| |
| let FutureOr = async.FutureOr$; |
| let Future = async.Future$; |
| let List = core.List$; |
| |
| setup(() => { |
| dart_sdk.dart.ignoreWhitelistedErrors(false); |
| }); |
| |
| teardown(() => { |
| dart_sdk.dart.ignoreWhitelistedErrors(false); |
| }); |
| |
| test('FutureOr', () => { |
| let f = Future(dart.dynamic).value(42); |
| let l = [1, 2, 3]; |
| |
| assert.throws(() => { dart.as(f, FutureOr(core.int)); }); |
| assert.throws(() => { dart.as(l, FutureOr(List(core.int)))}); |
| |
| dart_sdk.dart.ignoreWhitelistedErrors(true); |
| assert.equal(f, dart.as(f, FutureOr(core.int))); |
| assert.equal(l, dart.as(l, FutureOr(List(core.int)))); |
| }); |
| }); |
| |
| suite('generic', () => { |
| "use strict"; |
| |
| let generic = dart.generic; |
| |
| test('zero arguments is not allowed', () => { |
| assert.throws(() => { generic(function(){}); }); |
| }); |
| |
| test('dcall noSuchMethod has correct error target', () => { |
| assert.throws(() => dart.dcall(42), |
| new RegExp('NoSuchMethodError.*\nReceiver: 42', 'm'), |
| 'Calls with non-function receiver should throw a NoSuchMethodError' + |
| ' with correct target'); |
| |
| // TODO(jmesserly): we should show the name "print" in there somewhere. |
| assert.throws(() => dart.dcall(core.print, 1, 2, 3), |
| new RegExp('NoSuchMethodError.*\n' + |
| "Receiver: Instance of '\\(Object\\) -> void'", 'm'), |
| 'Calls with incorrect argument types should throw a NoSuchMethodError' + |
| ' with correct target'); |
| }); |
| |
| test('can throw number', () => { |
| try { |
| dart.throw(42); |
| } catch (e) { |
| assert.equal(e, 42); |
| } |
| }); |
| |
| test('argument count cannot change', () => { |
| let SomeType = generic(function(x) { return {x: x}; }); |
| assert.throws(() => { SomeType(1,2) }); |
| let obj = {}; |
| assert.equal(SomeType(obj).x, obj); |
| assert.equal(SomeType(obj).x, obj); |
| assert.equal(SomeType().x, dart.dynamic); |
| }); |
| |
| test('undefined/null are not allowed', () => { |
| let SomeType = generic(function(x) {}); |
| assert.throws(() => { SomeType(void 0) }); |
| SomeType(1); |
| assert.throws(() => { SomeType(void 0) }); |
| SomeType(1); |
| assert.throws(() => { SomeType(null) }); |
| }); |
| |
| test('result is memoized', () => { |
| let t1 = Object.create(null); |
| let t2 = Object.create(null); |
| |
| let count = 0; |
| let SomeType = generic(function(x, y) { |
| count++; |
| return Object.create(null); |
| }); |
| |
| let x12 = SomeType(1, 2); |
| assert.strictEqual(SomeType(1, 2), x12); |
| assert.strictEqual(SomeType(1, 2), x12); |
| assert.strictEqual(count, 1); |
| let x11 = SomeType(1, 1); |
| assert.strictEqual(count, 2); |
| assert.strictEqual(SomeType(1, 1), x11); |
| assert.strictEqual(count, 2); |
| count = 0; |
| |
| let t1t2 = SomeType(t1, t2); |
| assert.strictEqual(count, 1); |
| let t2t1 = SomeType(t2, t1); |
| assert.strictEqual(count, 2); |
| assert.notStrictEqual(t1t2, t2t1); |
| assert.strictEqual(SomeType(t1, t2), t1t2); |
| assert.strictEqual(SomeType(t2, t1), t2t1); |
| assert.strictEqual(SomeType(t1, t2), t1t2); |
| count = 0; |
| |
| // Nothing has been stored on the object |
| assert.strictEqual(Object.keys(t1).length, 0); |
| assert.strictEqual(Object.keys(t2).length, 0); |
| }); |
| |
| test('type constructor is reflectable', () => { |
| let SomeType = generic(function(x, y) { return Object.create(null); }); |
| let someValue = SomeType('hi', 123); |
| assert.equal(dart.getGenericClass(someValue), SomeType); |
| assert.deepEqual(dart.getGenericArgs(someValue), ['hi', 123]); |
| }); |
| |
| test('proper type constructor is called', () => { |
| // This tests https://github.com/dart-lang/dev_compiler/issues/178 |
| let l = dart_sdk._interceptors.JSArray$(core.int).of([1, 2, 3]); |
| let s = l[dartx.join](); |
| assert.equal(s, '123'); |
| }); |
| }); |
| |
| |
| suite('instanceOf', () => { |
| "use strict"; |
| |
| let expect = assert.equal; |
| let generic = dart.generic; |
| let intIsNonNullable = false; |
| let cast = dart.as; |
| let instanceOf = dart.is; |
| let strongInstanceOf = dart.strongInstanceOf; |
| let getReifiedType = dart.getReifiedType; |
| let fnTypeFuzzy = dart.fnTypeFuzzy; |
| let typedef = dart.typedef; |
| let isSubtype = dart.isSubtype; |
| |
| let Object = core.Object; |
| let String = core.String; |
| let dynamic = dart.dynamic; |
| let List = core.List; |
| let Map = core.Map; |
| let Map$ = core.Map$; |
| let double = core.double; |
| let int = core.int; |
| let num = core.num; |
| let bool = core.bool; |
| |
| class A {} |
| class B extends A {} |
| class C extends B {} |
| |
| let AA$ = generic((T, U) => { |
| class AA extends core.Object {} |
| (AA.new = function() {}).prototype = AA.prototype; |
| return AA; |
| }); |
| let AA = AA$(); |
| let BB$ = generic((T, U) => { |
| class BB extends AA$(U, T) {} |
| (BB.new = function() {}).prototype = BB.prototype; |
| return BB; |
| }); |
| let BB = BB$(); |
| class CC extends BB$(String, List) {} |
| (CC.new = function() {}).prototype = CC.prototype; |
| |
| let Func2 = typedef('Func2', () => fnTypeFuzzy(dynamic, [dynamic, dynamic])); |
| let Foo = typedef('Foo', () => fnTypeFuzzy(B, [B, String])); |
| |
| let FuncG$ = generic((T, U) => typedef('FuncG', () => fnTypeFuzzy(T, [T, U]))) |
| let FuncG = FuncG$(); |
| |
| // TODO(vsm): Revisit when we encode types on functions properly. |
| // A bar1(C c, String s) => null; |
| function bar1(c, s) { return null; } |
| dart.fn(bar1, dart.fnType(A, [C, String])); |
| |
| // bar2(B b, String s) => null; |
| function bar2(b, s) { return null; } |
| dart.fn(bar2, dart.fnType(dynamic, [B, String])); |
| |
| // B bar3(B b, Object o) => null; |
| function bar3(b, o) { return null; } |
| dart.fn(bar3, dart.fnType(B, [B, Object])); |
| |
| // B bar4(B b, o) => null; |
| function bar4(b, o) { return null; } |
| dart.fn(bar4, dart.fnType(B, [B, dynamic])); |
| |
| // C bar5(A a, Object o) => null; |
| function bar5(a, o) { return null; } |
| dart.fn(bar5, dart.fnType(C, [A, Object])); |
| |
| // B bar6(B b, String s, String o) => null; |
| function bar6(b, s, o) { return null; } |
| dart.fn(bar6, dart.fnType(B, [B, String, String])); |
| |
| // B bar7(B b, String s, [Object o]) => null; |
| function bar7(b, s, o) { return null; } |
| dart.fn(bar7, dart.fnType(B, [B, String], [Object])); |
| |
| // B bar8(B b, String s, {Object p}) => null; |
| function bar8(b, s, o) { return null; } |
| dart.fn(bar8, dart.fnType(B, [B, String], {p: Object})); |
| |
| let cls1 = dart.fn((c, s) => { return null; }, |
| dart.fnType(A, [C, String])); |
| |
| let cls2 = dart.fn((b, s) => { return null; }, |
| dart.fnType(dynamic, [B, String])); |
| |
| let cls3 = dart.fn((b, o) => { return null; }, |
| dart.fnType(B, [B, Object])); |
| |
| let cls4 = dart.fn((b, o) => { return null; }, |
| dart.fnType(B, [B, dynamic])); |
| |
| let cls5 = dart.fn((a, o) => { return null; }, |
| dart.fnType(C, [A, Object])); |
| |
| let cls6 = dart.fn((b, s, o) => { return null; }, |
| dart.fnType(B, [B, String, String])); |
| |
| let cls7 = dart.fn((b, s, o) => { return null; }, |
| dart.fnType(B, [B, String], [Object])); |
| |
| let cls8 = |
| dart.fn((b, s, o) => { return null; }, |
| dart.fnType(B, [B, String], {p: Object})); |
| |
| function checkType(x, type, expectedTrue) { |
| if (expectedTrue === undefined) expectedTrue = true; |
| expect(instanceOf(x, type), expectedTrue, |
| '"' + x + '" ' + |
| (expectedTrue ? 'should' : 'should not') + |
| ' be an instance of "' + dart.typeName(type) + '"'); |
| } |
| |
| test('int', () => { |
| checkType(5, int); |
| checkType(5, dynamic); |
| checkType(5, Object); |
| checkType(5, num); |
| |
| checkType(5, bool, false); |
| checkType(5, String, false); |
| |
| expect(cast(5, int), 5); |
| if (intIsNonNullable) { |
| expect(() => cast(null, int), throws); |
| } else { |
| expect(cast(null, int), null); |
| } |
| }); |
| |
| test('dynamic', () => { |
| checkType(new Object.new(), dynamic); |
| checkType(null, dynamic); |
| |
| expect(cast(null, dynamic), null); |
| }); |
| |
| test('Object', () => { |
| checkType(new Object.new(), dynamic); |
| checkType(null, Object); |
| |
| expect(cast(null, Object), null); |
| }); |
| |
| test('null', () => { |
| // Object, dynamic cases are already handled above. |
| checkType(null, core.Null); |
| checkType(null, core.String, false); |
| checkType(null, core.int, false); |
| checkType(null, Map, false); |
| checkType(void 0, core.Null); |
| checkType(void 0, core.Object); |
| checkType(void 0, dart.dynamic); |
| }); |
| |
| test('String', () => { |
| checkType("foo", String); |
| checkType("foo", Object); |
| checkType("foo", dynamic); |
| |
| expect(cast(null, String), null); |
| }); |
| |
| test('FutureOr', () => { |
| let FutureOr = async.FutureOr$; |
| |
| assert.equal(dart.as(3, FutureOr(int)), 3); |
| assert.equal(dart.as(3, FutureOr(double)), 3); |
| assert.throws(() => dart.as(3.5, FutureOr(int))); |
| assert.equal(dart.as(3.5, FutureOr(double)), 3.5); |
| assert.isTrue(dart.is(3, FutureOr(int))); |
| assert.isTrue(dart.is(3, FutureOr(double))); |
| assert.isFalse(dart.is(3.5, FutureOr(int))); |
| assert.isTrue(dart.is(3.5, FutureOr(double))); |
| |
| assert.equal(dart.as(3, FutureOr(FutureOr(double))), 3); |
| assert.isTrue(dart.is(3, FutureOr(FutureOr(double)))); |
| |
| }); |
| |
| test('Map', () => { |
| let m1 = Map$(String, String).new(); |
| let m2 = Map$(Object, Object).new(); |
| let m3 = Map.new(); |
| let m4 = collection.HashMap$(dart.dynamic, dart.dynamic).new(); |
| let m5 = collection.LinkedHashMap.new(); |
| let m6 = Map$(String, dart.dynamic).new(); |
| |
| // Map<T1,T2> <: Map |
| checkType(m1, Map); |
| checkType(m1, Object); |
| |
| // Instance of self |
| checkType(m1, getReifiedType(m1)); |
| checkType(m1, Map$(String, String)); |
| |
| // Covariance on generics |
| checkType(m1, getReifiedType(m2)); |
| checkType(m1, Map$(Object, Object)); |
| |
| // No contravariance on generics. |
| checkType(m2, getReifiedType(m1), false); |
| checkType(m2, Map$(String, String), false); |
| |
| // null is! Map |
| checkType(null, Map, false); |
| |
| // Raw generic types |
| checkType(m5, Map); |
| checkType(m4, Map); |
| |
| // Is checks |
| assert.isFalse(dart.is(m3, Map$(String, String))); |
| assert.isFalse(dart.is(m6, Map$(String, String))); |
| assert.isTrue(dart.is(m1, Map$(String, String))); |
| assert.isFalse(dart.is(m2, Map$(String, String))); |
| |
| // As checks |
| // TODO(vsm): Enable these. We're currently only logging warnings on |
| // StrongModeErrors. |
| // assert.throws(() => dart.as(m3, Map$(String, String)), |
| // dart.StrongModeError); |
| // assert.throws(() => dart.as(m6, Map$(String, String)), |
| // dart.StrongModeError); |
| assert.equal(dart.as(m1, Map$(String, String)), m1); |
| // assert.throws(() => dart.as(m2, Map$(String, String)), |
| // dart.StrongModeError); |
| }); |
| |
| test('constructors', () => { |
| class C extends core.Object { |
| } |
| (C.new = function(x) {}).prototype = C.prototype; |
| (C.named = function(x, y) {}).prototype = C.prototype; |
| dart.setSignature(C, { |
| constructors: () => ({ |
| new: dart.fnType(C, [core.int]), |
| named: dart.fnType(C, [core.int, core.int]) |
| }) |
| }); |
| let getType = dart.classGetConstructorType; |
| isSubtype(getType(C), dart.fnTypeFuzzy(C, [core.int])); |
| isSubtype(getType(C), dart.fnTypeFuzzy(C, [core.String]), false); |
| isSubtype(getType(C, 'new'), dart.fnTypeFuzzy(C, [core.int])); |
| isSubtype(getType(C, 'new'), dart.fnTypeFuzzy(C, [core.String]), false); |
| isSubtype(getType(C, 'named'), dart.fnTypeFuzzy(C, [core.int, core.int])); |
| isSubtype(getType(C, 'named'), |
| dart.fnTypeFuzzy(C, [core.int, core.String]), false); |
| }); |
| |
| test('generic and inheritance', () => { |
| let aaraw = new AA.new(); |
| let aarawtype = getReifiedType(aaraw); |
| let aadynamic = new (AA$(dynamic, dynamic).new)(); |
| let aadynamictype = getReifiedType(aadynamic); |
| let aa = new (AA$(String, List).new)(); |
| let aatype = getReifiedType(aa); |
| let bb = new (BB$(String, List).new)(); |
| let bbtype = getReifiedType(bb); |
| let cc = new CC.new(); |
| let cctype = getReifiedType(cc); |
| // We don't allow constructing bad types. |
| // This was AA<String> in Dart (wrong number of type args). |
| let aabad = new (AA$(dart.dynamic, dart.dynamic).new)(); |
| let aabadtype = getReifiedType(aabad); |
| |
| checkType(cc, aatype, false); |
| checkType(cc, AA$(String, List), false); |
| checkType(cc, bbtype); |
| checkType(cc, BB$(String, List)); |
| checkType(aa, cctype, false); |
| checkType(aa, CC, false); |
| checkType(aa, bbtype, false); |
| checkType(aa, BB$(String, List), false); |
| checkType(bb, cctype, false); |
| checkType(bb, CC, false); |
| checkType(aa, aabadtype); |
| checkType(aa, dynamic); |
| checkType(aabad, aatype, false); |
| checkType(aabad, AA$(String, List), false); |
| checkType(aabad, aarawtype); |
| checkType(aabad, AA); |
| checkType(aaraw, aabadtype); |
| checkType(aaraw, AA$(dart.dynamic, dart.dynamic)); |
| checkType(aaraw, aadynamictype); |
| checkType(aaraw, AA$(dynamic, dynamic)); |
| checkType(aadynamic, aarawtype); |
| checkType(aadynamic, AA); |
| }); |
| |
| test('void', () => { |
| //checkType((x) => x, type((void _(x)) {})); |
| }); |
| |
| test('mixins', () => { |
| let c = collection; |
| var s1 = new (c.SplayTreeSet$(String).new)(); |
| |
| checkType(s1, c.IterableMixin); |
| checkType(s1, c.IterableMixin$(String)); |
| checkType(s1, c.IterableMixin$(int), false); |
| |
| checkType(s1, c.SetMixin); |
| checkType(s1, c.SetMixin$(String)); |
| checkType(s1, c.SetMixin$(int), false); |
| }); |
| |
| test('Type', () => { |
| checkType(int, core.Type, true); |
| checkType(num, core.Type, true); |
| checkType(bool, core.Type, true); |
| checkType(String, core.Type, true); |
| checkType(dynamic, core.Type, true); |
| checkType(Object, core.Type, true); |
| checkType(List, core.Type, true); |
| checkType(Map, core.Type, true); |
| checkType(Map$(int, String), core.Type, true); |
| checkType(Func2, core.Type, true); |
| checkType(fnTypeFuzzy(dynamic, [dynamic]), core.Type, true); |
| checkType(core.Type, core.Type, true); |
| |
| checkType(3, core.Type, false); |
| checkType("hello", core.Type, false); |
| }) |
| |
| test('Functions', () => { |
| // - return type: Dart is bivariant. We're covariant. |
| // - param types: Dart is bivariant. We're contravariant. |
| checkType(bar1, Foo, false); |
| checkType(cls1, Foo, false); |
| checkType(bar1, fnTypeFuzzy(B, [B, String]), false); |
| checkType(cls1, fnTypeFuzzy(B, [B, String]), false); |
| checkType(bar2, Foo, false); |
| checkType(cls2, Foo, false); |
| checkType(bar2, fnTypeFuzzy(B, [B, String]), false); |
| checkType(cls2, fnTypeFuzzy(B, [B, String]), false); |
| checkType(bar3, Foo); |
| checkType(cls3, Foo); |
| checkType(bar3, fnTypeFuzzy(B, [B, String])); |
| checkType(cls3, fnTypeFuzzy(B, [B, String])); |
| checkType(bar4, Foo, true); |
| checkType(cls4, Foo, true); |
| checkType(bar4, fnTypeFuzzy(B, [B, String]), true); |
| checkType(cls4, fnTypeFuzzy(B, [B, String]), true); |
| checkType(bar5, Foo); |
| checkType(cls5, Foo); |
| checkType(bar5, fnTypeFuzzy(B, [B, String])); |
| checkType(cls5, fnTypeFuzzy(B, [B, String])); |
| checkType(bar6, Foo, false); |
| checkType(cls6, Foo, false); |
| checkType(bar6, fnTypeFuzzy(B, [B, String]), false); |
| checkType(cls6, fnTypeFuzzy(B, [B, String]), false); |
| checkType(bar7, Foo); |
| checkType(cls7, Foo); |
| checkType(bar7, fnTypeFuzzy(B, [B, String])); |
| checkType(cls7, fnTypeFuzzy(B, [B, String])); |
| checkType(bar7, getReifiedType(bar6)); |
| checkType(cls7, getReifiedType(bar6)); |
| checkType(bar8, Foo); |
| checkType(cls8, Foo); |
| checkType(bar8, fnTypeFuzzy(B, [B, String])); |
| checkType(cls8, fnTypeFuzzy(B, [B, String])); |
| checkType(bar8, getReifiedType(bar6), false); |
| checkType(cls8, getReifiedType(bar6), false); |
| checkType(bar7, getReifiedType(bar8), false); |
| checkType(cls7, getReifiedType(bar8), false); |
| checkType(bar8, getReifiedType(bar7), false); |
| checkType(cls8, getReifiedType(bar7), false); |
| |
| // Parameterized typedefs |
| checkType(bar1, FuncG$(B, String), false); |
| checkType(cls1, FuncG$(B, String), false); |
| checkType(bar3, FuncG$(B, String)); |
| checkType(cls3, FuncG$(B, String)); |
| }); |
| |
| test('dcall', () => { |
| function dd2d(x, y) {return x}; |
| dart.fn(dd2d); |
| function ii2i(x, y) {return x}; |
| dart.fn(ii2i, dart.fnType(core.int, [core.int, core.int])); |
| function ii_2i(x, y) {return x}; |
| dart.fn(ii_2i, dart.fnType(core.int, [core.int], [core.int])); |
| function i_i2i(x, opts) {return x}; |
| dart.fn(i_i2i, |
| dart.fnType(core.int, [core.int], {extra: core.int})); |
| |
| assert.equal(dart.dcall(dd2d, 0, 1), 0); |
| assert.equal(dart.dcall(dd2d, "hello", "world"), "hello"); |
| assert.throws(() => dart.dcall(dd2d, 0)); |
| assert.throws(() => dart.dcall(dd2d, 0, 1, 2)); |
| assert.throws(() => dart.dcall(dd2d, 0, 1, {extra : 3})); |
| // This should throw but currently doesn't. |
| // assert.throws(() => dart.dcall(dd2d, 0, {extra:3})); |
| |
| assert.equal(dart.dcall(ii2i, 0, 1), 0); |
| assert.throws(() => dart.dcall(ii2i, "hello", "world")); |
| assert.throws(() => dart.dcall(ii2i, 0)); |
| assert.throws(() => dart.dcall(ii2i, 0, 1, 2)); |
| |
| assert.equal(dart.dcall(ii_2i, 0, 1), 0); |
| assert.throws(() => dart.dcall(ii_2i, "hello", "world")); |
| assert.equal(dart.dcall(ii_2i, 0), 0); |
| assert.throws(() => dart.dcall(ii_2i, 0, 1, 2)); |
| |
| assert.throws(() => dart.dcall(i_i2i, 0, 1)); |
| assert.throws(() => dart.dcall(i_i2i, "hello", "world")); |
| assert.equal(dart.dcall(i_i2i, 0), 0); |
| assert.throws(() => dart.dcall(i_i2i, 0, 1, 2)); |
| assert.equal(dart.dcall(i_i2i, 0, {extra: 3}), 0); |
| }); |
| |
| test('dsend', () => { |
| class Tester extends core.Object { |
| m(x, y) {return x;} |
| call(x) {return x;} |
| static s(x, y) { return x;} |
| } |
| (Tester.new = function() { |
| this.f = dart.fn(x => x, |
| dart.fnType(core.int, [core.int])); |
| this.me = this; |
| }).prototype = Tester.prototype; |
| dart.setSignature(Tester, { |
| methods: () => ({ |
| m: dart.fnType(core.int, [core.int, core.int]), |
| call: dart.fnType(core.int, [core.int]) |
| }), |
| statics: () => ({ |
| s: dart.fnType(core.String, [core.String]) |
| }), |
| names: ['s'] |
| }) |
| let o = new Tester.new(); |
| |
| // Method send |
| assert.equal(dart.dsend(o, 'm', 3, 4), 3); |
| assert.equal(dart.dsend(o, 'm', null, 4), null); |
| assert.throws(() => dart.dsend(o, 'm', 3)); |
| assert.throws(() => dart.dsend(o, 'm', "hello", "world")); |
| assert.throws(() => dart.dsend(o, 'q', 3)); |
| |
| // Method send through a field |
| assert.equal(dart.dsend(o, 'f', 3), 3); |
| assert.equal(dart.dsend(o, 'f', null), null); |
| assert.throws(() => dart.dsend(o, 'f', "hello")); |
| assert.throws(() => dart.dsend(o, 'f', 3, 4)); |
| |
| // Static method call |
| assert.equal(dart.dcall(Tester.s, "hello"), "hello"); |
| assert.equal(dart.dcall(Tester.s, null), null); |
| assert.throws(() => dart.dcall(Tester.s, "hello", "world")); |
| assert.throws(() => dart.dcall(Tester.s, 0, 1)); |
| |
| // Calling an object with a call method |
| assert.equal(dart.dcall(o, 3), 3); |
| assert.equal(dart.dcall(o, null), null); |
| assert.throws(() => dart.dcall(o, "hello")); |
| assert.throws(() => dart.dcall(o, 3, 4)); |
| |
| // Calling through a field containing an object with a call method |
| assert.equal(dart.dsend(o, 'me', 3), 3); |
| assert.equal(dart.dsend(o, 'me', null), null); |
| assert.throws(() => dart.dsend(o, 'me', "hello")); |
| assert.throws(() => dart.dsend(o, 'me', 3, 4)); |
| }); |
| |
| test('Types on top level functions', () => { |
| // Test some generated code |
| // Test the lazy path |
| checkType(core.identityHashCode, |
| dart.fnTypeFuzzy(core.int, [core.Object])); |
| // Test the normal path |
| checkType(core.identical, |
| dart.fnTypeFuzzy(core.bool, |
| [core.Object, core.Object])); |
| |
| // Hand crafted tests |
| // All dynamic |
| function dd2d(x, y) {return x}; |
| dart.fn(dd2d); |
| checkType(dd2d, dart.fnTypeFuzzy(dart.dynamic, |
| [dart.dynamic, dart.dynamic])); |
| |
| // Set the type eagerly |
| function ii2i(x, y) {return x}; |
| dart.fn(ii2i, dart.fnType(core.int, [core.int, core.int])); |
| checkType(ii2i, dart.fnTypeFuzzy(core.int, |
| [core.int, core.int])); |
| |
| // Set the type lazily |
| function ss2s(x, y) {return x}; |
| var coreString; |
| dart.lazyFn(ss2s, |
| () => dart.fnType(coreString, |
| [coreString, coreString])); |
| coreString = core.String; |
| checkType(ss2s, dart.fnTypeFuzzy(core.String, |
| [core.String, core.String])); |
| |
| // Optional types |
| function ii_2i(x, y) {return x}; |
| dart.fn(ii_2i, dart.fnType(core.int, [core.int], [core.int])); |
| checkType(ii_2i, dart.fnTypeFuzzy(core.int, [core.int], |
| [core.int])); |
| checkType(ii_2i, dart.fnTypeFuzzy(core.int, [core.int, |
| core.int])); |
| checkType(ii_2i, dart.fnTypeFuzzy(core.int, [], [core.int, |
| core.int]), |
| false); |
| checkType(ii_2i, dart.fnTypeFuzzy(core.int, [core.int], |
| {extra: core.int}), false); |
| |
| // Named types |
| function i_i2i(x, opts) {return x}; |
| dart.fn(i_i2i, dart.fnType(core.int, [core.int], |
| {extra: core.int})); |
| checkType(i_i2i, dart.fnTypeFuzzy(core.int, [core.int], |
| {extra: core.int})); |
| checkType(i_i2i, dart.fnTypeFuzzy(core.int, |
| [core.int, core.int]), false); |
| checkType(i_i2i, dart.fnTypeFuzzy(core.int, [core.int], {})); |
| checkType(i_i2i, |
| dart.fnTypeFuzzy(core.int, [], {extra: core.int, |
| also: core.int}), false); |
| checkType(i_i2i, |
| dart.fnTypeFuzzy(core.int, [core.int], [core.int]), false); |
| }); |
| |
| test('Method tearoffs', () => { |
| let c = collection; |
| // Tear off of an inherited method |
| let map = Map$(core.int, core.String).new(); |
| checkType(dart.bind(map, 'toString'), |
| dart.fnTypeFuzzy(String, [])); |
| checkType(dart.bind(map, 'toString'), |
| dart.fnTypeFuzzy(int, []), false, true); |
| |
| // Tear off of a method directly on the object |
| let smap = new (c.SplayTreeMap$(core.int, core.String).new)(); |
| checkType(dart.bind(smap, 'forEach'), |
| dart.fnTypeFuzzy(dart.void, |
| [dart.fnTypeFuzzy(dart.void, [core.int, core.String])])); |
| checkType(dart.bind(smap, 'forEach'), |
| dart.fnTypeFuzzy(dart.void, |
| [dart.fnTypeFuzzy(dart.void, |
| [core.String, core.String])]), false, true); |
| |
| // Tear off of a mixed in method |
| let mapB = new (c.MapBase$(core.int, core.int).new)(); |
| checkType(dart.bind(mapB, 'forEach'), |
| dart.fnTypeFuzzy(dart.void, [ |
| dart.fnTypeFuzzy(dart.void, [core.int, core.int])])); |
| checkType(dart.bind(mapB, 'forEach'), |
| dart.fnTypeFuzzy(dart.void, [ |
| dart.fnTypeFuzzy(dart.void, [core.int, core.String])]), |
| false, true); |
| |
| // Tear off of a method with a symbol name |
| let listB = new (c.ListBase$(core.int).new)(); |
| // List.add is reified as taking Object |
| checkType(dart.bind(listB, dartx.add), |
| dart.fnTypeFuzzy(dart.void, [core.int])); |
| checkType(dart.bind(listB, dartx.add), |
| dart.fnTypeFuzzy(dart.void, [core.String]), true); |
| checkType(dart.bind(listB, dartx.removeAt), |
| dart.fnTypeFuzzy(dart.void, [core.String]), false); |
| |
| // Tear off of a static method |
| checkType(c.ListBase.listToString, |
| dart.fnTypeFuzzy(core.String, [core.List])); |
| checkType(c.ListBase.listToString, |
| dart.fnTypeFuzzy(core.String, [core.String]), false); |
| |
| // Tear-off of extension methods on primitives |
| checkType(dart.bind(3.0, dartx.floor), |
| dart.fnTypeFuzzy(core.int, [])); |
| checkType(dart.bind(3.0, dartx.floor), |
| dart.fnTypeFuzzy(core.String, []), false); |
| checkType(dart.bind("", dartx.endsWith), |
| dart.fnTypeFuzzy(core.bool, [core.String])); |
| checkType(dart.bind("", dartx.endsWith), |
| dart.fnTypeFuzzy(core.bool, [core.int]), false); |
| |
| // Tear off a mixin method |
| class Base { |
| m(x) {return x;} |
| }; |
| dart.setSignature(Base, { |
| methods: () => ({ |
| m: dart.fnType(core.int, [core.int]), |
| }) |
| }); |
| |
| class M1 { |
| m(x) {return x;} |
| }; |
| dart.setSignature(M1, { |
| methods: () => ({ |
| m: dart.fnType(core.num, [core.int]), |
| }) |
| }); |
| |
| class M2 { |
| m(x) {return x;} |
| }; |
| dart.setSignature(M2, { |
| methods: () => ({ |
| m: dart.fnType(core.Object, [core.int]), |
| }) |
| }); |
| |
| class O extends dart.mixin(Base, M1, M2) {} |
| (O.new = function() {}).prototype = O.prototype; |
| dart.setSignature(O, {}); |
| var obj = new O.new(); |
| var m = dart.bind(obj, 'm'); |
| checkType(m, dart.fnTypeFuzzy(core.Object, [core.int])); |
| checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false); |
| |
| // Test inherited signatures |
| class P extends O { |
| m(x) {return x;}; |
| }; |
| (P.new = function() {}).prototype = P.prototype; |
| dart.setSignature(P, {}); |
| var obj = new P.new(); |
| var m = dart.bind(obj, 'm'); |
| checkType(m, dart.fnTypeFuzzy(core.Object, [core.int])); |
| checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false); |
| }); |
| |
| test('Object members', () => { |
| let nullHash = dart.hashCode(null); |
| assert.equal(nullHash, 0); |
| let nullString = dart.toString(null); |
| assert.equal(nullString, 'null'); |
| |
| let map = Map.new(); |
| let mapHash = dart.hashCode(map); |
| checkType(mapHash, core.int); |
| assert.equal(mapHash, map.hashCode); |
| |
| let mapString = dart.toString(map); |
| assert.equal(mapString, map.toString()); |
| checkType(mapString, core.String); |
| |
| let str = "A string"; |
| let strHash = dart.hashCode(str); |
| checkType(strHash, core.int); |
| |
| let strString = dart.toString(str); |
| checkType(strString, core.String); |
| assert.equal(str, strString); |
| |
| let n = 42; |
| let intHash = dart.hashCode(n); |
| checkType(intHash, core.int); |
| |
| let intString = dart.toString(n); |
| assert.equal(intString, '42'); |
| }); |
| }); |
| |
| suite('subtyping', function() { |
| 'use strict'; |
| |
| let fnTypeFuzzy = dart.fnTypeFuzzy; |
| let fnType = dart.fnType; |
| let typedef = dart.typedef; |
| let isSubtype = dart.isSubtype; |
| let int = core.int; |
| let num = core.num; |
| let dyn = dart.dynamic; |
| |
| function always(t1, t2) { |
| assert.equal(isSubtype(t1, t2), true, |
| dart.toString(t1) + |
| " should always be a subtype of " + |
| dart.toString(t2)); |
| } |
| function never(t1, t2) { |
| assert.equal(isSubtype(t1, t2), false, |
| dart.toString(t1) + |
| " should never be a subtype of " + |
| dart.toString(t2)); |
| } |
| function maybe(t1, t2) { |
| assert.equal(isSubtype(t1, t2), null, |
| dart.toString(t1) + |
| " should maybe be a subtype of " + |
| dart.toString(t2)); |
| } |
| |
| function always2(t1, t2) { |
| always(t1, t2); |
| always(fnTypeFuzzy(t1, [t2]), fnTypeFuzzy(t2, [t1])); |
| } |
| function never2(t1, t2) { |
| never(t1, t2); |
| maybe(fnTypeFuzzy(t1, [t2]), fnTypeFuzzy(t2, [t1])); |
| } |
| function maybe2(t1, t2) { |
| maybe(t1, t2); |
| maybe(fnTypeFuzzy(t1, [t2]), fnTypeFuzzy(t2, [t1])); |
| } |
| |
| function run_test(func1, func2, func2opt, func1extra, func2extra) { |
| always2(func2(int, int), func2(int, int)); |
| always2(func2(int, num), func2(int, int)); |
| always2(func2(int, int), func2(num, int)); |
| |
| always2(func2opt(int, int), func2opt(int, int)); |
| always2(func2opt(int, num), func2opt(int, int)); |
| always2(func2opt(int, int), func2opt(num, int)); |
| |
| always2(func2opt(int, int), func2(int, int)); |
| always2(func2opt(int, num), func2(int, int)); |
| always2(func2opt(int, int), func2(num, int)); |
| |
| always2(func2opt(int, int), func1(int)); |
| always2(func2opt(int, num), func1(int)); |
| always2(func2opt(int, int), func1(num)); |
| |
| always2(func2extra(int, int), func2(int, int)); |
| always2(func2extra(int, num), func2(int, int)); |
| always2(func2extra(int, int), func2(num, int)); |
| |
| maybe2(func2(int, int), func2(int, num)); |
| maybe2(func2(num, int), func2(int, int)); |
| |
| maybe2(func2opt(num, num), func1(int)); |
| |
| maybe2(func2opt(int, int), func2opt(int, num)); |
| maybe2(func2opt(num, int), func2opt(int, int)); |
| |
| maybe2(func2opt(int, int), func2(int, num)); |
| maybe2(func2opt(num, int), func2(int, int)); |
| |
| maybe2(func2extra(int, int), func2(int, num)); |
| maybe2(func2extra(num, int), func2(int, int)); |
| |
| never2(func1(int), func2(int, num)); |
| never2(func1(num), func2(int, int)); |
| never2(func1(num), func2(num, num)); |
| |
| never2(func2(int, int), func1(int)); |
| never2(func2(num, int), func1(int)); |
| never2(func2(num, num), func1(num)); |
| |
| never2(func1(int), func2opt(int, num)); |
| never2(func1(num), func2opt(int, int)); |
| never2(func1(num), func2opt(num, num)); |
| |
| never2(func2(int, int), func2opt(int, num)); |
| never2(func2(num, int), func2opt(int, int)); |
| never2(func2(num, num), func2opt(num, num)); |
| |
| never2(func1extra(int), func2(int, num)); |
| never2(func1extra(num), func2(int, int)); |
| never2(func1extra(num), func2(num, num)); |
| |
| never2(func1extra(int), func2opt(int, num)); |
| never2(func1extra(num), func2opt(int, int)); |
| never2(func1extra(num), func2opt(num, num)); |
| |
| never2(func1(int), func1extra(int)); |
| never2(func1(num), func1extra(int)); |
| never2(func1(num), func1extra(num)); |
| |
| never2(func2(int, int), func1extra(int)); |
| never2(func2(num, int), func1extra(int)); |
| never2(func2(num, num), func1extra(num)); |
| |
| never2(func2(int, int), func2extra(int, int)); |
| never2(func2(num, int), func2extra(int, int)); |
| never2(func2(num, num), func2extra(num, num)); |
| }; |
| |
| test('basic function types', () => { |
| function func1(S) { |
| return fnTypeFuzzy(S, []); |
| } |
| |
| function func2(S, T) { |
| return fnTypeFuzzy(S, [T]); |
| } |
| |
| function func2opt(S, T) { |
| return fnTypeFuzzy(S, [], [T]); |
| } |
| |
| function func1extra(S) { |
| return fnTypeFuzzy(S, [], {extra: int}); |
| } |
| |
| function func2extra(S, T) { |
| return fnTypeFuzzy(S, [T], {extra: int}); |
| } |
| |
| run_test(func1, func2, func2opt, func1extra, func2extra); |
| }); |
| |
| test('top and bottom types', () => { |
| let FutureOr = async.FutureOr$; |
| let tops = [ |
| dart.dynamic, |
| core.Object, |
| dart.void, |
| FutureOr(dart.dynamic), |
| FutureOr(core.Object), |
| FutureOr(dart.void), |
| FutureOr(FutureOr(core.Object)), |
| // ... skip the (infinite) rest of the top types :D |
| ]; |
| let bottoms = [dart.bottom, core.Null]; |
| |
| for (let top of tops) { |
| for (let bottom of bottoms) { |
| always(bottom, top); |
| always( |
| fnType(bottom, [top]), |
| fnType(top, [bottom])); |
| } |
| } |
| |
| for (let equalTypes of [tops, bottoms]) { |
| for (let t1 of equalTypes) { |
| for (let t2 of equalTypes) { |
| always(t1, t2); |
| always(t2, t1); |
| |
| let t11 = fnType(t1, [t1]); |
| let t22 = fnType(t2, [t2]); |
| always(t11, t22); |
| always(t22, t11); |
| } |
| } |
| } |
| }); |
| |
| test('basic typedefs', () => { |
| function func1(S) { |
| return dart.typedef('Func1', () => fnTypeFuzzy(S, [])) |
| } |
| |
| function func2(S, T) { |
| return dart.typedef('Func2', () => fnTypeFuzzy(S, [T])) |
| } |
| |
| function func2opt(S, T) { |
| return dart.typedef('Func2', () => fnTypeFuzzy(S, [], [T])) |
| } |
| |
| function func1extra(S) { |
| return dart.typedef('Func1', () => fnTypeFuzzy(S, [], {extra: int})) |
| } |
| |
| function func2extra(S, T) { |
| return dart.typedef('Func2', () => fnTypeFuzzy(S, [T], {extra: int})) |
| } |
| |
| run_test(func1, func2, func2opt, func1extra, func2extra); |
| }); |
| |
| test('basic generic typedefs', () => { |
| let func1 = dart.generic( |
| (S) => dart.typedef('Func1', () => fnTypeFuzzy(S, []))); |
| |
| let func2 = dart.generic( |
| (S, T) => dart.typedef('Func2', () => fnTypeFuzzy(S, [T]))); |
| |
| let func2opt = dart.generic( |
| (S, T) => dart.typedef('Func2', () => fnTypeFuzzy(S, [], [T]))); |
| |
| let func1extra = dart.generic( |
| (S) => dart.typedef('Func1', () => fnTypeFuzzy(S, [], {extra: int}))); |
| |
| let func2extra = dart.generic( |
| (S, T) => dart.typedef('Func2', |
| () => fnTypeFuzzy(S, [T], {extra: int}))); |
| |
| run_test(func1, func2, func2opt, func1extra, func2extra); |
| }); |
| |
| test('fuzzy function types', () => { |
| always(fnTypeFuzzy(int, [int]), fnTypeFuzzy(dyn, [dyn])); |
| always(fnTypeFuzzy(int, [], [int]), fnTypeFuzzy(dyn, [], [dyn])); |
| always(fnTypeFuzzy(int, [], [int]), fnTypeFuzzy(dyn, [dyn])); |
| always(fnTypeFuzzy(int, [], [int]), fnTypeFuzzy(dyn, [])); |
| always(fnTypeFuzzy(int, [int], {extra: int}), fnTypeFuzzy(dyn, [dyn])); |
| |
| always(fnTypeFuzzy(dyn, [dyn]), fnTypeFuzzy(dyn, [dyn])); |
| always(fnTypeFuzzy(dyn, [], [dyn]), fnTypeFuzzy(dyn, [], [dyn])); |
| always(fnTypeFuzzy(dyn, [], [dyn]), fnTypeFuzzy(dyn, [dyn])); |
| always(fnTypeFuzzy(dyn, [], [dyn]), fnTypeFuzzy(dyn, [])); |
| always(fnTypeFuzzy(dyn, [dyn], {extra: dyn}), fnTypeFuzzy(dyn, [dyn])); |
| }); |
| |
| test('void function types', () => { |
| always(fnTypeFuzzy(int, [int]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(int, [], [int]), fnTypeFuzzy(dart.void, [], [dyn])); |
| always(fnTypeFuzzy(int, [], [int]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(int, [], [int]), fnTypeFuzzy(dart.void, [])); |
| always(fnTypeFuzzy(int, [int], {extra: int}), fnTypeFuzzy(dart.void, [dyn])); |
| |
| always(fnTypeFuzzy(dart.void, [int]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(dart.void, [], [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(dart.void, [])); |
| always(fnTypeFuzzy(dart.void, [int], {extra: int}), fnTypeFuzzy(dart.void, [dyn])); |
| |
| always(fnTypeFuzzy(dyn, [dyn]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(dyn, [], [dyn]), fnTypeFuzzy(dart.void, [], [dyn])); |
| always(fnTypeFuzzy(dyn, [], [dyn]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(dyn, [], [dyn]), fnTypeFuzzy(dart.void, [])); |
| always(fnTypeFuzzy(dyn, [dyn], {extra: dyn}), fnTypeFuzzy(dart.void, [dyn])); |
| |
| always(fnTypeFuzzy(dart.void, [dyn]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [dyn]), fnTypeFuzzy(dart.void, [], [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [dyn]), fnTypeFuzzy(dart.void, [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [dyn]), fnTypeFuzzy(dart.void, [])); |
| always(fnTypeFuzzy(dart.void, [dyn], {extra: dyn}), fnTypeFuzzy(dart.void, [dyn])); |
| |
| always(fnTypeFuzzy(dart.void, [int]), fnTypeFuzzy(dyn, [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(dyn, [], [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(dyn, [dyn])); |
| always(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(dyn, [])); |
| always(fnTypeFuzzy(dart.void, [int], {extra: int}), fnTypeFuzzy(dyn, [dyn])); |
| |
| never(fnTypeFuzzy(dart.void, [int]), fnTypeFuzzy(int, [dyn])); |
| never(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(int, [], [dyn])); |
| never(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(int, [dyn])); |
| never(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(int, [])); |
| never(fnTypeFuzzy(dart.void, [int], {extra: int}), fnTypeFuzzy(int, [dyn])); |
| |
| never(fnTypeFuzzy(dart.void, [int]), fnTypeFuzzy(int, [int])); |
| never(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(int, [], [int])); |
| never(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(int, [int])); |
| never(fnTypeFuzzy(dart.void, [], [int]), fnTypeFuzzy(int, [])); |
| never(fnTypeFuzzy(dart.void, [int], {extra: int}), fnTypeFuzzy(int, [int])); |
| }); |
| |
| test('higher-order typedef', () => { |
| let Func$ = dart.generic((S, T) => |
| dart.typedef('Func', () => |
| fnTypeFuzzy(T, [S]))); |
| let Func2$ = dart.generic((R, S, T) => |
| dart.typedef('Func2', () => |
| fnTypeFuzzy(T, [Func$(R, S)]))); |
| |
| maybe(fnTypeFuzzy(int, [fnTypeFuzzy(int, [num])]), |
| fnTypeFuzzy(num, [fnTypeFuzzy(int, [int])])); |
| maybe(fnTypeFuzzy(int, [Func$(num, int)]), |
| fnTypeFuzzy(num, [Func$(int, int)])); |
| maybe(Func2$(num, int, int), Func2$(int, int, num)); |
| }); |
| |
| test('mixed types', () => { |
| let AA$ = dart.generic((T) => { |
| class AA extends core.Object {} |
| (AA.new = function() {}).prototype = AA.prototype; |
| return AA; |
| }); |
| |
| always(int, dyn); |
| maybe(dyn, int); |
| |
| never(fnTypeFuzzy(int, [int]), int); |
| |
| never(int, fnTypeFuzzy(int, [int])); |
| |
| always(AA$(int), AA$(dyn)); |
| maybe(AA$(dyn), AA$(int)); |
| never(AA$(core.Object), AA$(int)); |
| |
| always(AA$(fnTypeFuzzy(int, [int])), AA$(dyn)); |
| maybe(AA$(dyn), AA$(fnTypeFuzzy(int, [int]))); |
| never(AA$(core.Object), AA$(fnTypeFuzzy(int, [int]))); |
| |
| always(AA$(fnTypeFuzzy(int, [int])), AA$(fnTypeFuzzy(dyn, [dyn]))); |
| maybe(AA$(fnTypeFuzzy(dyn, [dyn])), AA$(fnTypeFuzzy(int, [int]))); |
| maybe(AA$(fnTypeFuzzy(core.Object, [core.Object])), |
| AA$(fnTypeFuzzy(int, [int]))); |
| }); |
| }); |
| |
| suite('canonicalization', function() { |
| 'use strict'; |
| let fnTypeFuzzy = dart.fnTypeFuzzy; |
| let fnType = dart.fnType; |
| let typedef = dart.typedef; |
| let generic = dart.generic; |
| |
| let Object = core.Object; |
| let String = core.String; |
| let int = core.int; |
| let dynamic = dart.dynamic; |
| let bottom = dart.bottom; |
| let Map = core.Map; |
| let Map$ = core.Map$; |
| |
| class A {} |
| |
| let AA$ = generic((T, U) => { |
| class AA extends core.Object {} |
| (AA.new = function() {}).prototype = AA.prototype; |
| return AA; |
| }); |
| let AA = AA$(); |
| |
| let Func2 = typedef('Func2', () => fnTypeFuzzy(dynamic, [dynamic, dynamic])); |
| |
| let FuncG$ = generic((T, U) => typedef('FuncG', () => fnTypeFuzzy(T, [T, U]))) |
| let FuncG = FuncG$(); |
| |
| test('base types', () => { |
| assert.equal(Object, Object); |
| assert.equal(String, String); |
| assert.equal(dynamic, dynamic); |
| }); |
| |
| test('class types', () => { |
| assert.equal(A, A); |
| }); |
| |
| test('generic class types', () => { |
| assert.equal(AA, AA); |
| assert.equal(AA, AA$(dynamic, dynamic)); |
| assert.equal(AA$(dynamic, dynamic), AA$(dynamic, dynamic)); |
| assert.equal(AA$(AA, Object), AA$(AA, Object)); |
| assert.equal(Map, Map); |
| assert.equal(Map$(dynamic, dynamic), Map); |
| assert.equal(Map$(int, Map$(int, int)), Map$(int, Map$(int, int))); |
| }); |
| |
| test('typedefs', () => { |
| assert.equal(Func2, Func2); |
| assert.equal(FuncG, FuncG$(dynamic, dynamic)); |
| assert.equal(FuncG$(dynamic, dynamic), FuncG$(dynamic, dynamic)); |
| assert.equal(FuncG$(String, Func2), FuncG$(String, Func2)); |
| }); |
| |
| test('function types', () => { |
| assert.equal(fnTypeFuzzy(dynamic, [dynamic, dynamic]), |
| fnTypeFuzzy(dynamic, [dynamic, dynamic])) |
| |
| assert.notEqual(fnType(dynamic, [dynamic, dynamic]), |
| fnTypeFuzzy(dynamic, [dynamic, dynamic])) |
| |
| assert.equal(fnTypeFuzzy(dynamic, [dynamic, dynamic]), |
| fnTypeFuzzy(dynamic, [bottom, bottom])) |
| |
| assert.equal(fnTypeFuzzy(dynamic, [], [dynamic, dynamic]), |
| fnTypeFuzzy(dynamic, [], [dynamic, dynamic])) |
| |
| assert.notEqual(fnType(dynamic, [], [dynamic, dynamic]), |
| fnTypeFuzzy(dynamic, [], [dynamic, dynamic])) |
| |
| assert.equal(fnTypeFuzzy(dynamic, [], [dynamic, dynamic]), |
| fnTypeFuzzy(dynamic, [], [bottom, bottom])) |
| |
| assert.equal(fnTypeFuzzy(dynamic, [], {extra: dynamic}), |
| fnTypeFuzzy(dynamic, [], {extra: dynamic})) |
| |
| assert.notEqual(fnType(dynamic, [], {extra: dynamic}), |
| fnTypeFuzzy(dynamic, [], {extra: dynamic})) |
| |
| assert.equal(fnTypeFuzzy(dynamic, [], {extra: dynamic}), |
| fnTypeFuzzy(dynamic, [], {extra: bottom})) |
| |
| assert.equal(fnTypeFuzzy(int, [int, int]), |
| fnTypeFuzzy(int, [int, int])) |
| |
| assert.equal(fnTypeFuzzy(int, [], [int, int]), |
| fnTypeFuzzy(int, [], [int, int])) |
| |
| assert.equal(fnTypeFuzzy(int, [int, int], {extra: int}), |
| fnTypeFuzzy(int, [int, int], {extra: int})) |
| |
| assert.equal(fnTypeFuzzy(int, [int, int, int, int, int]), |
| fnTypeFuzzy(int, [int, int, int, int, int])) |
| |
| assert.notEqual(fnTypeFuzzy(int, [int, int, int, int, int]), |
| fnTypeFuzzy(int, [int, int, int], [int, int])) |
| |
| assert.notEqual(fnTypeFuzzy(String, [int, int, int, int, int]), |
| fnTypeFuzzy(int, [int, int, int, int, int])) |
| |
| assert.notEqual(fnTypeFuzzy(String, []), |
| fnTypeFuzzy(int, [])) |
| }); |
| }); |
| |
| suite('primitives', function() { |
| 'use strict'; |
| |
| test('fixed length list', () => { |
| let list = core.List.new(10); |
| list[0] = 42; |
| assert.throws(() => list.add(42)); |
| }); |
| |
| test('toString on ES Symbol', () => { |
| let sym = Symbol('_foobar'); |
| assert.equal(dart.toString(sym), 'Symbol(_foobar)'); |
| }); |
| }); |
| }); |
