assertThrows(
            TimeoutException.class,
            () -> service.startAsync().awaitRunning(1, TimeUnit.MILLISECONDS));
    assertThat(e)
        .hasMessageThat()
        .isEqualTo("Timed out waiting for Foo [STARTING] to reach the RUNNING state.");
  }

  private class FakeService extends AbstractExecutionThreadService implements TearDown {

    val readTimeout = soTimeout
    try {
      soTimeout = 1
      !source.exhausted()
    } finally {
      soTimeout = readTimeout
    }
  } catch (_: SocketTimeoutException) {
    true // Read timed out; socket is good.
  } catch (_: IOException) {
    false // Couldn't read; socket is closed.
  }
}

internal inline fun threadName(
  name: String,
  block: () -> Unit,
) {

	Err         string // description of the error
	Name        string // name looked for
	Server      string // server used
	IsTimeout   bool   // if true, timed out; not all timeouts set this
	IsTemporary bool   // if true, error is temporary; not all errors set this

	// IsNotFound is set to true when the requested name does not

		ctx, cancel := contextFromChannelAndMaxWaitDuration(hookContext.StopCh, 5*time.Minute)
		defer cancel()

		if !cache.WaitForCacheSync(ctx.Done(), bce.informersSynced...) {
			return fmt.Errorf("APF bootstrap ensurer timed out waiting for cache sync")
		}

		err = wait.PollImmediateUntilWithContext(
			ctx,
			time.Second,
			func(context.Context) (bool, error) {

			}
		}(index, c)
	}

	// Wait until we have either
	//
	// a) received all refresh responses
	// b) received too many refreshed for quorum to be still possible
	// c) timed out
	//
	lockNotFound, lockRefreshed := 0, 0
	done := false

	for i := 0; i < len(restClnts); i++ {
		select {
		case refreshResult := <-ch:
			if refreshResult.offline {
				continue
			}

        .socketPolicy(NoResponse)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertFailure(
      SocketTimeoutException::class.java,
      "timeout",
      "Read timed out",
    )
    assertThat(webSocket.close(1000, null)).isFalse()
  }

  /**
   * There's no read timeout when reading the first byte of a new frame. But as soon as we start

					}
					klog.ErrorS(restartErr, "Retrying after error")
					lastErr = restartErr
					return false, nil
				})
				if err != nil {
					klog.ErrorS(err, "Unable to restart server: wait timed out", "lastErr", lastErr.Error())
					panic(err)
				}

				if ok := m.registerControlFunc(); ok {
					if err := m.Register(kubeletEndpoint, resourceName, pluginSockDir); err != nil {

	sb := new(strings.Builder)
	cmd.Stdout = sb
	cmd.Stderr = sb
	if err := cmd.Start(); err != nil {
		t.Fatal(err)
	}

	timer := time.AfterFunc(time.Minute,
		func() {
			t.Error("test program timed out")
			cmd.Process.Kill()
		},
	)
	defer timer.Stop()

	err = cmd.Wait()
	t.Logf("%v\n%s", cmd.Args, sb)
	if err != nil {
		t.Error(err)
	}
}

// Issue 49288.

                }
            }
            LOGGER.debug("Cancel: daemon is still busy after grace period. Will force stop.");
            stopNow("cancel requested but timed out");
            return DaemonStopState.Forced;
        } finally {
            lock.unlock();
        }
    }

    @Override

	}
	// check client to make sure receive response.
	select {
	case <-graceCh:
		t.Logf("server shutdown gracefully.")
	case <-time.After(30 * time.Second):
		t.Errorf("Timed out waiting for response.")
	}
}

func TestWarningWithRequestTimeout(t *testing.T) {
	type result struct {
		err        interface{}
		stackTrace string
	}