.that(returnType.getComponentType())
          .isEqualTo(annotationClass.getDeclaringClass());
    }
  }

  // This is public so that tests for Feature enums we haven't yet imagined
  // can reuse it.
  public static <E extends Enum<?> & Feature<?>> void assertGoodFeatureEnum(
      Class<E> featureEnumClass) {
    Class<?>[] classes = featureEnumClass.getDeclaredClasses();

            t.setTargetCompatibility(BuildParams.getRuntimeJavaVersion().getMajorVersion());
            if (BuildParams.getRuntimeJavaVersion().compareTo(JavaVersion.VERSION_14) > 0) {
                // TODO: forbidden apis does not yet support java 15, rethink using runtime version
                t.setTargetCompatibility(JavaVersion.VERSION_14.getMajorVersion());
            }

            state="pending",
            description="Deploying Docs",
            context="deploy-docs",
            target_url=run_url,
        )
        logging.info("No deploy URL available yet")
        return
    if settings.state == "error":
        current_commit.create_status(
            state="error",
            description="Error Deploying Docs",
            context="deploy-docs",

 *   <li>Loading: loading is pending
 * </ul>
 *
 * <p>Invalid:
 *
 * <ul>
 *   <li>Expired: time expired (key/value may still be set)
 *   <li>Collected: key/value was partially collected, but not yet cleaned up
 *   <li>Unset: marked as unset, awaiting cleanup or reuse
 * </ul>
 */
@GwtIncompatible
@J2ktIncompatible
interface ReferenceEntry<K, V> {
  /** Returns the value reference from this entry. */

     *         any.
     */
    public PersistedToolchains read(XmlPullParser parser, boolean strict) throws IOException, XmlPullParserException {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    /**
     * @param reader a reader object.
     * @param strict a strict object.
     * @return PersistedToolchains
     * @throws IOException IOException if any.

  /** The total number of bytes permitted to be produced by incoming `WINDOW_UPDATE` frame. */
  var writeBytesMaximum: Long = connection.peerSettings.initialWindowSize.toLong()
    internal set

  /** Received headers yet to be [taken][takeHeaders]. */
  private val headersQueue = ArrayDeque<Headers>()

  /** True if response headers have been sent or received. */
  private var hasResponseHeaders: Boolean = false

  override val source =

        with(standardError) {
            files.forEach {
                assertContains("API changes in file '${it.name}' should be in alphabetical order (by type and member), yet these changes were not:\n")
            }
            changes?.forEach { assertContains(it.toString()) }
            assertContains(cleanupHint)
        }
    }

    private

     *
     * @param project the project to get the artifact path for
     * @return an Optional containing the path to the built artifact if available,
     *         or empty if the artifact hasn't been built yet
     */
    @Nonnull
    Optional<Path> getPath(@Nonnull Project project);

    /**
     * Returns an immutable collection of attached artifacts for the given project.

    EventListenerAdapter()
      .apply {
        listeners += ::logEvent
      }

  val eventListener: EventListener
    get() = eventListenerAdapter

  /** Events that haven't yet been removed. */
  val eventSequence: Deque<CallEvent> = ConcurrentLinkedDeque()

  /** The full set of events, used to match starts with ends. */
  private val eventsForMatching = ConcurrentLinkedDeque<CallEvent>()

    checkNotNull(supplier);
    Predicate<Throwable> predicate = INSTANCE_OF.get(expectedThrowable);
    if (predicate == null) {
      throw new IllegalArgumentException(
          expectedThrowable
              + " is not yet supported by ReflectionFreeAssertThrows. Add an entry for it in the"
              + " map in that class.");
    }
    Object result;
    try {
      result = supplier.get();
    } catch (Throwable t) {