mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 04:27:17 +00:00
8829ddc992
Change-Id: I5c388b3321a18f62b225d68c295b8d55ab2651fe Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/142994 Commit-Queue: Liam Appelbe <liama@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com>
469 lines
20 KiB
Dart
469 lines
20 KiB
Dart
// Copyright (c) 2018, 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.
|
|
|
|
// In strong mode, `FutureOr` should be a valid type in most locations.
|
|
// Requirements=nnbd-strong
|
|
|
|
import 'dart:async';
|
|
import 'package:expect/expect.dart';
|
|
|
|
// Some useful values.
|
|
dynamic nullValue = null;
|
|
dynamic intValue = 0;
|
|
dynamic doubleValue = 1.5;
|
|
dynamic numFutureInt = new Future<num>.value(intValue);
|
|
dynamic numFutureDouble = new Future<num>.value(doubleValue);
|
|
dynamic intFuture = new Future<int>.value(intValue);
|
|
dynamic doubleFuture = new Future<double>.value(doubleValue);
|
|
dynamic nullFuture = new Future<Null>.value(null);
|
|
|
|
dynamic objectValue = new Object();
|
|
dynamic objectFuture = new Future<Object>.value(objectValue);
|
|
dynamic objectFutureInt = new Future<Object>.value(intValue);
|
|
|
|
dynamic nullableNumFutureInt = new Future<num?>.value(intValue);
|
|
dynamic nullableNumFutureDouble = new Future<num?>.value(doubleValue);
|
|
dynamic nullableIntFuture = new Future<int?>.value(intValue);
|
|
dynamic nullableDoubleFuture = new Future<double?>.value(doubleValue);
|
|
dynamic nullableObjectFuture = new Future<Object?>.value(objectValue);
|
|
|
|
main() {
|
|
if (typeAssertionsEnabled) {
|
|
// Type annotation allows correct values.
|
|
FutureOr<num> variable;
|
|
variable = intValue;
|
|
variable = doubleValue;
|
|
variable = numFutureInt;
|
|
variable = numFutureDouble;
|
|
variable = intFuture;
|
|
variable = doubleFuture;
|
|
|
|
// Disallows invalid values.
|
|
// These are all valid down-casts that fail at runtime.
|
|
Expect.throws(() => variable = nullValue);
|
|
Expect.throws(() => variable = objectValue);
|
|
Expect.throws(() => variable = nullFuture);
|
|
Expect.throws(() => variable = objectFuture);
|
|
Expect.throws(() => variable = objectFutureInt);
|
|
Expect.throws(() => variable = nullableNumFutureInt);
|
|
Expect.throws(() => variable = nullableNumFutureDouble);
|
|
Expect.throws(() => variable = nullableIntFuture);
|
|
Expect.throws(() => variable = nullableDoubleFuture);
|
|
Expect.throws(() => variable = nullableObjectFuture);
|
|
|
|
// Type annotation allows correct values.
|
|
FutureOr<num?> nullableVariable;
|
|
nullableVariable = nullValue;
|
|
nullableVariable = intValue;
|
|
nullableVariable = doubleValue;
|
|
nullableVariable = numFutureInt;
|
|
nullableVariable = numFutureDouble;
|
|
nullableVariable = intFuture;
|
|
nullableVariable = doubleFuture;
|
|
nullableVariable = nullFuture;
|
|
nullableVariable = nullableNumFutureInt;
|
|
nullableVariable = nullableNumFutureDouble;
|
|
nullableVariable = nullableIntFuture;
|
|
nullableVariable = nullableDoubleFuture;
|
|
|
|
// Disallows invalid values.
|
|
// These are all valid down-casts that fail at runtime.
|
|
Expect.throws(() => nullableVariable = nullableObjectFuture);
|
|
Expect.throws(() => nullableVariable = objectValue);
|
|
Expect.throws(() => nullableVariable = objectFuture);
|
|
Expect.throws(() => nullableVariable = objectFutureInt);
|
|
|
|
void fun(FutureOr<num> parameter) {}
|
|
fun(intValue);
|
|
fun(doubleValue);
|
|
fun(numFutureInt);
|
|
fun(numFutureDouble);
|
|
fun(intFuture);
|
|
fun(doubleFuture);
|
|
|
|
// Disallows invalid values.
|
|
// These are all valid down-casts that fail at runtime.
|
|
Expect.throws(() => fun(nullValue));
|
|
Expect.throws(() => fun(objectValue));
|
|
Expect.throws(() => fun(nullFuture));
|
|
Expect.throws(() => fun(objectFuture));
|
|
Expect.throws(() => fun(objectFutureInt));
|
|
Expect.throws(() => fun(nullableNumFutureInt));
|
|
Expect.throws(() => fun(nullableNumFutureDouble));
|
|
Expect.throws(() => fun(nullableIntFuture));
|
|
Expect.throws(() => fun(nullableDoubleFuture));
|
|
Expect.throws(() => fun(nullableObjectFuture));
|
|
|
|
// Type annotation allows correct values.
|
|
void nullableFun(FutureOr<num?> parameter) {}
|
|
nullableFun(nullValue);
|
|
nullableFun(intValue);
|
|
nullableFun(doubleValue);
|
|
nullableFun(numFutureInt);
|
|
nullableFun(numFutureDouble);
|
|
nullableFun(intFuture);
|
|
nullableFun(doubleFuture);
|
|
nullableFun(nullFuture);
|
|
nullableFun(nullableNumFutureInt);
|
|
nullableFun(nullableNumFutureDouble);
|
|
nullableFun(nullableIntFuture);
|
|
nullableFun(nullableDoubleFuture);
|
|
|
|
// Disallows invalid values.
|
|
// These are all valid down-casts that fail at runtime.
|
|
Expect.throws(() => nullableFun(nullableObjectFuture));
|
|
Expect.throws(() => nullableFun(objectValue));
|
|
Expect.throws(() => nullableFun(objectFuture));
|
|
Expect.throws(() => nullableFun(objectFutureInt));
|
|
|
|
// Implicit down-cast to return type.
|
|
FutureOr<num> fun2(dynamic objectValue) => objectValue;
|
|
fun2(intValue);
|
|
fun2(doubleValue);
|
|
fun2(numFutureInt);
|
|
fun2(numFutureDouble);
|
|
fun2(intFuture);
|
|
fun2(doubleFuture);
|
|
|
|
// Disallows invalid values.
|
|
Expect.throws(() => fun2(nullValue));
|
|
Expect.throws(() => fun2(objectValue));
|
|
Expect.throws(() => fun2(nullFuture));
|
|
Expect.throws(() => fun2(objectFuture));
|
|
Expect.throws(() => fun2(objectFutureInt));
|
|
Expect.throws(() => fun2(nullableNumFutureInt));
|
|
Expect.throws(() => fun2(nullableNumFutureDouble));
|
|
Expect.throws(() => fun2(nullableIntFuture));
|
|
Expect.throws(() => fun2(nullableDoubleFuture));
|
|
Expect.throws(() => fun2(nullableObjectFuture));
|
|
|
|
// Implicit down-cast to return type.
|
|
FutureOr<num?> nullableFun2(dynamic objectValue) => objectValue;
|
|
nullableFun2(nullValue);
|
|
nullableFun2(intValue);
|
|
nullableFun2(doubleValue);
|
|
nullableFun2(numFutureInt);
|
|
nullableFun2(numFutureDouble);
|
|
nullableFun2(intFuture);
|
|
nullableFun2(doubleFuture);
|
|
nullableFun2(nullFuture);
|
|
nullableFun2(nullableNumFutureInt);
|
|
nullableFun2(nullableNumFutureDouble);
|
|
nullableFun2(nullableIntFuture);
|
|
nullableFun2(nullableDoubleFuture);
|
|
|
|
Expect.throws(() => nullableFun2(nullableObjectFuture));
|
|
Expect.throws(() => nullableFun2(objectValue));
|
|
Expect.throws(() => nullableFun2(objectFuture));
|
|
Expect.throws(() => nullableFun2(objectFutureInt));
|
|
}
|
|
|
|
{
|
|
List<Object> list = <FutureOr<num>>[];
|
|
list.add(intValue);
|
|
list.add(doubleValue);
|
|
list.add(numFutureInt);
|
|
list.add(numFutureDouble);
|
|
list.add(intFuture);
|
|
list.add(doubleFuture);
|
|
|
|
Expect.throws(() => list.add(nullValue));
|
|
Expect.throws(() => list.add(objectValue));
|
|
Expect.throws(() => list.add(nullFuture));
|
|
Expect.throws(() => list.add(objectFuture));
|
|
Expect.throws(() => list.add(objectFutureInt));
|
|
Expect.throws(() => list.add(nullableNumFutureInt));
|
|
Expect.throws(() => list.add(nullableNumFutureDouble));
|
|
Expect.throws(() => list.add(nullableIntFuture));
|
|
Expect.throws(() => list.add(nullableDoubleFuture));
|
|
Expect.throws(() => list.add(nullableObjectFuture));
|
|
|
|
List<Object?> nullableList = <FutureOr<num?>>[];
|
|
nullableList.add(nullValue);
|
|
nullableList.add(intValue);
|
|
nullableList.add(doubleValue);
|
|
nullableList.add(numFutureInt);
|
|
nullableList.add(numFutureDouble);
|
|
nullableList.add(intFuture);
|
|
nullableList.add(doubleFuture);
|
|
nullableList.add(nullFuture);
|
|
nullableList.add(nullableNumFutureInt);
|
|
nullableList.add(nullableNumFutureDouble);
|
|
nullableList.add(nullableIntFuture);
|
|
nullableList.add(nullableDoubleFuture);
|
|
|
|
Expect.throws(() => nullableList.add(nullableObjectFuture));
|
|
Expect.throws(() => nullableList.add(objectValue));
|
|
Expect.throws(() => nullableList.add(objectFuture));
|
|
Expect.throws(() => nullableList.add(objectFutureInt));
|
|
}
|
|
|
|
{
|
|
// Casts.
|
|
intValue as FutureOr<num>;
|
|
doubleValue as FutureOr<num>;
|
|
numFutureInt as FutureOr<num>;
|
|
numFutureDouble as FutureOr<num>;
|
|
intFuture as FutureOr<num>;
|
|
doubleFuture as FutureOr<num>;
|
|
|
|
// Disallows invalid values.
|
|
// These are all valid down-casts that fail at runtime.
|
|
Expect.throws(() => nullValue as FutureOr<num>);
|
|
Expect.throws(() => objectValue as FutureOr<num>);
|
|
Expect.throws(() => nullFuture as FutureOr<num>);
|
|
Expect.throws(() => objectFuture as FutureOr<num>);
|
|
Expect.throws(() => objectFutureInt as FutureOr<num>);
|
|
Expect.throws(() => nullableNumFutureInt as FutureOr<num>);
|
|
Expect.throws(() => nullableNumFutureDouble as FutureOr<num>);
|
|
Expect.throws(() => nullableIntFuture as FutureOr<num>);
|
|
Expect.throws(() => nullableDoubleFuture as FutureOr<num>);
|
|
Expect.throws(() => nullableObjectFuture as FutureOr<num>);
|
|
|
|
// Casts.
|
|
nullValue as FutureOr<num?>;
|
|
intValue as FutureOr<num?>;
|
|
doubleValue as FutureOr<num?>;
|
|
numFutureInt as FutureOr<num?>;
|
|
numFutureDouble as FutureOr<num?>;
|
|
intFuture as FutureOr<num?>;
|
|
doubleFuture as FutureOr<num?>;
|
|
nullFuture as FutureOr<num?>;
|
|
nullableNumFutureInt as FutureOr<num?>;
|
|
nullableNumFutureDouble as FutureOr<num?>;
|
|
nullableIntFuture as FutureOr<num?>;
|
|
nullableDoubleFuture as FutureOr<num?>;
|
|
|
|
// Disallows invalid values.
|
|
// These are all valid down-casts that fail at runtime.
|
|
Expect.throws(() => nullableObjectFuture as FutureOr<num?>);
|
|
Expect.throws(() => objectValue as FutureOr<num?>);
|
|
Expect.throws(() => objectFuture as FutureOr<num?>);
|
|
Expect.throws(() => objectFutureInt as FutureOr<num?>);
|
|
}
|
|
|
|
{
|
|
// On-catch.
|
|
String check(Object objectValue) {
|
|
try {
|
|
throw objectValue;
|
|
} on FutureOr<num> {
|
|
return "caught";
|
|
} on Object {
|
|
return "uncaught";
|
|
}
|
|
}
|
|
|
|
// Can't throw null, so no null or nullable FutureOr cases here.
|
|
Expect.equals("caught", check(intValue));
|
|
Expect.equals("caught", check(doubleValue));
|
|
Expect.equals("caught", check(numFutureInt));
|
|
Expect.equals("caught", check(numFutureDouble));
|
|
Expect.equals("caught", check(intFuture));
|
|
Expect.equals("caught", check(doubleFuture));
|
|
|
|
Expect.equals("uncaught", check(objectValue));
|
|
Expect.equals("uncaught", check(nullFuture));
|
|
Expect.equals("uncaught", check(objectFuture));
|
|
Expect.equals("uncaught", check(objectFutureInt));
|
|
}
|
|
|
|
{
|
|
// Type variable bound.
|
|
var valids = <C<FutureOr<num>>>[
|
|
new C<int>(),
|
|
new C<double>(),
|
|
new C<num>(),
|
|
new C<Future<int>>(),
|
|
new C<Future<double>>(),
|
|
new C<Future<num>>(),
|
|
new C<FutureOr<int>>(),
|
|
new C<FutureOr<double>>(),
|
|
new C<FutureOr<num>>(),
|
|
];
|
|
Expect.equals(9, valids.length);
|
|
|
|
// Nullable variable bound.
|
|
var nullableValids = <C<FutureOr<num?>>>[
|
|
new C<Null>(),
|
|
new C<int>(),
|
|
new C<double>(),
|
|
new C<num>(),
|
|
new C<num?>(),
|
|
new C<Future<Null>>(),
|
|
new C<Future<int>>(),
|
|
new C<Future<double>>(),
|
|
new C<Future<num>>(),
|
|
new C<Future<num?>>(),
|
|
new C<FutureOr<Null>>(),
|
|
new C<FutureOr<int>>(),
|
|
new C<FutureOr<double>>(),
|
|
new C<FutureOr<num>>(),
|
|
new C<FutureOr<num?>>(),
|
|
];
|
|
Expect.equals(15, nullableValids.length);
|
|
}
|
|
|
|
{
|
|
// Dynamic checks.
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullValue));
|
|
Expect.isTrue(new C<FutureOr<num>>().isCheck(intValue));
|
|
Expect.isTrue(new C<FutureOr<num>>().isCheck(doubleValue));
|
|
Expect.isTrue(new C<FutureOr<num>>().isCheck(numFutureInt));
|
|
Expect.isTrue(new C<FutureOr<num>>().isCheck(numFutureDouble));
|
|
Expect.isTrue(new C<FutureOr<num>>().isCheck(intFuture));
|
|
Expect.isTrue(new C<FutureOr<num>>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(objectValue));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<FutureOr<num>>().isCheck(objectFutureInt));
|
|
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullValue));
|
|
Expect.isTrue(new C<FutureOr<int>>().isCheck(intValue));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(doubleValue));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(numFutureInt));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(numFutureDouble));
|
|
Expect.isTrue(new C<FutureOr<int>>().isCheck(intFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(objectValue));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<FutureOr<int>>().isCheck(objectFutureInt));
|
|
|
|
Expect.isTrue(new C<FutureOr<Null>>().isCheck(nullValue));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(intValue));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(doubleValue));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(numFutureInt));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(numFutureDouble));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(intFuture));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(doubleFuture));
|
|
Expect.isTrue(new C<FutureOr<Null>>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(objectValue));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<FutureOr<Null>>().isCheck(objectFutureInt));
|
|
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullValue));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(intValue));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(doubleValue));
|
|
Expect.isTrue(new C<Future<num>>().isCheck(numFutureInt));
|
|
Expect.isTrue(new C<Future<num>>().isCheck(numFutureDouble));
|
|
Expect.isTrue(new C<Future<num>>().isCheck(intFuture));
|
|
Expect.isTrue(new C<Future<num>>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(objectValue));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<Future<num>>().isCheck(objectFutureInt));
|
|
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullValue));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(intValue));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(doubleValue));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(numFutureInt));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(numFutureDouble));
|
|
Expect.isTrue(new C<Future<int>>().isCheck(intFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(objectValue));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<Future<int>>().isCheck(objectFutureInt));
|
|
|
|
Expect.isFalse(new C<num>().isCheck(nullValue));
|
|
Expect.isTrue(new C<num>().isCheck(intValue));
|
|
Expect.isTrue(new C<num>().isCheck(doubleValue));
|
|
Expect.isFalse(new C<num>().isCheck(numFutureInt));
|
|
Expect.isFalse(new C<num>().isCheck(numFutureDouble));
|
|
Expect.isFalse(new C<num>().isCheck(intFuture));
|
|
Expect.isFalse(new C<num>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<num>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<num>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<num>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<num>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<num>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<num>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<num>().isCheck(objectValue));
|
|
Expect.isFalse(new C<num>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<num>().isCheck(objectFutureInt));
|
|
|
|
Expect.isFalse(new C<int>().isCheck(nullValue));
|
|
Expect.isTrue(new C<int>().isCheck(intValue));
|
|
Expect.isFalse(new C<int>().isCheck(doubleValue));
|
|
Expect.isFalse(new C<int>().isCheck(numFutureInt));
|
|
Expect.isFalse(new C<int>().isCheck(numFutureDouble));
|
|
Expect.isFalse(new C<int>().isCheck(intFuture));
|
|
Expect.isFalse(new C<int>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<int>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<int>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<int>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<int>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<int>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<int>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<int>().isCheck(objectValue));
|
|
Expect.isFalse(new C<int>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<int>().isCheck(objectFutureInt));
|
|
|
|
Expect.isTrue(new C<Null>().isCheck(nullValue));
|
|
Expect.isFalse(new C<Null>().isCheck(intValue));
|
|
Expect.isFalse(new C<Null>().isCheck(doubleValue));
|
|
Expect.isFalse(new C<Null>().isCheck(numFutureInt));
|
|
Expect.isFalse(new C<Null>().isCheck(numFutureDouble));
|
|
Expect.isFalse(new C<Null>().isCheck(intFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(doubleFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(nullFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(nullableNumFutureInt));
|
|
Expect.isFalse(new C<Null>().isCheck(nullableNumFutureDouble));
|
|
Expect.isFalse(new C<Null>().isCheck(nullableIntFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(objectValue));
|
|
Expect.isFalse(new C<Null>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<Null>().isCheck(objectFutureInt));
|
|
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(nullValue));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(intValue));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(doubleValue));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(numFutureInt));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(numFutureDouble));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(intFuture));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(doubleFuture));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(nullFuture));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(nullableNumFutureInt));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(nullableNumFutureDouble));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(nullableIntFuture));
|
|
Expect.isTrue(new C<FutureOr<num?>>().isCheck(nullableDoubleFuture));
|
|
Expect.isFalse(new C<FutureOr<num?>>().isCheck(nullableObjectFuture));
|
|
Expect.isFalse(new C<FutureOr<num?>>().isCheck(objectValue));
|
|
Expect.isFalse(new C<FutureOr<num?>>().isCheck(objectFuture));
|
|
Expect.isFalse(new C<FutureOr<num?>>().isCheck(objectFutureInt));
|
|
}
|
|
}
|
|
|
|
// FutureOr used as type parameter bound.
|
|
class C<T extends FutureOr<num?>> {
|
|
bool isCheck(dynamic objectValue) => objectValue is T;
|
|
}
|