private final Map<EventType, AtomicLong> eventCounters = new ConcurrentHashMap<>();
    private final Map<EventType, AtomicLong> eventTimings = new ConcurrentHashMap<>();

    // Configuration
    private volatile boolean enableJsonLogging = true;
    private volatile boolean maskSensitiveData = true;
    private volatile boolean includeStackTrace = false;
    private volatile Severity minLogLevel = Severity.INFO;

        updateDocumentationExtension(project, documentationExtension);
        configurePlugin(project, documentationExtension);
    }

    private static void applyPlugin(Project project) {
        project.getPlugins().apply(DokkaPlugin.class);
    }

    private static void updateDocumentationExtension(Project project, GradleDocumentationExtension extension) {

    private String role;

    /** The content of the message. */
    private String content;

    /** The timestamp when the message was created. */
    private LocalDateTime timestamp;

    /** The list of sources referenced in this message. */
    private List<ChatSource> sources;

    /** The HTML-rendered content for display. */
    private String htmlContent;

    /**
     * Default constructor.
     */

  private final Outcome expectedOutcome;
  private final Monitor monitor;
  private final FlagGuard guard;
  private final CountDownLatch tearDownLatch;
  private final CountDownLatch doingCallLatch;
  private final CountDownLatch callCompletedLatch;

  private GeneratedMonitorTest(
      Method method,
      Scenario scenario,
      boolean fair,
      @Nullable Timeout timeout,
      Outcome expectedOutcome) {

    }

    private static class BuiltinShellCommandRegistry extends JlineCommandRegistry implements AutoCloseable {
        private final LookupContext shellContext;
        private final MavenInvoker shellMavenInvoker;
        private final MavenParser mavenParser;
        private final EncryptInvoker shellEncryptInvoker;
        private final EncryptParser encryptParser;

@Deprecated
public class MetadataResolutionResult {
    private Artifact originatingArtifact;

    private List<Artifact> missingArtifacts;

    // Exceptions

    private List<Exception> exceptions;

    private List<Exception> versionRangeViolations;

    private List<ArtifactResolutionException> metadataResolutionExceptions;

    private List<CyclicDependencyException> circularDependencyExceptions;

@GwtIncompatible
public final class CacheBuilderSpec {
  /** Parses a single value. */
  private interface ValueParser {
    void parse(CacheBuilderSpec spec, String key, @Nullable String value);
  }

  /** Splits each key-value pair. */
  private static final Splitter KEYS_SPLITTER = Splitter.on(',').trimResults();

  /** Splits the key from the value. */
  private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').trimResults();

@GwtIncompatible
public final class CacheBuilderSpec {
  /** Parses a single value. */
  private interface ValueParser {
    void parse(CacheBuilderSpec spec, String key, @Nullable String value);
  }

  /** Splits each key-value pair. */
  private static final Splitter KEYS_SPLITTER = Splitter.on(',').trimResults();

  /** Splits the key from the value. */
  private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').trimResults();

    private final RemoteRepositoryManager remoteRepositoryManager;
    private final VersionResolver versionResolver;
    private final VersionRangeResolver versionRangeResolver;
    private final ArtifactResolver artifactResolver;
    private final RepositoryEventDispatcher repositoryEventDispatcher;
    private final ModelBuilder modelBuilder;
    private final ModelCacheFactory modelCacheFactory;

@Timeout(30)
open class TrailersTest {
  private val fileSystem = FakeFileSystem()

  @JvmField
  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var client =
    clientTestRule
      .newClientBuilder()