Update isolate tests.

Remove uses of async_minitest and multitests.

Removed two files that were checking dynamic behavior that no longer exists (compile-time errors reported at runtime).

Rewrote and/or added to enum_const_test.dart and _deferred_in_isoltae_test.dart.

Otherwise mainly removing multitest `//# ok:...` comments, or `//# 01: ...error...` that only existed because the test failed in dart2js, along with anything else that tried to special-case dart2js (which no longer supports isolates at all).
Some sporadic general clean-up like removing library names.

Change-Id: I99b55f05710347343286e86b37ce02f1006868dc
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/402700
Reviewed-by: Nate Bosch <[email protected]>
Commit-Queue: Lasse Nielsen <[email protected]>

Author: lrhn

tests/lib/isolate/compile_time_error_test.dart

@@ -3,6 +3,4 @@
 // BSD-style license that can be found in the LICENSE file.
 
 // Used by deferred_in_isolate2_test.
-library deferred_in_isolate2_lib;
-
 String f() => "hi";

tests/lib/isolate/deferred_in_isolate2_lib.dart

@@ -5,22 +5,37 @@
 library deferred_in_isolate2_test;
 
 import 'dart:isolate';
-import 'package:expect/legacy/async_minitest.dart'; // ignore: deprecated_member_use
+
+import 'package:expect/async_helper.dart';
+import 'package:expect/expect.dart';
 
 import 'deferred_in_isolate2_lib.dart' deferred as lib;
 
-loadDeferred(port) {
+void loadDeferred(SendPort port) {
   lib.loadLibrary().then((_) {
     port.send(lib.f());
   });
 }
 
-main() {
-  test("Deferred loading in isolate", () {
-    ReceivePort port = new ReceivePort();
-    port.first.then(expectAsync((msg) {
-      expect(msg, equals("hi"));
-    }));
-    Isolate.spawn(loadDeferred, port.sendPort);
-  });
+void main() {
+  asyncStart(2);
+  var port = RawReceivePort();
+  port.handler = (msg) {
+    if (msg == null) {
+      asyncEnd();
+      port.close();
+    } else if (msg case [String error, String stack]) {
+      var remoteError = RemoteError("Error in isolate: $error", stack);
+      Error.throwWithStackTrace(remoteError, remoteError.stackTrace);
+    } else {
+      Expect.equals("hi", msg);
+      asyncEnd();
+    }
+  };
+  Isolate.spawn(
+    loadDeferred,
+    port.sendPort,
+    onError: port.sendPort,
+    onExit: port.sendPort,
+  );
 }

tests/lib/isolate/deferred_in_isolate2_test.dart

@@ -2,27 +2,19 @@
 // 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.
 
-import 'deferred_in_isolate_lib.dart' deferred as test;
+import 'dart:isolate' show SendPort;
 
-void main(args, msg) {
-  assert(args != null);
-  assert(args.length == 1);
-  assert(msg != null);
-  assert(msg.length == 1);
+import 'deferred_in_isolate_lib.dart' deferred as lib;
 
+void main(List<String> args, Object? msg) {
+  assert(args.length == 1);
   var expectedMsg = args[0];
-  var replyPort = msg[0];
+  var replyPort = msg as SendPort;
 
-  try {
-    print("BeforeLibraryLoading");
+  replyPort.send(true); // Tell test that isolate has started.
 
-    test.loadLibrary().then((_) {
-      var obj = new test.DeferredObj(expectedMsg);
-      replyPort.send(obj.toString());
-    }).catchError((error) {
-      replyPort.send("Error from isolate:\n$error");
-    });
-  } catch (exception, stacktrace) {
-    replyPort.send("Exception from isolate:\n$exception\n$stacktrace");
-  }
+  lib.loadLibrary().then((_) {
+    var obj = lib.DeferredObj(expectedMsg);
+    replyPort.send("$obj");
+  });
 }

tests/lib/isolate/deferred_in_isolate_app.dart

@@ -2,11 +2,9 @@
 // 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 deferred_in_isolate_lib;
-
 class DeferredObj {
   DeferredObj(this._val);
-  toString() => "$_val";
+  String toString() => "*$_val*";
 
-  var _val;
+  final Object? _val;
 }

tests/lib/isolate/deferred_in_isolate_lib.dart

@@ -7,31 +7,45 @@
 
 import 'dart:isolate';
 
-main() {
-  try {
-    var receivePort = new RawReceivePort();
-    var expectedMsg = "Deferred Loaded.";
+import 'package:expect/async_helper.dart';
+import 'package:expect/expect.dart';
 
-    receivePort.handler = (msg) {
-      if (msg != expectedMsg) {
-        print("Test failed.");
-        throw msg; // Fail the test if the message is not expected.
-      }
-      print('Test done.');
+void main() {
+  asyncStart(4);
+  var receivePort = RawReceivePort();
+  var nonce = "Deferred Loaded.";
+  int state = 0; // Incremented when reaching expected steps in communication.
+
+  receivePort.handler = (reply) {
+    if (reply == null) {
+      Expect.equals(2, state); // After isolate result message.
+      state = -1;
+      // Isolate exit.
       receivePort.close();
-    };
+      asyncEnd();
+    } else if (reply == true) {
+      Expect.equals(0, state); // Initial isolate-start message.
+      state = 1;
+      asyncEnd();
+    } else if (reply case [String error, String stack]) {
+      // Isolate unhandled or handled error.
+      var remoteError = RemoteError("@$state: $error", stack);
+      Error.throwWithStackTrace(remoteError, remoteError.stackTrace);
+    } else {
+      Expect.equals("*$nonce*", reply);
+      Expect.equals(1, state); // After isolate-start message.
+      state = 2;
+      asyncEnd();
+    }
+  };
 
-    var stopwatch = new Stopwatch()..start();
-    Isolate.spawnUri(new Uri(path: 'deferred_in_isolate_app.dart'),
-        [expectedMsg], [receivePort.sendPort]).then((isolate) {
-      print('Isolate spawn: ${stopwatch.elapsedMilliseconds}ms');
-    }).catchError((error) {
-      print(error);
-    });
-  } catch (exception, stackTrace) {
-    print('Test failed.');
-    print(exception);
-    print(stackTrace);
-    rethrow;
-  }
+  Isolate.spawnUri(
+    Uri(path: 'deferred_in_isolate_app.dart'),
+    [nonce],
+    receivePort.sendPort,
+    onError: receivePort.sendPort,
+    onExit: receivePort.sendPort,
+  ).then((_) {
+    asyncEnd();
+  });
 }

tests/lib/isolate/deferred_in_isolate_test.dart

@@ -2,30 +2,56 @@
 // 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.
 
-// Formatting can break multitests, so don't format them.
-// dart format off
-
 import "dart:isolate";
+
+import "package:expect/async_helper.dart";
 import "package:expect/expect.dart";
 
-enum Foo { BAR, BAZ }
+/// Check that an enum value sent through a send/receive-port retains identity.
+
+enum Foo { bar, baz }
+
+void main() {
+  asyncStart();
+  test1();
+  test2();
+  test3();
+  asyncEnd();
+}
 
-verify(val) {
-  Expect.identical(Foo.BAR, val);
+void verify(Object? val) {
+  Expect.identical(Foo.bar, val);
 }
 
-main() {
-  test1(); //# 01: ok
-  test2(); //# 02: ok
+void test1() {
+  // Sanity check.
+  verify(Foo.bar);
 }
 
-test1() => verify(Foo.BAR);
+void test2() {
+  // From same isolate.
+  asyncStart();
+  var rp = RawReceivePort();
+  rp.handler = (val) {
+    verify(val);
+    rp.close();
+    asyncEnd();
+  };
+  rp.sendPort.send(Foo.bar);
+}
 
-test2() {
-  var rp;
-  rp = new RawReceivePort((val) {
+void test3() {
+  // From other isolate.
+  asyncStart();
+  var rp = RawReceivePort();
+  rp.handler = (val) {
     verify(val);
     rp.close();
-  });
-  rp.sendPort.send(Foo.BAR);
+    asyncEnd();
+  };
+  Isolate.spawn(_sendFoo, rp.sendPort);
+}
+
+void _sendFoo(SendPort sendPort) {
+  sendPort.send(Foo.bar);
 }

tests/lib/isolate/enum_const_test.dart

@@ -2,49 +2,43 @@
 // 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.
 
-// Formatting can break multitests, so don't format them.
-// dart format off
-
 import 'dart:isolate';
 import 'package:expect/async_helper.dart';
 import "package:expect/expect.dart";
 
 import "deferred_loaded_lib.dart" deferred as lib;
 
-// In this test case we send an object created from a deferred library
-// that is loaded in the child isolate but not the parent isolate. The
-// parent isolate does not know about the type of this object and throws
-// an unhandled exception.
-funcChild(args) {
-  var replyPort = args[0];
+// Sends an object created from a deferred library that is loaded in the child
+// isolate but not the parent isolate.
+// The parent isolate successfully receives the object.
+
+void funcChild(SendPort replyPort) {
   // Deferred load a library, create an object from that library and send
   // it over to the parent isolate which has not yet loaded that library.
   lib.loadLibrary().then((_) {
     replyPort.send(new lib.FromChildIsolate());
   });
 }
 
-void helperFunction() {
+void main() {
   var receivePort = new ReceivePort();
   asyncStart();
 
   // Spawn an isolate using spawnFunction.
-  Isolate.spawn(funcChild, [receivePort.sendPort]).then((isolate) {
-    receivePort.listen((msg) {
-      // We don't expect to receive any valid messages.
-      Expect.fail("We don't expect to receive any valid messages");
-      receivePort.close();
-      asyncEnd();
-    }, onError: (e) {
-      // We don't expect to receive any error messages, per spec listen
-      // does not receive an error object.
-      Expect.fail("We don't expect to receive any error messages");
-      receivePort.close();
-      asyncEnd();
-    });
+  Isolate.spawn(funcChild, receivePort.sendPort).then((isolate) {
+    receivePort.listen(
+      (dynamic msg) {
+        Expect.equals(10, msg.fld);
+        receivePort.close();
+        asyncEnd();
+      },
+      onError: (e, s) {
+        // We don't expect to receive any error messages, per spec listen
+        // does not receive an error object.
+        Expect.fail("We don't expect to receive any error messages");
+        receivePort.close();
+        asyncEnd();
+      },
+    );
   });
 }
-
-main() {
-  helperFunction(); //# 01: runtime error
-}