}

    @Test
    public void testCircuitResetsAfterTimeout() throws Exception {
        // Open the circuit
        circuitBreaker.trip();
        assertEquals(State.OPEN, circuitBreaker.getState(), "Circuit should be OPEN");

        // Wait for reset timeout
        Thread.sleep(1100);

    /**
     * Create a circuit breaker with default settings
     *
     * @param name circuit breaker name for logging
     */
    public SmbCircuitBreaker(String name) {
        this(name, 5, 3, 60000, 3, false, false, 100);
    }

    /**
     * Create a circuit breaker with custom settings
     *
     * @param name circuit breaker name for logging

    /**
     * Creates a simple circuit breaker with default settings
     *
     * @param name the circuit breaker name
     */
    public SimpleCircuitBreaker(String name) {
        this(name, 5, 3, 30000L); // 5 failures, 3 successes, 30 second timeout
    }

    /**
     * Creates a simple circuit breaker
     *
     * @param name the circuit breaker name

    }

    @Test
    @DisplayName("Test circuit closes after success threshold in HALF_OPEN")
    void testCircuitClosesAfterSuccessThreshold() throws Exception {
        // Open the circuit
        circuitBreaker.tripBreaker();

        // Wait for timeout
        Thread.sleep(150);

        // Two successful calls should close the circuit
        circuitBreaker.call(() -> "success1");

            when(mockFile.getType()).thenReturn(SmbConstants.TYPE_FILESYSTEM);

            // Capture the ReadAndX request; throw to short-circuit network
            doAnswer(inv -> {
                throw new SmbException("short-circuit");
            }).when(mockTree)
                    .send(any(jcifs.internal.CommonServerMessageBlockRequest.class),

        void testNoMicCalculationWhenIntegrityUnsupported() throws Exception {
            // Only stub supportsIntegrity - isEstablished won't be called due to short-circuit
            when(mockCtx.supportsIntegrity()).thenReturn(false);

            // A small consumer that only uses MIC if advertised as available
            byte[] data = new byte[] { 1, 2 };

    /** Native LAN manager name */
    String NATIVE_LANMAN = Config.getProperty("jcifs.smb1.smb.client.nativeLanMan", "jCIFS");
    /** Virtual circuit number */
    int VC_NUMBER = 1;
    /** Null transport instance */
    SmbTransport NULL_TRANSPORT = new SmbTransport(null, 0, null, 0);

}

func lcp(strs []string, pre bool) string {
	// short-circuit empty list
	if len(strs) == 0 {
		return ""
	}
	xfix := strs[0]
	// short-circuit single-element list
	if len(strs) == 1 {
		return xfix
	}
	// compare first to rest
	for _, str := range strs[1:] {
		xfixl := len(xfix)
		strl := len(str)
		// short-circuit empty strings
		if xfixl == 0 || strl == 0 {
			return ""
		}

     *
     * @return socket timeout for netbios connections, in milliseconds
     */
    int getNetbiosSoTimeout();

    /**
     * Gets the virtual circuit number for SMB connections
     *
     * @return virtual circuit number to use
     */
    int getVcNumber();

    /**
     *
     * Property {@code jcifs.smb.client.capabilities} (int)
     *
     * @return custom capabilities

        assertFalse(result);
        assertEquals(1, chain1.changePasswordCallCount);
        assertEquals(1, chain2.changePasswordCallCount);
        // allMatch may short-circuit, so chain3 might not be called
        assertTrue(chain3.changePasswordCallCount <= 1);
    }

    // Test delete with no chains
    public void test_delete_noChains() {