| // Copyright (c) 2011, 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. |
| |
| /// @assertion A function type (T1,...Tk,[Tk+1,...,Tn+m]) -> T is a subtype of |
| /// the function type (S1,...,Sk+j,[Sk+j+1,...,Sn]) -> S, if all of the following |
| /// conditions are met: |
| /// 1. Either |
| /// • S is void, or |
| /// • T <=> S. |
| /// 2. ∀i ∈ 1..n, Ti ⇐⇒ Si. |
| /// @description Checks that this statement is true for function types with |
| /// several formal parameters (class, generic, function, Dynamic). |
| /// @author iefremov |
| |
| import "../../../Utils/expect.dart"; |
| |
| class A {} |
| class A1 {} |
| class A2 {} |
| class B implements A, A1, A2 {} |
| class C implements B {} |
| class D implements C {} |
| |
| class G<T, S, U, W> {} |
| |
| typedef classesFunc(A a, B b, C c, D d); |
| typedef genericsFunc(Map<num, int> m, List<List<B>> l, G<A, B, C, D> g); |
| typedef dynamicFunc(var x, var y, var z, var v); |
| typedef funcFunc(classesFunc f1, genericsFunc f2, dynamicFunc f3); |
| typedef mixFunc(var x, B b, G<A, B, C, D> g, funcFunc); |
| |
| typedef okWithClassesFunc_1(A a, A1 b, A1 c, A1 d); |
| typedef okWithClassesFunc_2(D a, D b, D c, D d); |
| |
| typedef okWithGenericsFunc_1(Map<num, num> m, List<List<A1>> l, G<A, A1, A1, A1> g); |
| typedef okWithGenericsFunc_2(Map<int, int> m, List<List<D>> l, G<D, D, D, D> g); |
| |
| typedef okWithDynamicFunc_1(A x, G g, mixFunc f, var z); |
| typedef okWithDynamicFunc_2(int x, bool g, List<Map> f, classesFunc z); |
| |
| f1(D d, B b, C c, A a) {} |
| f2(A d, A b, A c, A a) {} |
| f3(D d, A1 b, A1 c, A1 a) {} |
| f4(D d, A2 b, A2 c, A2 a) {} |
| f5(D d, D b, D c, D a) {} |
| f6(var d, var b, var c, var a) {} |
| f7(Object d, Object b, Object c, Object a) {} |
| |
| f11(Map<num, num> m, List<List<A1>> l, G<A, A1, A1, A1> g) {} |
| f12(Map<int, int> m, List<List<D>> l, G<D, D, D, D> g) {} |
| f13(var m, var l, var g) {} |
| f14(Object m, Object l, Object g) {} |
| |
| f21(A x, G g, mixFunc d, var z) {} |
| f22(int x, bool g, List<Map> d, classesFunc z) {} |
| |
| f31(okWithClassesFunc_1 a, okWithGenericsFunc_1 b, okWithDynamicFunc_1 c) {} |
| f32(okWithClassesFunc_2 a, okWithGenericsFunc_2 b, okWithDynamicFunc_2 c) {} |
| |
| main() { |
| Expect.isFalse(f1 is classesFunc); |
| Expect.isTrue(f2 is classesFunc); |
| Expect.isFalse(f3 is classesFunc); |
| Expect.isFalse(f4 is classesFunc); |
| Expect.isFalse(f5 is classesFunc); |
| Expect.isTrue(f6 is classesFunc); |
| Expect.isTrue(f7 is classesFunc); |
| Expect.runtimeIsNotType<classesFunc>(f1); |
| Expect.runtimeIsType<classesFunc>(f2); |
| Expect.runtimeIsNotType<classesFunc>(f3); |
| Expect.runtimeIsNotType<classesFunc>(f4); |
| Expect.runtimeIsNotType<classesFunc>(f5); |
| Expect.runtimeIsType<classesFunc>(f6); |
| Expect.runtimeIsType<classesFunc>(f7); |
| |
| Expect.isTrue(f11 is genericsFunc); |
| Expect.isFalse(f12 is genericsFunc); |
| Expect.isTrue(f13 is genericsFunc); |
| Expect.isTrue(f14 is genericsFunc); |
| Expect.runtimeIsType<genericsFunc>(f11); |
| Expect.runtimeIsNotType<genericsFunc>(f12); |
| Expect.runtimeIsType<genericsFunc>(f13); |
| Expect.runtimeIsType<genericsFunc>(f14); |
| |
| Expect.isFalse(f21 is dynamicFunc); |
| Expect.isFalse(f22 is dynamicFunc); |
| Expect.runtimeIsNotType<dynamicFunc>(f21); |
| Expect.runtimeIsNotType<dynamicFunc>(f22); |
| |
| Expect.isFalse(f31 is funcFunc); |
| Expect.isTrue(f32 is funcFunc); |
| Expect.runtimeIsNotType<funcFunc>(f31); |
| Expect.runtimeIsType<funcFunc>(f32); |
| } |