UndoWrite bool `msg:"u"`
	// OldDataDir of the previous object
	OldDataDir string `msg:"o,omitempty"` // old data dir used only when to revert a rename()
}

// BaseOptions represents common options for all Storage API calls
type BaseOptions struct{}

// RenameOptions represents rename API options, currently its same as BaseOptions
type RenameOptions struct {
	BaseOptions
}

// DiskInfoOptions options for requesting custom results.

| `minio_system_network_internode_dial_errors_total`   | Total number of internode TCP dial timeouts and errors. <br><br>Type: counter | `server`, `pool_index` |
| `minio_system_network_internode_dial_avg_time_nanos` | Average dial time of internodes TCP calls in nanoseconds. <br><br>Type: gauge | `server`, `pool_index` |

You probably want to test the external provider once, but not necessarily call it for every test that runs.

In this case, you can override the dependency that calls that provider, and use a custom dependency that returns a mock user, only for your tests.

### Use the `app.dependency_overrides` attribute { #use-the-app-dependency-overrides-attribute }

    val request2 = Request.Builder().url(server.url("/")).build()
    val response2 = client.newCall(request2).execute()
    assertThat(response2.body.string()).isEqualTo("def")

    // The HTTP calls should share a single connection.
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun proxySelector() {
    server.enqueue(MockResponse.Builder().body("abc").build())

    void getConfig_returnsConfig() {
        SmbTreeConnection c = newConn();
        assertSame(config, c.getConfig());
    }

    @Test
    @DisplayName("acquire calls tree.acquire on first usage, release calls tree.release at zero")
    void acquire_release_lifecycle() {
        SmbTreeConnection c = newConn();
        SmbTreeImpl tree = mock(SmbTreeImpl.class);

  }

  /*
   * Our implementation works fine with a null `dir`. However, there's nothing in the documentation
   * of the supertype that suggests that implementations are expected to tolerate null. That said, I
   * see calls in Google code that pass a null `dir` to a FilenameFilter.... So let's declare the
   * parameter as non-nullable (since passing null to a FilenameFilter is unsafe in general), but if

   * suggested that listeners are added before the service starts.
   *
   * <p>{@code addListener} guarantees execution ordering across calls to a given listener but not
   * across calls to multiple listeners. Specifically, a given listener will have its callbacks
   * invoked in the same order as the underlying service enters those states. Additionally, at most

    }

    @Test
    @DisplayName("Test multiple sequential calls to read/write methods")
    void testMultipleSequentialCalls() {
        byte[] buffer = new byte[200];

        // Multiple calls should each return 0
        for (int i = 0; i < 10; i++) {
            assertEquals(0, response.writeSetupWireFormat(buffer, i * 10));

import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import org.jspecify.annotations.Nullable;

/**
 * A navigable map which forwards all its method calls to another navigable map. Subclasses should
 * override one or more methods to modify the behavior of the backing map as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

import java.util.NoSuchElementException;
import java.util.SortedMap;
import java.util.function.BiFunction;
import org.jspecify.annotations.Nullable;

/**
 * A navigable map which forwards all its method calls to another navigable map. Subclasses should
 * override one or more methods to modify the behavior of the backing map as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *