return (n & 1) == 0; // isEven()
              }
            }));
    assertEquals(newArrayList("1", "3", "5"), list);
    assertFalse(
        removeIf(
            transformed,
            new Predicate<Integer>() {
              @Override
              public boolean apply(Integer n) {
                return (n & 1) == 0; // isEven()
              }
            }));

                return (n & 1) == 0; // isEven()
              }
            }));
    assertEquals(newArrayList("1", "3", "5"), list);
    assertFalse(
        removeIf(
            transformed,
            new Predicate<Integer>() {
              @Override
              public boolean apply(Integer n) {
                return (n & 1) == 0; // isEven()
              }
            }));

        assertSame(pipe, handle.getPipe());
    }

    @Test
    @DisplayName("isOpen/isStale reflect handle validity and lifecycle")
    void isOpen_isStale_transitions() throws Exception {
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\w");
        assertFalse(handle.isOpen(), "Initially not open");
        assertFalse(handle.isStale(), "Initially not stale");

* MIT License 

        // Initially not open (isStale returns false when handle is null, not true)
        assertFalse(target.isOpen());
        assertFalse(target.isStale());

        // After ensureOpen, handle valid -> open
        SmbFileHandleImpl fh = target.ensureOpen();
        assertSame(fileHandle, fh);
        assertTrue(target.isOpen());
        assertFalse(target.isStale());

        // If handle becomes invalid, reflect stale

     *
     * @return true if the stream is open, false otherwise
     */
    public boolean isOpen() {
        return file.isOpen();
    }

    void ensureOpen() throws IOException {
        // ensure file is open
        if (!file.isOpen()) {
            file.open(openFlags, access | SmbConstants.FILE_WRITE_DATA, SmbFile.ATTR_NORMAL, 0);
            if (append) {

    }

    public String getUncPath() {
        return this.uncPath;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbPipeHandle#isOpen()
     */
    @Override
    public boolean isOpen() {
        return this.open && this.handle != null && this.handle.isValid();
    }

    /**
     *
     * {@inheritDoc}
     *

                SmbConstants.DEFAULT_SHARING);

        // When & Then
        assertTrue(outputStream.isOpen());

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

    @Test
    void testWriteAfterClose() throws IOException, CIFSException {
        // Given

            "four", 4,
            "five", 5,
            "six", 6,
            "seven", 7),
        "one",
        1,
        "two",
        2,
        "three",
        3,
        "four",
        4,
        "five",
        5,
        "six",
        6,
        "seven",
        7);
    assertMapEquals(
        ImmutableBiMap.of(
            "one", 1,

        if (len <= 0) {
            return 0;
        }
        final long start = fp;

        // ensure file is open
        if (!file.isOpen()) {
            file.open(openFlags, 0, SmbFile.ATTR_NORMAL, options);
        }

        int r, n;
        final SmbComReadAndXResponse response = new SmbComReadAndXResponse(b, off);
        do {