assertTrue(ALWAYSACTIVE.accept(mockFile));
        }
    }

    @Nested
    @DisplayName("Invalid input – null file handling")
    class InvalidPath {
        @Test
        void acceptWithNullThrows() {
            SmbFileFilter throwOnNull = new SmbFileFilter() {
                @Override
                public boolean accept(SmbFile file) throws SmbException {

        when(mockConfig.isDfsDisabled()).thenReturn(false);
        DfsReferralData mockReferralData = mock(DfsReferralData.class);
        assertDoesNotThrow(() -> dfsResolver.cache(mockContext, "invalidPath", mockReferralData));
    }

        DfsReferralDataInternal mockReferral = mock(DfsReferralDataInternal.class);
        // Should not throw any exception.
        assertDoesNotThrow(() -> dfsImpl.cache(mockContext, "invalidpath", mockReferral));
    }

    @Test
    void testCache_ValidPath() {
        // Scenario: A valid referral is cached.
        DfsReferralDataInternal mockReferral = mock(DfsReferralDataInternal.class);

        }
    }

    public void test_writeThreadDump_withInvalidPath() {
        // Test with invalid file path (directory that doesn't exist)
        String invalidPath = "/nonexistent/directory/thread-dump.txt";

        try {
            ThreadDumpUtil.writeThreadDump(invalidPath);
            // Should not throw exception but log warning
        } catch (Exception e) {

            if ((newState & Smb2LeaseState.SMB2_LEASE_READ_CACHING) == 0) {
                // Lost read cache - invalidate directory cache
                entry.invalidate();
            }
        } else {
            // Lease completely broken - invalidate cache
            entry.invalidate();
        }

        if ((newState & Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING) == 0) {

        
        // Invalidate affected cache entries
        DirectoryCacheEntry entry = leaseManager.getCacheEntry(directoryPath);
        if (entry != null) {
            entry.removeChild(fileName);
            
            // If too many inconsistencies, invalidate entire cache
            if (entry.getInconsistencyCount() > 5) {
                entry.invalidate();
            }
        }
    }

     */
    public boolean isValid() {
        return valid;
    }

    /**
     * Invalidate this memory region
     *
     * After invalidation, the region cannot be used for RDMA operations.
     */
    public abstract void invalidate();

    /**
     * Generate local key for this memory region
     *
     * @return local key
     */

                    this.currentHash = newHash.clone();
                }
            }
        }

        public boolean isValid() {
            return isValid;
        }

        public void invalidate() {
            this.isValid = false;
            // Clear sensitive data
            synchronized (hashLock) {
                Arrays.fill(currentHash, (byte) 0);
            }
        }
    }

        assertEquals("<%= a", AdminDesignAction.decodeJsp("<%= a"));
        assertEquals("<% try{ %>", AdminDesignAction.decodeJsp("<!--TRY-->"));
        assertEquals("<% }catch(Exception e){session.invalidate();} %>",
                AdminDesignAction.decodeJsp("<!--CACHE_AND_SESSION_INVALIDATE-->"));
        assertEquals("&lt;% a %&gt; %>", AdminDesignAction.decodeJsp("<% a %> %>"));

  override fun getCreationTime(): Long = delegate!!.creationTime

  override fun getLastAccessedTime(): Long = delegate!!.lastAccessedTime

  override fun invalidate() {
    delegate!!.invalidate()
  }

  override fun isValid(): Boolean = delegate!!.isValid

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }