protected Analyzer analyzer = new WhitespaceAnalyzer();

    /** Whether to allow leading wildcards in query terms */
    protected boolean allowLeadingWildcard = true;

    /** The default operator to use between query terms */
    protected Operator defaultOperator = Operator.AND;

    /** List of filters to apply to queries */
    protected List<Filter> filterList = new ArrayList<>();

    private static final Object[] OBJECT_ARGS = new Object[0];

    /**
     * Use a WeakHashMap here, so the keys (Class objects) can be garbage collected.
     * This approach prevents permgen space overflows due to retention of discarded
     * classloaders.
     */
    private static final Map<Class<?>, WeakReference<ClassMap>> CLASS_MAPS = new WeakHashMap<>();

    static final int EOF = -1;

      Throwable cause, Class<X> exceptionClass) throws X {
    if (cause instanceof Error) {
      throw new ExecutionError((Error) cause);
    }
    if (cause instanceof RuntimeException) {
      throw new UncheckedExecutionException(cause);
    }
    throw newWithCause(exceptionClass, cause);
  }

  /*

                .build();
    }

    /**
     * Creates a new builder for constructing a ProjectBuilderRequest.
     *
     * @return a new ProjectBuilderRequestBuilder
     */
    @Nonnull
    static ProjectBuilderRequestBuilder builder() {
        return new ProjectBuilderRequestBuilder();
    }

    /**
     * Builder for creating ProjectBuilderRequest instances.

    TestService service = new TestService();
    assertEquals(0, service.startUpCalled);
    service.startAsync().awaitRunning();
    assertEquals(1, service.startUpCalled);
    assertEquals(Service.State.RUNNING, service.state());
    assertThat(service.transitionStates).containsExactly(Service.State.STARTING);
  }

  public void testStart_failed() {
    Exception exception = new Exception("deliberate");

        long t;

        return switch (enc) {
        case TIME_1970_SEC_32BE -> new Date(dec_uint32be(src, si) * 1000L);
        case TIME_1970_SEC_32LE -> new Date(dec_uint32le(src, si) * 1000L);
        case TIME_1904_SEC_32BE -> new Date(((dec_uint32be(src, si) & 0xFFFFFFFFL) - SEC_BETWEEEN_1904_AND_1970) * 1000L);
        case TIME_1904_SEC_32LE -> new Date(((dec_uint32le(src, si) & 0xFFFFFFFFL) - SEC_BETWEEEN_1904_AND_1970) * 1000L);

        SmbCircuitBreaker backpressureCircuitBreaker = new SmbCircuitBreaker("backpressure-test", 5, 2, 1000, 3, false, true, 2);

        try {
            CountDownLatch startLatch = new CountDownLatch(1);
            CountDownLatch completeLatch = new CountDownLatch(5);
            AtomicInteger rejectedCount = new AtomicInteger(0);
            AtomicInteger successCount = new AtomicInteger(0);

    checkNotNull(file);
    checkNotNull(charset);
    return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset));
  }

  /**
   * Returns a new {@link ByteSource} for reading bytes from the given file.
   *
   * @since 14.0
   */
  public static ByteSource asByteSource(File file) {
    return new FileByteSource(file);
  }

  private static final class FileByteSource extends

        FavoriteLogCQ cq = new FavoriteLogCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            FavoriteLogCA ca = new FavoriteLogCA();
            aggsLambda.callback(ca);

		throw new Error("globalThis.TextDecoder is not available, polyfill required");
	}

	const encoder = new TextEncoder("utf-8");
	const decoder = new TextDecoder("utf-8");

	globalThis.Go = class {
		constructor() {
			this.argv = ["js"];
			this.env = {};
			this.exit = (code) => {
				if (code !== 0) {
					console.warn("exit code:", code);
				}
			};
			this._exitPromise = new Promise((resolve) => {