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

	vn := localLockMap{}
	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 BenchmarkEncodelocalLockMap(b *testing.B) {
	v := localLockMap{}
	var buf bytes.Buffer

    }

    /**
     * Test that pre-auth hash is reset on error
     */
    @Test
    @DisplayName("Pre-auth integrity hash should reset on error")
    void testPreauthHashResetOnError() throws Exception {
        // Setup invalid SMB2 state to trigger error
        setPrivateField(transport, "smb2", false);

        // Try to update preauth hash - should fail and reset

    }

    @Test
    void testResetAndReuse() {
        // Test that HMACT64 can be reset and reused
        HMACT64 hmac = new HMACT64(TEST_KEY);

        // First use
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        byte[] result1 = hmac.engineDigest();

        // Reset and reuse with same data
        hmac.engineReset();
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

        assertTrue(response.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset method")
    void testReset() {
        // Set some values
        response.setDataCount(50);

        // Call reset
        response.reset();

        // After reset, hasMore should be true
        assertTrue(response.hasMoreElements());
    }

    @Test

		echo \"Failed attempts: $ATTEMPTS\"
		if [ $ATTEMPTS -gt $LIMIT ]; then
			exit 1
		fi
		sleep 2 # 1 second intervals between attempts
		$MC_COMMAND
		STATUS=$?
	done
	set -e # reset `e` as active
	return 0
}

# checkBucketExists ($bucket)
# Check if the bucket exists, by using the exit code of `mc ls`
checkBucketExists() {
	BUCKET=$1
	CMD=$(${MC} stat myminio/$BUCKET >/dev/null 2>&1)

    @Mock
    private CommonServerMessageBlock disconnectRequest;

    @Mock
    private CommonServerMessageBlockRequest nextRequest;

    @BeforeEach
    void setUp() {
        // Reset mocks before each test
        reset(request, response, context, disconnectRequest, nextRequest);
    }

    @Test
    @DisplayName("Test initResponse returns initialized response")
    void testInitResponse() {
        // Given

        try {
            activeRequests.incrementAndGet();

            State currentState = state.get();

            // Check if we should attempt reset
            if (currentState == State.OPEN && shouldAttemptReset()) {
                log.debug("[{}] Attempting to reset circuit breaker from OPEN to HALF_OPEN", name);
                transitionTo(State.HALF_OPEN);
                currentState = State.HALF_OPEN;
            }

async def set_up_request_state_dependency():
    request_state = {"user": "deadpond"}
    contextvar_token = legacy_request_state_context_var.set(request_state)
    yield request_state
    legacy_request_state_context_var.reset(contextvar_token)


@app.middleware("http")
async def custom_middleware(
    request: Request, call_next: Callable[[Request], Awaitable[Response]]
):
    response = await call_next(request)

    b.limit(limit);
  }

  static void mark(Buffer b) {
    b.mark();
  }

  static void position(Buffer b, int position) {
    b.position(position);
  }

  static void reset(Buffer b) {
    b.reset();
  }

  private Java8Compatibility() {}

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

	vn := RStat{}
	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 BenchmarkEncodeRStat(b *testing.B) {
	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)