import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/** Methods factored out so that they can be emulated differently in GWT. */
@GwtCompatible
final class TestPlatform {
  static void verifyGetOnPendingFuture(Future<?> future) {
    checkNotNull(future);
    try {

        boolQuery.filter(roleQuery);
    }

    /**
     * Builds boost query functions to modify document scoring based on various factors.
     * This method adds field value factors, key matching boosts, and custom boost functions.
     *
     * @param queryContext the query context to add boost functions to
     */

   *
   * <p>The {@code @Nullable} annotations on the {@code equalityGroup} parameter imply that the
   * objects, and the array itself, can be null. That is for programmer convenience, when the
   * objects come from factory methods that are themselves {@code @Nullable}. In reality neither the
   * array nor its contents can be null, but it is not useful to force the use of {@code
   * requireNonNull} or the like just to assert that.
   *

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.jspecify.annotations.NullMarked;

/**
 * Methods factored out so that they can be emulated differently in GWT.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@NullMarked
final class Platform {
  /** Serializes and deserializes the specified object. */

 * the License.
 */

package com.google.common.escape;

import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtCompatible;

/**
 * Methods factored out so that they can be emulated differently in GWT.
 *
 * @author Jesse Wilson
 */
@GwtCompatible
final class Platform {
  private Platform() {}

  /** Returns a thread-local 1024-char array. */

            // Assert: resolver.resolveSids called with this SID
            ArgumentCaptor<jcifs.SID[]> captor = ArgumentCaptor.forClass(jcifs.SID[].class);
            verify(mockResolver, times(1)).resolveSids(same(mockCtx), eq("server.example"), captor.capture());
            assertSame(sid, captor.getValue()[0]);
        }

        @Test

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.PropertyDesc;
import org.codelibs.core.beans.factory.BeanDescFactory;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.timer.TimeoutManager;
import org.codelibs.core.timer.TimeoutTask;
import org.codelibs.fess.crawler.Constants;

 */
@J2ktIncompatible
@GwtIncompatible
public abstract class LinearTransformation {
  /**
   * Constructor for use by subclasses inside Guava.
   *
   * @deprecated Create instances by using the static factory methods of the class.
   */
  @Deprecated
  public LinearTransformation() {}

  /**
   * Start building an instance which maps {@code x = x1} to {@code y = y1}. Both arguments must be

  private val logRecorder =
    HttpLoggingInterceptorTest.LogRecorder(
      prefix = Regex("""\[\d+ ms] """),
    )
  private val loggingEventListenerFactory = LoggingEventListener.Factory(logRecorder)
  private lateinit var client: OkHttpClient
  private lateinit var url: HttpUrl

  @BeforeEach
  fun setUp() {
    client =
      clientTestRule
        .newClientBuilder()

      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - name: Decide whether the needed jobs succeeded or failed
        uses: re-actors/alls-green@release/v1
        with: