which might be interesting to read and for further discussion.

Getting Started
---------------

+ Make sure you have a [GitHub account](https://github.com/signup/free).
+ If you're planning to implement a new feature, it makes sense to discuss your changes
  on the [dev list](https://maven.apache.org/mailing-lists.html) first.
  This way you can make sure you're not wasting your time on something that isn't
  considered to be in Apache Maven's scope.

MockWebServer
=============

A scriptable web server for testing HTTP clients


### Motivation

This library makes it easy to test that your app Does The Right Thing when it
makes HTTP and HTTPS calls. It lets you specify which responses to return and
then verify that requests were made as expected.

Because it exercises your full HTTP stack, you can be confident that you're

          <name>threadSafe</name>
          <version>1.0.0/1.1.0</version>
          <type>boolean</type>
          <description>
            Marks this Mojo as being thread-safe, i.e. the Mojo safely supports concurrent execution during parallel
            builds. Mojos without this annotation will make Maven output a warning when used during a parallel build
            session.
            @since Maven 3.0.
          </description>

   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      LinkedHashMultimap<K, V> create(int expectedKeys, int expectedValuesPerKey) {
    return new LinkedHashMultimap<>(
        Maps.capacity(expectedKeys), Maps.capacity(expectedValuesPerKey));
  }

  /**
   * Constructs a {@code LinkedHashMultimap} with the same mappings as the specified multimap. If a

		// not be required but makes reproduction much easier.
		nsLk.lockMapMutex.Lock()

		// lk3 blocks.
		lk3ch := make(chan bool)
		go func() {
			lk3ch <- nsLk.lock(ctx, "volume", "path", "source", "opsID", false, 0)
		}()

		// lk4, blocks.
		lk4ch := make(chan bool)
		go func() {
			lk4ch <- nsLk.lock(ctx, "volume", "path", "source", "opsID", false, 0)

`@ExperimentalOkHttpApi`. You can safely use this release in production.

 *  Fix: Attempt to read the response even if sending the request failed. This makes it possible
    to handle response statuses like `HTTP/1.1 431 "Request Header Fields Too Large`.

 *  Fix: Handle multiple 1xx responses.

If there's a security flaw in your code, it will still exist.

			continue
		}
		if existingValues, found := args[key]; found {
			args[key] = append(existingValues, values...)
		} else {
			args[key] = values
		}
	}

	cloneURLValues := make(url.Values, len(r.Form))
	maps.Copy(cloneURLValues, r.Form)

	for _, objLock := range []string{
		xhttp.AmzObjectLockMode,
		xhttp.AmzObjectLockLegalHold,
		xhttp.AmzObjectLockRetainUntilDate,
	} {

func (s *peerRESTServer) ConsoleLogHandler(ctx context.Context, params *grid.MSS, out chan<- *grid.Bytes) *grid.RemoteErr {
	mask, err := strconv.Atoi(params.Get(peerRESTLogMask))
	if err != nil {
		mask = int(madmin.LogMaskAll)
	}
	ch := make(chan log.Info, 1000)
	err = globalConsoleSys.Subscribe(ch, ctx.Done(), "", 0, madmin.LogMask(mask), nil)
	if err != nil {
		return grid.NewRemoteErr(err)
	}
	var buf bytes.Buffer

     *
     * - a call that consults a chain of maps, as in `mapA.getOrDefault(key, mapB.getOrDefault(key,
     *   ...))`
     *
     * So it makes sense for the parameter (and thus the return type) to be @Nullable.
     *
     * Two other points:
     *
     * 1. We'll want to use something like @PolyNull once we can make that work for the various
     * platforms we target.
     *