)

	if err := queueStore.Open(); err != nil {
		return fmt.Errorf("unable to initialize the queue store of %s webhook: %w", h.Name(), err)
	}

	h.store = queueStore
	store.StreamItems(h.store, h, ctx.Done(), h.config.LogOnceIf)

	return nil
}

func (h *Target) initMemoryStore(ctx context.Context) (err error) {
	ctx, cancel := context.WithCancel(ctx)
	h.storeCtxCancel = cancel
	h.lastStarted = time.Now()

			list.currentSendCalls.Add(1)
			list.incCurrentSendCalls(id)
			list.incTotalEvents(id)
			defer list.decCurrentSendCalls(id)
			defer list.currentSendCalls.Add(-1)
			defer wg.Done()

			if err := target.Save(event); err != nil {
				list.eventsErrorsTotal.Add(1)
				list.incFailedEvents(id)
				reqInfo := &logger.ReqInfo{}
				reqInfo.AppendTags("targetID", id.String())

  public void testOf() {
    assertMapEquals(ImmutableMap.of("one", 1), "one", 1);
    assertMapEquals(ImmutableMap.of("one", 1, "two", 2), "one", 1, "two", 2);
    assertMapEquals(
        ImmutableMap.of("one", 1, "two", 2, "three", 3), "one", 1, "two", 2, "three", 3);
    assertMapEquals(
        ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4),
        "one",
        1,
        "two",
        2,
        "three",

/**
 * GWT implementation of {@link ImmutableSet} that forwards to another {@code Set} implementation.
 *
 * @author Hayward Chan
 */
@ElementTypesAreNonnullByDefault
@SuppressWarnings("serial") // Serialization only done in GWT.
public abstract class ForwardingImmutableSet<E> extends ImmutableSet<E> {
  private final transient Set<E> delegate;

  ForwardingImmutableSet(Set<E> delegate) {
    // TODO(cpovirk): are we over-wrapping?

func (w *Watcher) Wait(ctx context.Context) error {
	select {
	case <-w.Events:
		return nil
	case err := <-w.Errors:
		return err
	case <-ctx.Done():
		return ctx.Err()
	}
}

func (w *Watcher) Close() {
	_ = w.watcher.Close()
}

// Creates a file watcher that watches for any changes to the directory

}

func (bs *bootstrapTracer) Publish(ctx context.Context, trace *pubsub.PubSub[madmin.TraceInfo, madmin.TraceType]) {
	for _, bsEvent := range bs.Events() {
		if bsEvent.Message != "" {
			select {
			case <-ctx.Done():
			default:
				trace.Publish(bsEvent)
			}
		}
	}

                }
            ]
        }
    )


def test_get_http_error():
    response = client.get("/items/3")
    assert response.status_code == 418, response.text
    assert response.json() == {"detail": "Nope! I don't like 3."}


def test_get():
    response = client.get("/items/2")
    assert response.status_code == 200, response.text
    assert response.json() == {"item_id": 2}


def test_openapi_schema():

    echo \"Failed attempts: $ATTEMPTS\" ;
    if [ $ATTEMPTS -gt $LIMIT ]; then
      exit 1 ;
    fi ;
    sleep 2 ; # 1 second intervals between attempts
    $MC_COMMAND ;
    STATUS=$? ;
  done ;
  set -e ; # reset `e` as active
  return 0
}

# checkPolicyExists ($policy)
# Check if the policy exists, by using the exit code of `mc admin policy info`
checkPolicyExists() {
  POLICY=$1

	// the locked resource, useful primarily in figuring out stale locks.
	Owner string

	// Source contains the line number, function and file name of the code
	// on the client node that requested the lock.
	Source string `msgp:"omitempty"`

	// Quorum represents the expected quorum for this lock type.
	Quorum *int `msgp:"omitempty"`
}

// ResponseCode is the response code for a locking request.

	xioutil "github.com/minio/minio/internal/ioutil"
)

// DrainBody close non nil response with any response Body.
// convenient wrapper to drain any remaining data on response body.
//
// Subsequently this allows golang http RoundTripper
// to reuse the same connection for future requests.
func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.