on:
  pull_request:
    branches:
      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  build:
    name: Build Tests with Go ${{ matrix.go-version }} on ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:

on:
  pull_request:
    branches:
      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  build:
    name: Go ${{ matrix.go-version }} on ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:

        auto_error: Annotated[
            bool,
            Doc(
                """
                By default, if the query parameter is not provided, `APIKeyQuery` will
                automatically cancel the request and send the client an error.

                If `auto_error` is set to `False`, when the query parameter is not
                available, instead of erroring out, the dependency result will be

// are consistent with each other.
func TestListOnlineDisks(t *testing.T) {
	if runtime.GOOS == globalWindowsOSName {
		t.Skip()
	}

	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, disks, err := prepareErasure16(ctx)
	if err != nil {
		t.Fatalf("Prepare Erasure backend failed - %v", err)
	}
	setObjectLayer(obj)
	defer obj.Shutdown(t.Context())

      super.addListener(listener, executor);
    }

    @CanIgnoreReturnValue
    @Override
    public final boolean cancel(boolean mayInterruptIfRunning) {
      return super.cancel(mayInterruptIfRunning);
    }
  }

  FluentFuture() {}

  /**
   * Converts the given {@code ListenableFuture} to an equivalent {@code FluentFuture}.
   *

          webSocketCloseTimeout,
        ).apply {
          if (client) {
            call =
              object : FailingCall() {
                override fun cancel() {
                  this@TestStreams.cancel()
                }
              }
          }
        }
      webSocket!!.initReaderAndWriter(name, this, client)
    }

    /**

   * of {@link CombinedFuture}, the user-supplied callback usually has its own references to inputs.
   */
  /*
   * In certain circumstances, this field might theoretically not be visible to an afterDone() call
   * triggered by cancel(). For details, see the comments on the fields of TimeoutFuture.
   */
  @LazyInit
  private @Nullable ImmutableCollection<? extends ListenableFuture<? extends InputT>> futures;

  private final boolean allMustSucceed;

		return listener, listenErrs
	}
	listeners = slices.Clip(listeners)

	ctx, cancel := context.WithCancel(ctx)
	listener = &httpListener{
		listeners:   listeners,
		acceptCh:    make(chan acceptResult, len(listeners)),
		opts:        opts,
		ctxDoneCh:   ctx.Done(),
		ctxCanceler: cancel,
	}
	opts.Trace(fmt.Sprintf("opening %d listeners", len(listener.listeners)))
	listener.start()

on:
  pull_request:
    branches:
      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  build:
    name: Go ${{ matrix.go-version }} on ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:

 */
package okhttp3

import okio.IOException

/**
 * Returns the trailers that follow an HTTP response, blocking if they aren't ready yet.
 * Implementations of this interface should respond to [Call.cancel] by immediately throwing an
 * [IOException].
 *
 * Most callers won't need this interface, and should use [Response.trailers] instead.
 *