) = apply {
      headers.add(name, value)
    }

    /** Removes all headers named [name] on this builder. */
    open fun removeHeader(name: String) =
      apply {
        headers.removeAll(name)
      }

    /** Removes all headers on this builder and adds [headers]. */
    open fun headers(headers: Headers) =
      apply {
        this.headers = headers.newBuilder()
      }

				w := xioutil.NewDeadlineWorker(globalDriveConfig.GetMaxTimeout())
				return w.Run(func() error {
					wait := deleteCleanupSleeper.Timer(ctx)
					removeAll(pathJoin(drivePath, minioMetaTmpDeletedBucket, ddir))
					wait()
					return nil
				})
			})
		}(disk)
	}
	wg.Wait()
}

                        mapping.setLabelTypeId(id);
                        newList.add(mapping);
                    }
                }
                list.removeAll(matchedList);
                elevateWordToLabelBhv.batchInsert(newList, op -> {
                    op.setRefreshPolicy(Constants.TRUE);
                });
                elevateWordToLabelBhv.batchDelete(list, op -> {

          }
        };
      }

      @Override
      public Collection<V> values() {
        return new Maps.Values<Range<K>, V>(this) {
          @Override
          public boolean removeAll(Collection<?> c) {
            return removeEntryIf(compose(in(c), Maps.<V>valueFunction()));
          }

          @Override
          public boolean retainAll(Collection<?> c) {

func (testServer TestServer) Stop() {
	testServer.cancel()
	testServer.Server.Close()
	testServer.Obj.Shutdown(context.Background())
	os.RemoveAll(testServer.Root)
	for _, ep := range testServer.Disks {
		for _, disk := range ep.Endpoints {
			os.RemoveAll(disk.Path)
		}
	}
}

// Truncate request to simulate unexpected EOF for a request signed using streaming signature v4.

    }
    if (!derivedFeatures.contains(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
      derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
    }
    derivedFeatures.removeAll(GET_FEATURE_MAP.keySet());
    return derivedFeatures;
  }

  Set<Feature<?>> computeMultimapAsMapGetFeatures(Set<Feature<?>> multimapFeatures) {

)

func TestCheckValid(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	objLayer, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
		t.Fatalf("unable initialize config file, %s", err)
	}

	initAllSubsystems(ctx)
	initConfigSubsystem(ctx, objLayer)

    ) = apply {
      headers.add(name, value)
    }

    /** Removes all headers named [name] on this builder. */
    open fun removeHeader(name: String) =
      apply {
        headers.removeAll(name)
      }

    /** Removes all headers on this builder and adds [headers]. */
    open fun headers(headers: Headers) =
      apply {
        this.headers = headers.newBuilder()
      }

    /**

        removeHeader(name)
        addHeader(name, value)
      }

    /** Removes all headers named [name]. */
    public fun removeHeader(name: String): Builder =
      apply {
        headers_.removeAll(name)
      }

    public fun body(body: Buffer): Builder = body(body.toMockResponseBody())

    public fun body(body: MockResponseBody): Builder =
      apply {

   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean removeAll(Collection<?> oldElements) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the collection unmodified.
   *