throw new SmbException("Account '" + username + "' is locked out until " + account.getLockoutExpiry());
                } else {
                    // Lockout expired, reset
                    account.reset();
                }
            }
        }

        // Check per-IP limit
        if (sourceIp != null) {

        assertEquals(State.OPEN, circuitBreaker.getState(), "Circuit should be OPEN");

        // Manually reset
        circuitBreaker.reset();
        assertEquals(State.CLOSED, circuitBreaker.getState(), "Circuit should be CLOSED after reset");
        assertEquals(0, circuitBreaker.getFailureCount(), "Failure count should be reset");
    }

    @Test
    public void testCustomFailureDetection() throws CIFSException {

            HMACT64 hmac = new HMACT64(TEST_KEY);
            hmac.engineReset();
            verify(mockMd5, times(2)).reset(); // Once in constructor, once in reset
            verify(mockMd5, times(2)).update(any(byte[].class)); // Once in constructor, once in reset
        }
    }

    @Test
    void testEngineGetDigestLength() throws NoSuchAlgorithmException {
        // Test engineGetDigestLength()

		rcfg:         replicationConfig{Config: &configs[0]},
		expectedSync: false,
	},
	{ // 4. existing object replication enabled, versioning enabled; no reset in progress
		name: "existing object replication enabled, versioning enabled; no reset in progress",
		info: ObjectInfo{
			Size:              100,
			ReplicationStatus: replication.Completed,
			VersionID:         "a3348c34-c352-4498-82f0-1098e8b34df9",
		},

        }
    }

    @Test
    @DisplayName("Test reset method")
    void testReset() {
        // Given
        doNothing().when(messageBlock).reset();

        // When
        messageBlock.reset();

        // Then
        verify(messageBlock).reset();
    }

    @Test
    @DisplayName("Test multiple operations in sequence")

    }

    @Test
    @DisplayName("Test reset functionality")
    void testReset() {
        // Reset should not throw exception
        assertDoesNotThrow(() -> transaction.reset());

        // Transaction should be ready for reuse
        assertTrue(transaction.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset with key and lastName")
    void testResetWithKeyAndLastName() {

    }

    @Test
    void testReset() {
        ndrBuffer.advance(100);
        ndrBuffer.setLength(150);
        ndrBuffer.reset();

        // Verify reset state
        assertEquals(0, ndrBuffer.index);
        assertEquals(0, ndrBuffer.length);
        assertSame(ndrBuffer, ndrBuffer.deferred);
    }

    @Test
    void testGetAndSetIndex() {

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

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

		t.Log("WARNING: TestEncodeDecodeBatchJobReplicateCredentials Msgsize() is inaccurate")
	}

	vn := BatchJobReplicateCredentials{}
	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 BenchmarkEncodeBatchJobReplicateCredentials(b *testing.B) {
	v := BatchJobReplicateCredentials{}

        doNothing().when(response).setSessionId(999L);
        response.setSessionId(999L);
        verify(response).setSessionId(999L);

        // Test reset method
        doNothing().when(response).reset();
        response.reset();
        verify(response).reset();
    }

    @Test
    @DisplayName("Test concrete implementation with multiple scenarios")