blob: 7fb556ca88025639c3fc6a20e68b3baac9fe76b0 [file] [log] [blame]
// Copyright (c) 2016, 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 kernel.type_substitute_bounds_test;
import 'package:kernel/kernel.dart';
import 'package:kernel/type_algebra.dart';
import 'package:test/test.dart';
import 'type_parser.dart';
final List<TestCase> testCases = <TestCase>[
testCase('T', {'T': bound('_', 'String')}, 'String'),
testCase('List<T>', {'T': bound('_', 'String')}, 'List<String>'),
testCase('List<List<T>>', {'T': bound('_', 'String')}, 'List<List<String>>'),
testCase('(T) => T', {'T': bound('_', 'String')}, '(_) => String'),
testCase('<G>(G,T) => T', {'T': bound('_', 'String')}, '<G>(G,_) => String'),
testCase(
'<G>(G,x:T) => T', {'T': bound('_', 'String')}, '<G>(G,x:_) => String'),
testCase('<G:T>(G) => G', {'T': bound('_', 'String')}, '<G:_>(G) => G'),
testCase('<G:T>(G) => G', {'T': bound('int', 'num')}, '<G:int>(G) => G'),
testCase('<G>(T,G) => void', {'T': bound('_', 'String')}, '<G>(_,G) => void'),
testCase('(T) => void', {'T': bound('_', 'String')}, '(_) => void'),
testCase('(int) => T', {'T': bound('_', 'String')}, '(int) => String'),
testCase('(int) => int', {'T': bound('_', 'String')}, '(int) => int'),
testCase('((T) => int) => int', {'T': bound('_', 'String')},
'((String) => int) => int'),
testCase('<E>(<F>(T) => int) => int', {'T': bound('_', 'String')},
'<E>(<F>(String) => int) => int'),
testCase('(<F>(T) => int) => int', {'T': bound('_', 'String')},
'(<F>(String) => int) => int'),
testCase('<E>((T) => int) => int', {'T': bound('_', 'String')},
'<E>((String) => int) => int'),
testCase('(T?) =>* String', {'T': bound('int', 'int')}, '(int?) =>* String'),
];
class TestCase {
final String type;
final Map<String, TypeBound> bounds;
final String expected;
TestCase(this.type, this.bounds, this.expected);
String toString() {
var substitution = bounds.keys.map((key) {
var bound = bounds[key];
return '${bound.lower} <: $key <: ${bound.upper}';
}).join(',');
return '$type [$substitution] <: $expected';
}
}
class TypeBound {
final String lower, upper;
TypeBound(this.lower, this.upper);
}
TypeBound bound(String lower, String upper) => new TypeBound(lower, upper);
TestCase testCase(String type, Map<String, TypeBound> bounds, String expected) {
return new TestCase(type, bounds, expected);
}
main() {
for (var testCase in testCases) {
test('$testCase', () {
var environment = new LazyTypeEnvironment();
var type = environment.parse(testCase.type);
var upperBounds = <TypeParameter, DartType>{};
var lowerBounds = <TypeParameter, DartType>{};
testCase.bounds.forEach((String name, TypeBound bounds) {
var parameter = environment.getTypeParameter(name);
upperBounds[parameter] = environment.parse(bounds.upper);
lowerBounds[parameter] = environment.parse(bounds.lower);
});
var substituted =
Substitution.fromUpperAndLowerBounds(upperBounds, lowerBounds)
.substituteType(type);
var expected = environment.parse(testCase.expected);
if (substituted != expected) {
fail('Expected `$expected` but got `$substituted`');
}
});
}
}