@DisplayName("openConnection returns SmbFile using provided CIFSContext")
    void testOpenConnection_UsesProvidedContext() throws MalformedURLException, IOException {
        // Arrange
        when(mockCtx.getConfig()).thenReturn(mockCfg);
        when(mockCfg.isTraceResourceUsage()).thenReturn(false);

        Handler handler = newHandlerWith(mockCtx);
        URL url = new URL(null, "smb://example-host/share/", new Handler());

        // Act

     */
    private var expires: Date? = null

    /**
     * Extension header set by OkHttp specifying the timestamp when the cached HTTP request was
     * first initiated.
     */
    private var sentRequestMillis = 0L

    /**
     * Extension header set by OkHttp specifying the timestamp when the cached HTTP response was
     * first received.
     */
    private var receivedResponseMillis = 0L

	"net/http"
)

var (
	// ErrPermission is an error returned by the KMS when it has not
	// enough permissions to perform the operation.
	ErrPermission = Error{
		Code:    http.StatusForbidden,
		APICode: "kms:NotAuthorized",
		Err:     "insufficient permissions to perform KMS operation",
	}

	// ErrKeyExists is an error returned by the KMS when trying to
	// create a key that already exists.
	ErrKeyExists = Error{

    assertTrue(executor.isTerminated());

    otherTask.get();
  }

  /**
   * Test for a bug where threads weren't getting signaled when shutdown was called, only when tasks
   * completed.
   */
  public void testDirectExecutorService_awaitTermination_missedSignal() {
    ExecutorService service = newDirectExecutorService();
    Thread waiter =

	if err != nil {
		fmt.Printf("error when create private.pem: %s n", err)
		os.Exit(1)
	}
	err = pem.Encode(privatePem, privateKeyBlock)
	if err != nil {
		fmt.Printf("error when encode private pem: %s n", err)
		os.Exit(1)
	}

	// dump public key to file
	publicKeyBytes := x509.MarshalPKCS1PublicKey(&privatekey.PublicKey)
	if err != nil {
		fmt.Printf("error when dumping publickey: %s n", err)
		os.Exit(1)

        @DisplayName("Should verify signature when digest is present and successful")
        void testVerifySignatureSuccess() throws Exception {
            byte[] buffer = new byte[1024];
            echoResponse.setDigest(mockDigest);
            setStatus(echoResponse, NtStatus.NT_STATUS_SUCCESS);

            when(mockConfig.isRequireSecureNegotiate()).thenReturn(true);

    @BeforeEach
    void setUp() throws Exception {
        when(context.getConfig()).thenReturn(config);
        when(config.isSigningEnforced()).thenReturn(false);
        when(config.getSessionTimeout()).thenReturn(30_000);
        when(config.getResponseTimeout()).thenReturn(5_000);
        when(address.getHostAddress()).thenReturn("127.0.0.1");
        when(address.getHostName()).thenReturn("testhost");

exemptAssignees: false

# Label to use when marking as stale
staleLabel: stale

# Comment to post when marking as stale. Set to `false` to disable
markComment: >-
  This issue has been automatically marked as stale because it has not had
  recent activity. It will be closed after 15 days if no further activity
  occurs. Thank you for your contributions.
# Comment to post when removing the stale label.
# unmarkComment: >

        assertTrue(resp.isLoggedInAsGuest(), "Guest/anonymous should be detected");

        // prepare should propagate session id when received
        CIFSContext mockCtx = mock(CIFSContext.class);
        when(mockCtx.getConfig()).thenReturn(mock(Configuration.class));
        Smb2SessionSetupRequest nextReq = new Smb2SessionSetupRequest(mockCtx, 0, 0, 0L, null);

        SmbFileFilter filter = f -> f.length() > 0;

        // negative size -> reject
        when(smbFile.length()).thenReturn(-1L);
        assertFalse(filter.accept(smbFile), "Negative size should be rejected");
        verify(smbFile, times(1)).length();

        // zero size -> reject
        reset(smbFile);
        when(smbFile.length()).thenReturn(0L);
        assertFalse(filter.accept(smbFile), "Zero size should be rejected");