assertTrue(transport.isSMB2());
        assertFalse(transport.isSMB2());
        verify(transport, times(2)).isSMB2();

        doThrow(new SmbException("query failed")).when(transport).isSMB2();
        assertThrows(SmbException.class, () -> transport.isSMB2());
        verify(transport, times(3)).isSMB2();
    }

    // Inflight requests count including edge values
    @ParameterizedTest

	statsTime           time.Time
	rttMsSum, maxRttMs  float64
	successRequestCount int64
	failedRequestCount  int64
}

type metrics struct {
	sync.Mutex
	LastCheckSuccess time.Time
	LastCheckFailure time.Time
	lastFullMinute   serviceRTTMinuteStats
	currentMinute    serviceRTTMinuteStats
}

func (h *metrics) setConnSuccess(reqStartTime time.Time) {
	h.Lock()
	defer h.Unlock()

		offset = 0
	}
	return time.FixedZone("", int(offset/time.Second))
}

// msDosTimeToTime converts an MS-DOS date and time into a time.Time.
// The resolution is 2s.
// See: https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
func msDosTimeToTime(dosDate, dosTime uint16) time.Time {
	return time.Date(

### Build session state

A "build session" represents a single invocation of Gradle, for example when you run `gradlew build`.
A session runs the build one or more times.
For example, when continuous build is enabled, the session may run the build many times, but when it is disabled, the session will run the build once only.

The build session state is managed by the `BuildSessionState` class.

        // Act
        pipe.customizeCreate(req, resp);

        // Assert: verify interactions with dependencies
        verify(req, times(1)).addFlags0(0x16);
        verify(resp, times(1)).setExtended(true);
        verify(resp, never()).setExtended(false);
    }

    @Test
    @DisplayName("openPipe returns a handle bound to this pipe")

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import java.io.IOException;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;

	}

	if parentUser == "" {
		return auth.Credentials{}, time.Time{}, errInvalidArgument
	}

	if len(opts.accessKey) > 0 && len(opts.secretKey) == 0 {
		return auth.Credentials{}, time.Time{}, auth.ErrNoSecretKeyWithAccessKey
	}
	if len(opts.secretKey) > 0 && len(opts.accessKey) == 0 {
		return auth.Credentials{}, time.Time{}, auth.ErrNoAccessKeyWithSecretKey
	}

   * scheduled. If the task is already in the queue, the earliest execution time is used.
   *
   * The target execution time is implemented on a best-effort basis. If another task in this queue
   * is running when that time is reached, that task is allowed to complete before this task is
   * started. Similarly the task will be delayed if the host lacks compute resources.
   *

        // getConfig() is called twice: once in Kerb5Authenticator and once in NtlmPasswordAuthenticator
        verify(tc, times(2)).getConfig();
        verify(config, times(1)).isAllowNTLMFallback();
        verify(config, times(1)).isUseRawNTLM();
    }

    @Test
    @DisplayName("refresh: throws unsupported operation")
    void refresh_throwsUnsupported() {

    }

    /**
     * Gets the total execution time for the search request in milliseconds.
     *
     * @return the execution time in milliseconds
     */
    public long getExecTime() {
        return execTime;
    }

    /**
     * Sets the total execution time for the search request in milliseconds.
     *
     * @param execTime the execution time in milliseconds
     */