send = recv
			}
			select {
			case d.resultCh <- send:
				// propagated event successfully
			case <-ctx.Done():
				// context timed out or was cancelled, stop the underlying watcher
				d.w.Stop()
				return
			}
		case <-ctx.Done():
			// context timed out or was cancelled, stop the underlying watcher
			d.w.Stop()
			return
		}
	}
}

func (d *decoratedWatcher) Stop() {

            synchronized (lock) {
                if (!stopped) {
                    slowStop = true;
                    doAsPartOfBuildOperation(() -> {
                        LOGGER.warn("Timed out {} has not yet stopped.", workUnitDescription.getDisplayName());

                        if (logStacktraceTimer.hasExpired()) {
                            StackTraceElement[] currentStackTrace = thread.getStackTrace();

    }
  }

  private Outcome doCall() {
    boolean guarded = isGuarded(method);
    boolean timed = isTimed(method);
    Object[] arguments = new Object[(guarded ? 1 : 0) + (timed ? 2 : 0)];
    if (guarded) {
      arguments[0] = guard;
    }
    if (timed) {
      arguments[arguments.length - 2] = timeout.millis;
      arguments[arguments.length - 1] = TimeUnit.MILLISECONDS;
    }

        )
    }

    private
    fun textFromResource(named: String) =
        javaClass.getResource(named).readText()

    private
    fun String.withoutTrailingWhitespace() =
        lineSequence().map { it.trimEnd() }.joinToString("\n")

  }

  /**
   * Waits until the given future {@linkplain Future#isDone is done}, invoking the garbage collector
   * as necessary to try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/260137033
  public static void awaitDone(Future<?> future) {
    if (future.isDone()) {
      return;
    }

			// Update the deployment with a timeout condition. If the condition already exists,
			// we ignore this update.
			msg := fmt.Sprintf("Deployment %q has timed out progressing.", d.Name)
			if newRS != nil {
				msg = fmt.Sprintf("ReplicaSet %q has timed out progressing.", newRS.Name)
			}
			condition := util.NewDeploymentCondition(apps.DeploymentProgressing, v1.ConditionFalse, util.TimedOutReason, msg)

{"Action":"start"}
{"Action":"run","Test":"Test"}
{"Action":"output","Test":"Test","Output":"=== RUN   Test\n"}
{"Action":"output","Test":"Test","Output":"panic: test timed out after 1s\n"}
{"Action":"output","Test":"Test","Output":"\n"}
{"Action":"output","Output":"FAIL\tp\t1.111s\n"}
{"Action":"output","Output":"FAIL\n"}

  }

  /**
   * Waits until the given future {@linkplain Future#isDone is done}, invoking the garbage collector
   * as necessary to try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/260137033
  public static void awaitDone(Future<?> future) {
    if (future.isDone()) {
      return;
    }

# Tests issue 19394

[short] skip

! go test -cpuprofile cpu.pprof -memprofile mem.pprof -timeout 1ms
stdout '^panic: test timed out'
grep . cpu.pprof
grep . mem.pprof

-- go.mod --
module profiling

go 1.16
-- timeout_test.go --
package timeouttest_test

import (
	"testing"
	"time"
)

func TestSleep(t *testing.T) {
	for {
		time.Sleep(1 * time.Second)
	}

            appendLine("Resolve extension navigation targets: ${navTargets.size}")
            withIndent { navTargets.forEach { appendLine(it.toString()) } }
        }
    }.trimEnd()