sdk/tests/lib/async/error_stack_test.dart

// Copyright (c) 2024, 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.

import 'dart:async';

// Checks that an `Error` object that is "thrown" through async functionality
// gets a stack trace set.

import 'package:expect/async_helper.dart';
import 'package:expect/expect.dart';

main() async {
  asyncStart();

  for ((String, Object, StackTrace, Object, String, AsyncError?)
      Function() setUp in [
    () {
      // Without error callback. Inject and expect same fresh error.
      var error = StateError("Quo!");
      var stack = StackTrace.fromString("Secret stack");
      return ("", error, stack, error, stack.toString(), null);
    },
    () {
      // With error callback, same error, new stack.
      var error = StateError("Quo");
      var stack = StackTrace.fromString("Secret stack");
      var stack2 = StackTrace.fromString("Other stack");
      var errorCallback = AsyncError(error, stack2);
      return (
        "errorCallback: fresh both",
        error,
        stack,
        error,
        stack2.toString(),
        errorCallback
      );
    },
    () {
      // With error callback, new error, stack.
      var error = StateError("Quo");
      var stack = StackTrace.fromString("Secret stack");
      var error2 = StateError("Quid");
      var stack2 = StackTrace.fromString("Other stack");
      var errorCallback = AsyncError(error2, stack2);
      return (
        "errorCallback: fresh stack",
        error,
        stack,
        error2,
        stack2.toString(),
        errorCallback
      );
    },
  ]) {
    Future<void> test(String name,
        Future<(Object, StackTrace)> Function(Object, StackTrace) body) {
      var (msg, error, stack, expectError, expectStackString, errorCallback) =
          setUp();
      print("Test: $name${msg.isNotEmpty ? ", $msg" : msg}");

      return asyncTest(() => runZoned(() => body(error, stack),
              zoneSpecification: ZoneSpecification(
                  errorCallback: (s, p, z, e, st) => errorCallback)).then((es) {
            var (e, s) = es;
            Expect.identical(expectError, e, name);
            Expect.equals(expectStackString, s.toString(), name);
            Expect.equals(
                expectStackString, (e as Error).stackTrace.toString(), name);
          }));
    }

    // Sanity check: Plain throws.
    () {
      var (name, error, stack, error2, stack2, errorCallback) = setUp();
      try {
        Error.throwWithStackTrace(error, stack);
      } catch (e, s) {
        Expect.identical(error, e, "Error.throw");
        Expect.equals(stack.toString(), s.toString(), "Error.throw");
        Expect.equals(stack.toString(), (e as Error).stackTrace.toString(),
            "Error.throw");
      }
    }();

    // Futures.

    // Immediate error.
    await test("Future.error",
        (error, stack) => futureError(Future.error(error, stack)));

    // Through controller, async.
    await test("Completer().completeError", (error, stack) {
      var completer = Completer<void>();
      completer.completeError(error, stack);
      return futureError(completer.future);
    });

    // Through controller, sync.
    await test("Completer.sync().completeError", (error, stack) {
      var completer = Completer<void>.sync();
      var future = completer.future..ignore();
      completer.completeError(error, stack);
      return futureError(future);
    });

    // Streams.

    // Singleton error.
    await test("Stream.error",
        (error, stack) => streamError(Stream.error(error, stack)));

    // Controller errors.
    for (var broadcast in [false, true]) {
      for (var sync in [false, true]) {
        await test(
            "Stream${broadcast ? ".broadcast" : ""}${sync ? "(sync)" : ""}",
            (error, stack) {
          var controller = broadcast
              ? StreamController<void>.broadcast(sync: sync)
              : StreamController<void>(sync: sync);
          var future = streamError(controller.stream)..ignore();
          controller.addError(error, stack);
          return future;
        });
      }
    }
  }

  asyncEnd();
}

// --------------------------------------------------------------------
// Helper functions

(Object, StackTrace) captureError(Object e, StackTrace s) => (e, s);

(Object, StackTrace) fail(_) {
  Expect.fail("No error from future") as Never;
}

/// Captures error of future.
Future<(Object, StackTrace)> futureError(Future<void> future) =>
    future.then(fail, onError: captureError);

/// Captures first error of stream.
Future<(Object, StackTrace)> streamError(Stream<void> stream) {
  var c = Completer<(Object, StackTrace)>();
  var sub = stream.listen((_) {
    // No values expected.
  }, onError: (Object e, StackTrace s) {
    c.complete((e, s));
  }, onDone: () {
    Expect.fail("No error from stream");
  }, cancelOnError: true);
  return c.future;
}