mirror of
https://github.com/dart-lang/sdk
synced 2024-09-30 09:20:41 +00:00
b464fc9037
This reverts commitcd2c566bcf
. Reason for revert: Updating to not remove field used by Flutter engine. Original change's description: > Revert "Tweak `expect.dart` library." > > This reverts commitff5f391c0a
. > > Reason for revert: The expect library is used by Flutter engine, and some of its tests use assertStatementsEnabled. There should be a migration path that doesn't require an atomic change, like adding the replacement api before removing the old one. > > Original change's description: > > Tweak `expect.dart` library. > > > > Make API more consistent for a few methods. > > Reduce the number of language features used in tests: > > * Never iterating an iterable, always converting it > > using `.toList()` first and iterating using indices > > (fx `setEquals`). > > Also require a `List` in places where an `Iterable` > > wasn't necessary. > > * Avoid doing complicated computations that are also > > used for the error message. Do simple check first, > > then recompute to get better error messages > > (fx `allDistinct`). > > > > Renamed some rarely used members for consistency > > (`stringContainsInOrder`->`containsInOrder`, > > where other string-contains functions just start > > with `contains`, and `containsOneOf` -> `containsAny` > > to match `Iterable.any` phrasing, and also it accepts > > if containing at least one, not precisely one.) > > > > Removed a function that wasn't used anywhere. > > > > Moved `assertStatementsEnabled` to `variations.dart` as `asserts`. > > Removed `typeAssertionsEnabled` and `checkedModeEnabled`. The former used in one place, where it was replaced with `checkedImplicitDowncasts` from `variations.dart`, the latter wasn't used anywhere. > > > > Deprecates `package:expect/minitest.dart`. It was never intended > > to be used for new tests, only as a help to convert existing tests > > written against `package:unit_test`. > > All existing imports marked as `// ignore: deprecated_member_use`. > > > > Change-Id: I07e21d4c0f3ccf11b82ee34af2668fdbb22264d2 > > Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/352360 > > Reviewed-by: Slava Egorov <vegorov@google.com> > > Reviewed-by: Ömer Ağacan <omersa@google.com> > > Reviewed-by: Nate Bosch <nbosch@google.com> > > Reviewed-by: Stephen Adams <sra@google.com> > > Commit-Queue: Lasse Nielsen <lrn@google.com> > > Change-Id: I360b4347470a0bb2b63c3108e2b83ee2a771bf3f > No-Presubmit: true > No-Tree-Checks: true > No-Try: true > Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/362020 > Reviewed-by: Nate Bosch <nbosch@google.com> > Reviewed-by: Ömer Ağacan <omersa@google.com> > Reviewed-by: Stephen Adams <sra@google.com> > Reviewed-by: Leaf Petersen <leafp@google.com> > Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com> > Commit-Queue: William Hesse <whesse@google.com> CoreLibraryReviewExempt: Reland Change-Id: I53db40edc0733842a008839c3913d51c885e39ab Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/362502 Reviewed-by: Alexander Thomas <athom@google.com> Reviewed-by: Nate Bosch <nbosch@google.com> Reviewed-by: Ömer Ağacan <omersa@google.com> Reviewed-by: Slava Egorov <vegorov@google.com> Reviewed-by: William Hesse <whesse@google.com> Commit-Queue: Lasse Nielsen <lrn@google.com>
160 lines
4.5 KiB
Dart
160 lines
4.5 KiB
Dart
// Copyright (c) 2020, 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.
|
|
|
|
// Tests `is` checks and `as` casts between various JS objects. Currently, all
|
|
// checks and casts should be allowed between JS objects.
|
|
|
|
@JS()
|
|
library is_check_and_as_cast_test;
|
|
|
|
import 'package:js/js.dart';
|
|
import 'package:expect/expect.dart' show hasUnsoundNullSafety;
|
|
import 'package:expect/minitest.dart'; // ignore: deprecated_member_use_from_same_package
|
|
|
|
@JS()
|
|
external void eval(String code);
|
|
|
|
@JS()
|
|
class Foo {
|
|
external Foo(int a);
|
|
external int get a;
|
|
}
|
|
|
|
// Class with same structure as Foo but separate JS class.
|
|
@JS()
|
|
class Bar {
|
|
external Bar(int a);
|
|
external int get a;
|
|
}
|
|
|
|
@JS('Bar')
|
|
class BarCopy {
|
|
external BarCopy(int a);
|
|
external int get a;
|
|
}
|
|
|
|
// JS object literals
|
|
@JS()
|
|
@anonymous
|
|
class LiteralA {
|
|
external int get x;
|
|
}
|
|
|
|
@JS()
|
|
@anonymous
|
|
class LiteralB {
|
|
external int get y;
|
|
}
|
|
|
|
// Library is annotated with JS so we don't need the annotation here.
|
|
external LiteralA get a;
|
|
external LiteralB get b;
|
|
|
|
class DartClass {}
|
|
|
|
// Avoid static type optimization by running all tests using this.
|
|
@pragma('dart2js:noInline')
|
|
@pragma('dart2js:assumeDynamic')
|
|
confuse(x) => x;
|
|
|
|
void main() {
|
|
eval(r"""
|
|
function Foo(a) {
|
|
this.a = a;
|
|
}
|
|
function Bar(a) {
|
|
this.a = a;
|
|
}
|
|
var a = {
|
|
x: 1,
|
|
};
|
|
var b = {
|
|
y: 2,
|
|
};
|
|
""");
|
|
|
|
// JS class object can be checked and casted with itself.
|
|
var foo = Foo(42);
|
|
expect(foo is Foo, isTrue);
|
|
expect(confuse(foo) is Foo, isTrue);
|
|
expect(() => (foo as Foo), returnsNormally);
|
|
|
|
// Try it with dynamic.
|
|
dynamic d = Foo(42);
|
|
expect(d is Foo, isTrue);
|
|
expect(() => (d as Foo), returnsNormally);
|
|
|
|
// Casts are allowed between any JS class objects.
|
|
expect(foo is Bar, isTrue);
|
|
expect(confuse(foo) is Bar, isTrue);
|
|
expect(d is Bar, isTrue);
|
|
expect(() => (foo as Bar), returnsNormally);
|
|
expect(() => (d as Bar), returnsNormally);
|
|
|
|
// BarCopy is the same JS class as Bar.
|
|
var barCopy = BarCopy(42);
|
|
expect(barCopy is Bar, isTrue);
|
|
expect(confuse(barCopy) is Bar, isTrue);
|
|
expect(() => (barCopy as Bar), returnsNormally);
|
|
|
|
// JS object literal can be checked and casted with itself.
|
|
expect(a is LiteralA, isTrue);
|
|
expect(confuse(a) is LiteralA, isTrue);
|
|
expect(() => (a as LiteralA), returnsNormally);
|
|
|
|
// Like class objects, casts are allowed between any object literals.
|
|
expect(a is LiteralB, isTrue);
|
|
expect(confuse(a) is LiteralB, isTrue);
|
|
expect(() => (a as LiteralB), returnsNormally);
|
|
|
|
// Similarly, casts are allowed between any class objects and object literals.
|
|
expect(foo is LiteralB, isTrue);
|
|
expect(confuse(foo) is LiteralB, isTrue);
|
|
expect(() => (foo as LiteralB), returnsNormally);
|
|
expect(a is Foo, isTrue);
|
|
expect(confuse(a) is Foo, isTrue);
|
|
expect(() => (a as Foo), returnsNormally);
|
|
|
|
// You cannot cast between JS interop objects and Dart objects, however.
|
|
var dartClass = DartClass();
|
|
expect(dartClass is Foo, isFalse);
|
|
expect(confuse(dartClass) is Foo, isFalse);
|
|
expect(() => (dartClass as Foo), throws);
|
|
expect(dartClass is LiteralA, isFalse);
|
|
expect(confuse(dartClass) is LiteralA, isFalse);
|
|
expect(() => (dartClass as LiteralA), throws);
|
|
|
|
expect(foo is DartClass, isFalse);
|
|
expect(confuse(foo) is DartClass, isFalse);
|
|
expect(() => (foo as DartClass), throws);
|
|
expect(a is DartClass, isFalse);
|
|
expect(confuse(a) is DartClass, isFalse);
|
|
expect(() => (a as DartClass), throws);
|
|
|
|
// Test that nullability is still respected with JS types.
|
|
expect(foo is Foo?, isTrue);
|
|
expect(confuse(foo) is Foo?, isTrue);
|
|
expect(() => (foo as Foo?), returnsNormally);
|
|
Foo? nullableFoo = null;
|
|
expect(nullableFoo is Foo?, isTrue);
|
|
expect(confuse(nullableFoo) is Foo?, isTrue);
|
|
expect(() => (nullableFoo as Foo?), returnsNormally);
|
|
expect(nullableFoo is Foo, isFalse);
|
|
expect(confuse(nullableFoo) is Foo, isFalse);
|
|
expect(() => (nullableFoo as Foo),
|
|
hasUnsoundNullSafety ? returnsNormally : throws);
|
|
|
|
expect(a is LiteralA?, isTrue);
|
|
expect(confuse(a) is LiteralA?, isTrue);
|
|
expect(() => (a as LiteralA?), returnsNormally);
|
|
LiteralA? nullableA = null;
|
|
expect(nullableA is LiteralA?, isTrue);
|
|
expect(confuse(nullableA) is LiteralA?, isTrue);
|
|
expect(() => (nullableA as LiteralA?), returnsNormally);
|
|
expect(nullableA is LiteralA, isFalse);
|
|
expect(confuse(nullableA) is LiteralA, isFalse);
|
|
expect(() => (nullableA as LiteralA),
|
|
hasUnsoundNullSafety ? returnsNormally : throws);
|
|
}
|