verifyNoMoreInteractions(renewable);
    }

    @Test
    @DisplayName("Edge: calling renew() on a null reference throws NPE")
    void renewOnNullReferenceThrowsNPE() {
        // Arrange: null reference to the interface
        SmbRenewableCredentials creds = null;

        // Act + Assert: invoking renew() on null triggers NullPointerException
        assertThrows(NullPointerException.class, () -> {

        // Given - Various invalid buffers
        byte[] nullBuffer = null;
        byte[] wrongSizeBuffer = new byte[100]; // Wrong size
        byte[] correctBuffer = new byte[SmbComTransaction.TRANSACTION_BUF_SIZE];

        // When/Then - Should handle invalid buffers gracefully
        assertDoesNotThrow(() -> {
            BufferCache.releaseBuffer(nullBuffer); // Should ignore null

    @Override
    public void setUp() throws Exception {
        super.setUp();
        responseHeaders = new HashMap<>();
        processCalled = false;
        processOrigin = null;
        processRequest = null;
        processResponse = null;

        // Create a test implementation of CorsHandler
        corsHandler = new CorsHandler() {
            @Override

  private <T extends Iterator<E>> void internalExecuteAndCompare(
      T reference, T target, IteratorOperation method) {
    Object referenceReturnValue = null;
    PermittedMetaException referenceException = null;
    Object targetReturnValue = null;
    Exception targetException = null;

    try {
      targetReturnValue = method.execute(target);
    } catch (Exception e) { // sneaky checked exception
      targetException = e;

     * @param pathMappingList the path mapping list
     */
    public void setPathMappingList(final String sessionId, final List<PathMapping> pathMappingList) {
        if (sessionId != null) {
            if (pathMappingList != null) {
                pathMappingMap.put(sessionId, pathMappingList);
            } else {
                removePathMappingList(sessionId);
            }
        }
    }

    /**

                    return e;
                }
            }

            return null;
        }

        @SuppressWarnings({"unchecked", "checkstyle:methodlength"})
        private void traverseObjectWithParents(Class<?> cls, Object target) throws ModelInterpolationException {
            if (cls == null) {
                return;
            }

            if (cls.isArray()) {

        @Override
        public Path getPath() {
            return null;
        }

        @Override
        public Source resolve(String relative) {
            return null;
        }

        @Override
        @Nullable
        public ModelSource resolve(@Nonnull ModelLocator modelLocator, @Nonnull String relative) {
            return null;
        }
    }

    /**

            long id = 0;
            String line = null;
            while ((line = reader.readLine()) != null) {
                if (line.length() == 0 || line.charAt(0) == '#') {
                    if (updater != null) {
                        updater.write(line);
                    }
                    continue; // ignore empty lines and comments

        byte[] encrypted = storage.encryptCredentials(null);
        assertNull(encrypted, "Encrypting null should return null");

        char[] decrypted = storage.decryptCredentials(null);
        assertNull(decrypted, "Decrypting null should return null");
    }

    @Test
    public void testEncryptDecryptLongPassword() throws Exception {
        // Test with very long password

     * @return the embedded file, or null if not found
     */
    protected PDEmbeddedFile getEmbeddedFile(final PDComplexFileSpecification fileSpec) {
        // search for the first available alternative of the embedded file
        PDEmbeddedFile embeddedFile = null;
        if (fileSpec != null) {
            embeddedFile = fileSpec.getEmbeddedFileUnicode();
            if (embeddedFile == null) {