this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {

        if (value != null) {
            try {
                if (listener != null) {
                    listener.notifyFieldChangeUsingSetter("", value, bean);
                }
                setterInfo.method.invoke(bean, value);
            } catch (IllegalAccessException | InvocationTargetException | LinkageError e) {
                throw new ComponentConfigurationException(configuration, "Cannot set default", e);
            }

        // Event occurred before start, for an example an early cancel.
        0L
      } else {
        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)
      }

    logger.invoke("[$timeMs ms] $message")
  }

            getExpiredTimeMethod.setAccessible(true);

            long result1 = (Long) getExpiredTimeMethod.invoke(crawlingInfoHelper, 1);
            long result7 = (Long) getExpiredTimeMethod.invoke(crawlingInfoHelper, 7);
            long result0 = (Long) getExpiredTimeMethod.invoke(crawlingInfoHelper, 0);

            // Verify that results are reasonable relative to each other

   * synchronized.
   */
  @VisibleForTesting
  void invokeSubscriberMethod(Object event) throws InvocationTargetException {
    try {
      method.invoke(target, checkNotNull(event));
    } catch (IllegalArgumentException e) {
      throw new Error("Method rejected target/argument: " + event, e);
    } catch (IllegalAccessException e) {

 *
 * <h3>Usage</h3>
 *
 * Given an algorithm, for example:
 *
 * {@snippet :
 * public <N> someGraphAlgorithm(N startNode, PredecessorsFunction<N> predecessorsFunction);
 * }
 *
 * you will invoke it depending on the graph representation you're using.
 *
 * <p>If you have an instance of one of the primary {@code common.graph} types ({@link Graph},
 * {@link ValueGraph}, and {@link Network}):
 *
 * {@snippet :

 *
 * <h3>Usage</h3>
 *
 * Given an algorithm, for example:
 *
 * {@snippet :
 * public <N> someGraphAlgorithm(N startNode, SuccessorsFunction<N> successorsFunction);
 * }
 *
 * you will invoke it depending on the graph representation you're using.
 *
 * <p>If you have an instance of one of the primary {@code common.graph} types ({@link Graph},
 * {@link ValueGraph}, and {@link Network}):
 *
 * {@snippet :

	// since the `objectLayer==nil`  check is performed before any other checks inside the handlers.
	// The only aim is to generate an HTTP request in a way that the relevant/registered end point is evoked/called.

	nilBucket := "dummy-bucket"
	nilObject := "dummy-object"
	nilReq, err := newTestSignedRequestV4(http.MethodHead, getGetObjectURL("", nilBucket, nilObject),
		0, nil, "", "", nil)
	if err != nil {

  fun checkForPinning() {
    assertThat(capturedOut.toString()).isEmpty()
  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService =
    Executors::class.java.getMethod("newVirtualThreadPerTaskExecutor").invoke(null) as ExecutorService

  @Test
  fun testHttpsRequest() {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      mockServerClient
        .`when`(
          request()

   * Verifies that {@code method} produces a {@link NullPointerException} or {@link
   * UnsupportedOperationException} whenever <i>any</i> of its non-nullable parameters are null.
   *
   * @param instance the instance to invoke {@code method} on, or null if {@code method} is static
   */
  public void testMethod(@Nullable Object instance, Method method) {
    Class<?>[] types = method.getParameterTypes();