.that(ListenableFuture.class.getDeclaredMethods())
        .asList()
        .containsExactly(
            ListenableFuture.class.getMethod("addListener", Runnable.class, Executor.class));
    assertWithMessage(
            "Do not add new supertypes to ListenableFuture. Its API needs to continue to match the"

  fun buildsWhenJdk9() {
    platform.assumeJdk9()
    assertThat(buildIfSupported()).isNotNull()
  }

  @Test
  fun buildsWhenJdk8() {
    platform.assumeJdk8()
    try {
      SSLSocket::class.java.getMethod("getApplicationProtocol")
      // also present on JDK8 after build 252.
      assertThat(buildIfSupported()).isNotNull()
    } catch (nsme: NoSuchMethodException) {
      assertThat(buildIfSupported()).isNull()
    }

    Method getMethod = List.class.getMethod("get", int.class);
    Method setMethod = List.class.getMethod("set", int.class, Object.class);
    new EqualsTester()
        .addEqualityGroup(Invokable.from(getMethod), Invokable.from(getMethod))
        .addEqualityGroup(Invokable.from(setMethod))
        .addEqualityGroup(new TypeToken<List<Integer>>() {}.method(getMethod))

    }

    @Override
    public void close() {
        if (!closed) {
            closed = true;
            HttpClientUtils.closeQuietly(httpResponse);
        }
    }

    String getMethod() {
        return method;
    }

    URI getEffectiveUri() {
        return effectiveUri;
    }

    boolean wasSuccessful() {
        int statusCode = getStatusLine().getStatusCode();

    }

    public Object[] getArguments() {
        return arguments;
    }

    public String getMethodName() {
        return method.getName();
    }

    public Method getMethod() {
        return method;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || obj.getClass() != getClass()) {

                    .firstOrNull { it.name == "getConvention" }
                    ?.invoke(this)
                    ?.let { convention ->
                        convention::class.java
                            .getMethod("findPlugin", Class::class.java)
                            .invoke(convention, T::class.java)
                    }
            }.let { findPlugin ->

   * unhashable objects can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()}.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getHashCodeMethod() {
    return Helpers.getMethod(ListHashCodeTester.class, "testHashCode");
  }

        get() = withValidityAssertion { KaFe10DescFunctionSymbol.build(descriptor.getMethod, analysisContext) }

    override val javaSetterSymbol: KaFunctionSymbol?
        get() = withValidityAssertion {
            val setMethod = descriptor.setMethod ?: return null
            return KaFe10DescFunctionSymbol.build(setMethod, analysisContext)
        }

    override val hasSetter: Boolean

                } else {
                    addDir(entry.name)
                }
                addMode(entry.name, entry.getUnixMode())
                addCompressionMethod(entry.name, entry.getMethod())
            }
        } finally {
            zipFile.close();
        }
    }

    void hasCompression(String relativePath, int compressionMethod) {

        def actor = factory.createBlockingActor(target)
        def testThread = Thread.currentThread()

        when:
        actor.dispatch(new MethodInvocation(TargetObject.class.getMethod('doStuff', String.class), ['param'] as Object[]))

        then:
        1 * target.doStuff('param') >> {
            assert Thread.currentThread() == testThread
        }
    }