}

    @Test
    @DisplayName("Test isValid returns false for invalid negotiation")
    void testIsValidReturnsFalse() {
        // Arrange
        when(negotiationResponse.isValid(cifsContext, negotiationRequest)).thenReturn(false);

        // Act
        boolean result = negotiationResponse.isValid(cifsContext, negotiationRequest);

        // Assert

        assertTrue(h.isValid());

        // Tree id change makes it invalid
        when(tree.getTreeId()).thenReturn(11L);
        assertFalse(h.isValid());

        // Connected=false makes it invalid
        when(tree.getTreeId()).thenReturn(10L);
        when(tree.isConnected()).thenReturn(false);
        assertFalse(h.isValid());

        // Mark closed makes it invalid

            return false;
        }

        if (!context.isValid()) {
            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

        byte[] actualHash = context.getCurrentHash();
        boolean isValid = MessageDigest.isEqual(actualHash, expectedHash);

        if (isValid) {

    }

    // Ensures watch() fails fast if the underlying handle is invalid
    @Test
    @DisplayName("watch() throws when handle invalid")
    void watch_invalidHandle_throwsSmbException() throws Exception {
        when(handle.isValid()).thenReturn(false);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0, false);

        when(mockFileHandle.isValid()).thenReturn(false);
        assertFalse(outputStream.isOpen());
    }

    @Test
    void testWriteAfterClose() throws IOException, CIFSException {
        // Given
        when(mockTreeHandle.isSMB2()).thenReturn(true);
        when(mockTreeHandle.getSendBufferSize()).thenReturn(65536);
        when(mockFileHandle.isValid()).thenReturn(true);

        // When
        boolean valid = response.isValid(mockContext, mockRequest);

        // Then
        assertTrue(valid);
        assertEquals(DialectVersion.SMB311, response.getSelectedDialect());
    }

    @Test
    @DisplayName("Should fail validation when not received")
    void testIsValidNotReceived() {
        // When
        boolean valid = response.isValid(mockContext, mockRequest);

        // Then

        // Re-prepare state for second branch: not open but handle set
        when(fileHandle.isValid()).thenReturn(false);
        // Need to reopen logic to set handle again
        // Reset open flag by reconstructing target
        target = new SmbPipeHandleImpl(pipe);

        target.ensureOpen(); // handle present but invalid per isValid=false
        target.close();
        verify(fileHandle, atLeastOnce()).release();
    }

            fail("Expected CIFSException");
        } catch (CIFSException e) {
            // Expected
        }

        assertFalse(context.isValid());

        // Further operations on invalid context should fail
        assertThrows(CIFSException.class, () -> {
            preauthService.updatePreauthHash(sessionId, "test".getBytes());
        });
    }

    @Test

			for index, e := range etags {
				if partsMetadata[index].IsValid() && e == etag {
					onlineDisks[index] = disks[index]
				} else {
					onlineDisks[index] = nil
				}
			}
			return onlineDisks, modTime, etag
		}
	}

	// Create a new online disks slice, which have common uuid.
	for index, t := range modTimes {
		if partsMetadata[index].IsValid() && t.Equal(modTime) {
			onlineDisks[index] = disks[index]

        when(fh.acquire()).thenReturn(fh);
        when(fh.isValid()).thenReturn(true, false); // first true, then false

        handle.ensureOpen();
        assertTrue(handle.isOpen());

        // Simulate invalidation
        assertFalse(handle.isOpen(), "Becomes not open when underlying handle invalid");

        // After close, report stale
        handle.close();