}
    }
    return suite;
  }

  /** Throw {@link IllegalStateException} if {@link #createTestSuite()} can't be called yet. */
  protected void checkCanCreate() {
    if (subjectGenerator == null) {
      throw new IllegalStateException("Call using() before createTestSuite().");
    }
    if (name == null) {
      throw new IllegalStateException("Call named() before createTestSuite().");
    }

                  throws Throwable {
                throw exception;
              }
            });
    T wrapper = wrapperFunction.apply(proxy);
    try {
      method.invoke(wrapper, getParameterValues(method));
      fail(method + " failed to throw exception as is.");
    } catch (InvocationTargetException e) {
      if (exception != e.getCause()) {
        throw new RuntimeException(e);
      }

            throw new TransferCancelledException();
        }
        put(event, false);
    }

    @Override
    public void transferProgressed(TransferEvent event) throws TransferCancelledException {
        if (ongoing.get(new TransferResourceIdentifier(event.getResource())) == Boolean.FALSE) {
            throw new TransferCancelledException();
        }

  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final @Nullable E pollFirst() {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the set unmodified.
   *
   * @since 12.0
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated

        } catch (final SuggesterException e) {
            // Re-throw SuggesterException with original message
            throw e;
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create and switch to next index: baseIndex={}", index, e);
            }
            throw new SuggesterException("Failed to create and switch to next index: " + index, e);

                (k, v) -> {
                  throw new AssertionFailedError();
                }));
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testComputeIfPresent_unsupportedAbsent() {
    try {
      getMap()
          .computeIfPresent(
              k3(),
              (k, v) -> {
                throw new AssertionFailedError();
              });

    Iterator<String> iterator = asList("one", "two", "three", "four", "five").iterator();
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> getOnlyElement(iterator));
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("expected one element but was: <one, two, three, four, five>");
  }

        }
        throw new MethodNotFoundRuntimeException(beanClass, methodName, args);
    }

    @Override
    public MethodDesc[] getMethodDescs(final String methodName) {
        assertArgumentNotEmpty("methodName", methodName);

        final MethodDesc[] methodDescs = methodDescsCache.get(methodName);
        if (methodDescs == null) {

        val request = Request.Builder()
            .url("https://publicobject.com/helloworld.txt")
            .build()

        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          for ((name, value) in response.headers) {
            println("$name: $value")
          }

          println(response.body!!.string())
        }
      }

                if (entry.getPr() == null) {
                    throw new GradleException(
                        "[" + path + "] must provide a [pr] number (only 'known-issue' and " + "'security' entries can omit this"
                    );
                }

                if (entry.getArea() == null) {
                    throw new GradleException(