multimap.put("e", 55);

    multimap.keySet().tailSet("d").clear();
    assertEquals(ImmutableSet.of("a", "b", "c"), multimap.keySet());
    assertEquals(4, multimap.size());
    assertEquals(4, multimap.values().size());
    assertEquals(4, multimap.keys().size());
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testKeySetBridgeMethods() {
    for (Method m : TreeMultimap.class.getMethods()) {

					}
				}

				if err == nil {
					bgSeq.countHealed(madmin.HealItemObject)
					result = healEntrySuccess(uint64(version.Size))
				} else {
					bgSeq.countFailed(madmin.HealItemObject)
					result = healEntryFailure(uint64(version.Size))
					if version.VersionID != "" {
						healingLogIf(ctx, fmt.Errorf("unable to heal object %s/%s (version-id=%s): %w",

	peerRESTUserType        = "user-type"
	peerRESTIsGroup         = "is-group"
	peerRESTSignal          = "signal"
	peerRESTSubSys          = "sub-sys"
	peerRESTProfiler        = "profiler"
	peerRESTSize            = "size"
	peerRESTConcurrent      = "concurrent"
	peerRESTDuration        = "duration"
	peerRESTStorageClass    = "storage-class"
	peerRESTEnableSha256    = "enableSha256"
	peerRESTEnableMultipart = "enableMultipart"

    this.withLock {
      return busyQueues + readyQueues
    }
  }

  fun cancelAll() {
    assertLockHeld()
    for (i in busyQueues.size - 1 downTo 0) {
      busyQueues[i].cancelAllAndDecide()
    }
    for (i in readyQueues.size - 1 downTo 0) {
      val queue = readyQueues[i]
      queue.cancelAllAndDecide()
      if (queue.futureTasks.isEmpty()) {
        readyQueues.removeAt(i)
      }

        fileStandardInfo.decode(buffer, 0, buffer.length);
        assertEquals(expectedEndOfFile, fileStandardInfo.getSize());
    }

    @Test
    @DisplayName("Test size method returns 22")
    void testSize() {
        assertEquals(22, fileStandardInfo.size());
    }

    @Test
    @DisplayName("Test decode with valid data")
    void testDecodeWithValidData() throws SMBProtocolDecodingException {
        // Prepare test data

* `write(data)`: Escreve `data` (`str` ou `bytes`) no arquivo.
* `read(size)`: Lê `size` (`int`) bytes/caracteres do arquivo.
* `seek(offset)`: Vai para o byte na posição `offset` (`int`) no arquivo.
    * Por exemplo, `await myfile.seek(0)` irá para o início do arquivo.

    nextProxyIndex = 0
    call.eventListener.proxySelectEnd(call, url, proxies)
  }

  /** Returns true if there's another proxy to try. */
  private fun hasNextProxy(): Boolean = nextProxyIndex < proxies.size

  /** Returns the next proxy to try. May be PROXY.NO_PROXY but never null. */
  @Throws(IOException::class)
  private fun nextProxy(): Proxy {
    if (!hasNextProxy()) {
      throw SocketException(

    }

    /**
     * Returns the number of key-value mappings in this map.
     *
     * @return the number of key-value mappings in this map
     */
    @Override
    public int size() {
        return parent.size();
    }

    /**
     * Returns true if this map contains no key-value mappings.
     *
     * @return true if this map contains no key-value mappings
     */
    @Override

          }
        };
    List<String> result = Resources.readLines(resource, US_ASCII, collectAndLowercaseAndTrim);
    assertEquals(3600, result.size());
    assertThat(result.get(0)).isEqualTo("ALICE'S ADVENTURES IN WONDERLAND");
    assertThat(result.get(result.size() - 1)).isEqualTo("THE END");
  }

  public void testCopyToOutputStream() throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();

     */
    private List<MavenProject> applyFilter(
            Collection<? extends MavenProject> projects, boolean transitive, boolean upstream) {
        List<MavenProject> filtered = new ArrayList<>(projects.size());
        for (MavenProject project : projects) {
            if (whiteList.containsKey(project)) {
                filtered.add(project);
            } else if (!transitive) {