Set<E> elementSet = getMultiset().elementSet();
    assertTrue(elementSet.remove(e0()));
    assertEmpty(getMultiset());
    assertEquals(expectedSize, getMultiset().size());
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testElementSetRemoveAbsent() {
    Set<E> elementSet = getMultiset().elementSet();
    assertFalse(elementSet.remove(e3()));
    expectUnchanged();
  }

``MinIO`` uses `go mod` to manage its dependencies.

- Run `go get foo/bar` in the source folder to add the dependency to `go.mod` file.

To remove a dependency

- Edit your code and remove the import reference.
- Run `go mod tidy` in the source folder to remove dependency from `go.mod` file.

### What are the coding guidelines for MinIO?

    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
      uses: github/codeql-action/autobuild@v1

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl

    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines

     * @see java.lang.AutoCloseable#close()
     */
    @Override
    public void close() throws CIFSException {
        this.delegate.close();
    }

    @Override
    public void remove() {
        this.delegate.remove();
    }

    assertThat(allCipherSuites.equals(null)).isFalse()
    assertThat(set.remove(ConnectionSpec.MODERN_TLS)).isTrue()
    assertThat(set.remove(ConnectionSpec.COMPATIBLE_TLS))
      .isTrue()
    assertThat(set.remove(ConnectionSpec.CLEARTEXT)).isTrue()
    assertThat(set.remove(allTlsVersions)).isTrue()
    assertThat(set.remove(allCipherSuites)).isTrue()
    assertThat(set).isEmpty()
    allTlsVersions.hashCode()

                return p;
            }
        }
        return null;
    }

    /**
     * Remove all occurances of the given type
     *
     * @param pairs the list of AV pairs to modify
     * @param type the AV pair type to remove
     */
    public static void remove(final List<AvPair> pairs, final int type) {
        final Iterator<AvPair> it = pairs.iterator();
        while (it.hasNext()) {

   * if there is no such edge.
   */
  @Nullable V value(N node);

  /** Remove {@code node} from the set of predecessors. */
  void removePredecessor(N node);

  /**
   * Remove {@code node} from the set of successors. Returns the value previously associated with
   * the edge connecting the two nodes.
   */
  @CanIgnoreReturnValue

  @Override
  public @Nullable V putIfAbsent(K key, V value) {
    return delegate().putIfAbsent(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@Nullable Object key, @Nullable Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V replace(K key, V value) {
    return delegate().replace(key, value);
  }

	if err != nil {
		log.Fatalln(err)
	}

	opts := madmin.HealOpts{
		Recursive: true,                  // recursively heal all objects at 'prefix'
		Remove:    true,                  // remove content that has lost quorum and not recoverable
		ScanMode:  madmin.HealNormalScan, // by default do not do 'deep' scanning
	}

        return delegate().iterator();
      }

      @Override
      public int size() {
        return delegate().size();
      }

      @Override
      public boolean remove(Object o) {
        return delegate().remove(o);
      }

      @Override
      public void clear() {
        delegate().clear();
      }
    };
  }

  @Override
  public @Nullable Entry<K, V> firstEntry() {