assertTrue(
        Visibility.PACKAGE.isVisible(VisibilityMethods.class.getDeclaredMethod("publicMethod")));
  }

  @SuppressWarnings("ClassCanBeStatic") // We want to test an inner class.
  private class Inner {
    @Keep
    public Inner(String s) {
      checkNotNull(s);
    }
  }

  public void testNonStaticInnerClass() {
    IllegalArgumentException expected =
        assertThrows(

import org.gradle.testkit.runner.BuildResult;
import org.gradle.testkit.runner.GradleRunner;

public class TestingConventionsTasksIT extends GradleIntegrationTestCase {

    @Override
    public String projectName() {
        return "testingConventions";
    }

    public void testInnerClasses() {

                        listOf("async-profiler", "async-profiler-heap")
                    }.map { FlameGraphGenerationBuildSpec(scenario, os, arch, it) }
                }
            }

    inner class FlameGraphGenerationBuildSpec(
        val performanceScenario: PerformanceScenario,
        override val os: Os,
        override val arch: Arch,
        val profiler: String,
    ) : PerformanceTestBuildSpec {

  /**
   * A source that reads the incoming data frames of a stream. Although this class uses
   * synchronization to safely receive incoming data frames, it is not intended for use by multiple
   * readers.
   */
  inner class FramingSource internal constructor(
    /** Maximum number of bytes to buffer before reporting a flow control error. */
    private val maxByteCount: Long,
    /**

 * RequestData request = RequestDataBuilder.newRequestData()
 *     .method("GET")
 *     .url("https://example.com")
 *     .weight(1.0f)
 *     .build();
 * </pre>
 *
 * <p>The builder is implemented using an inner class {@link RequestDataContext} that handles
 * the actual construction of the RequestData object.</p>
 *
 */
public final class RequestDataBuilder {
    private RequestDataBuilder() {
    }

    /**

ion.href=\"# \"'> </div> % # ( ) # ( ) # ( ) # ( ) images/interface.png images/abstract.png images/innerabstract.png images/innerclass.png images/class.png images/innerinterface.png images/logo.png images/link.png images/mixedCycleLink.png images/inner.png images/mix.png images/package.png images/innerCycleLink.png...

        }

        DefaultParser parser = new DefaultParser();
        parser.setRegexCommand("[:]{0,1}[a-zA-Z!]{1,}\\S*"); // change default regex to support shell commands

        String banner = """

                ░▒▓██████████████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░░▒▓███████▓▒░  ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░\s
                ░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░       ░▒▓█▓▒░░▒▓█▓▒░\s

          // We have a connected TCP connection. Cancel and defer the racing connects that all lost.
          cancelInFlightConnects()

          // Finish connecting. We won't have to if the winner is from the connection pool.
          if (!connectResult.plan.isReady) {
            connectResult = connectResult.plan.connectTlsEtc()
          }

          if (connectResult.isSuccess) {

  override fun sameHostAndPort(url: HttpUrl): Boolean = url.host == address.url.host && url.port == address.url.port

  override fun close() {
    factory.close()
  }

  inner class FakePlan(
    val id: Int,
  ) : RoutePlanner.Plan {
    var planningThrowable: Throwable? = null
    var canceled = false
    var connectState = ConnectState.READY
    val connection =

            .expireAfterAccess(500000, MILLISECONDS)
            .maximumSize(count)
            .build();
  }

  public void testComputeIfAbsent() {
    // simultaneous insertion for same key, expect 1 winner
    doParallelCacheOp(count, n -> cache.asMap().computeIfAbsent(key, k -> "value" + n));
    assertThat(cache.size()).isEqualTo(1);
  }

  public void testComputeIfAbsentEviction() {
    // b/80241237