if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBaseOptions Msgsize() is inaccurate")
	}

	vn := BaseOptions{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBaseOptions(b *testing.B) {
	v := BaseOptions{}
	var buf bytes.Buffer

        }

        // Should have some state
        AuthenticationRateLimiter.RateLimiterStats stats = rateLimiter.getStats();
        assertTrue(stats.getActiveAccounts() > 0);

        // Reset
        rateLimiter.reset();

        // State should be cleared
        stats = rateLimiter.getStats();
        assertEquals(0, stats.getTotalBlocked());
        assertEquals(0, stats.getAccountsLocked());

        verify(mockResponse, times(1)).setExpiration(expiration);
    }

    @Test
    void testReset() {
        // Call the method
        mockResponse.reset();

        // Verify that the method was called
        verify(mockResponse, times(1)).reset();
    }

    @Test
    void testGetException() {
        Exception testException = new RuntimeException("Test Exception");

		panic("bytes.Reader.WriteTo: invalid Write count")
	}
	r.i += int64(m)
	n = int64(m)
	if m != len(b) && err == nil {
		err = io.ErrShortWrite
	}
	return
}

// Reset resets the [Reader] to be reading from b.
func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} }

// NewReader returns a new [Reader] reading from b.

	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecoderebalanceInfo Msgsize() is inaccurate")
	}

	vn := rebalanceInfo{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncoderebalanceInfo(b *testing.B) {
	v := rebalanceInfo{}
	var buf bytes.Buffer

        if (n != null) {
            n.prepare(next);
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#reset()
     */
    @Override
    public void reset() {
        super.reset();
        this.received = false;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#received()
     */
    @Override

    }

    /**
     * Verifies reset() clears flags2 and updates resumeKey and filename used for parameters.
     */
    @Test
    void testResetUpdatesStateAndParameters() {
        // Given
        Trans2FindNext2 next = new Trans2FindNext2(0x0001, 0x0AAA0BBB, "old");
        next.flags2 = 0xFFFF; // simulate non-zero flags2

        // When
        next.reset(0x11121314, "last.dat");

        // Then

    int status;
    int numEntries;
    FileEntry[] results;

    SmbComTransactionResponse() {
        txn_buf = null;
    }

    @Override
    void reset() {
        super.reset();
        bufDataStart = 0;
        isPrimary = hasMore = true;
        parametersDone = dataDone = false;
    }

    @Override
    public boolean hasMoreElements() {

    void close_isNoop() throws Exception {
        // Verify close() is a no-op and does not call handle/tree/fd
        SmbPipeInputStream stream = newStreamWithInit(true);

        // reset to ignore constructor interactions
        reset(handle, tree, fd);

        assertDoesNotThrow(stream::close);
        verify(handle, never()).ensureOpen();
        verifyNoInteractions(tree, fd);
    }

    @Nested

FastAPI will still be able to override it.

///

Then you can reset your overrides (remove them) by setting `app.dependency_overrides` to be an empty `dict`:

```Python
app.dependency_overrides = {}
```

/// tip

If you want to override a dependency only during some tests, you can set the override at the beginning of the test (inside the test function) and reset it at the end (at the end of the test function).