this.writeSize = Math.min(th.getConfig().getSendBufferSize() - 70, 0xFFFF - 70);
            }

            this.fp = 0L;
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @return
     * @throws SmbException
     */

     */
    public static MessageDigest getInstance(final String algorithm) {
        assertArgumentNotEmpty("algorithm", algorithm);

        try {
            return MessageDigest.getInstance(algorithm);
        } catch (final NoSuchAlgorithmException e) {
            throw new NoSuchAlgorithmRuntimeException(e);
        }
    }

    /**
     * Hashes the specified text using the given algorithm and converts it to a string.
     *

        try {
            return asJson(new ApiResult.ApiStorageResponse().items(list).status(ApiResult.Status.OK).result());
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug(e.getMessage(), e);
            }

                return listFilesWithDirectoryLeasing(smbFile, dirManager);
            } else {
                // Fall back to regular directory listing
                return smbFile.listFiles();
            }
        } catch (CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * Enhanced exists method that uses directory leasing for parent directory caching
     *

                    try {
                        Class<?> handlerClass = null;
                        try {
                            handlerClass = Class.forName(className);
                        } catch (final Exception ex) {
                            log.debug("Failed to load handler class " + className, ex);
                        }
                        if (handlerClass == null) {

                        }
                        in.close();
                    }
                } catch (final IOException ioe) {
                    logger.error("I/O error occurred: {}", ioe.getMessage(), ioe);
                }

            }
        } catch (final Exception e) {
            logger.error("Error in test execution", e);
        } finally {
            numComplete++;
        }

        assertArgumentNotNull("field", field);

        try {
            field.set(target, value);
        } catch (final IllegalAccessException e) {
            throw new IllegalAccessRuntimeException(field.getDeclaringClass(), e);
        } catch (final IllegalArgumentException e) {
            final Class<?> clazz = field.getDeclaringClass();
            final Class<?> fieldClass = field.getType();

        body.crudMode = CrudMode.CREATE;
        final RelatedQuery relatedQuery = getRelatedQuery(body).map(entity -> {
            try {
                relatedQueryService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));

            uni = password.getBytes(SmbConstants.UNI_ENCODING);
        } catch (final UnsupportedEncodingException uee) {
            if (LogStream.level > 0) {
                uee.printStackTrace(log);
            }
        }
        final MD4 md4 = new MD4();
        md4.update(uni);
        try {
            md4.digest(p21, 0, 16);
        } catch (final Exception ex) {
            if (LogStream.level > 0) {

        chain.updateThrowsException = true;
        User user = createTestUser("testuser", "Test User");

        try {
            chain.update(user);
            fail("Expected exception to be thrown");
        } catch (RuntimeException e) {
            assertEquals("Update failed", e.getMessage());
        }

        assertEquals(1, chain.updateCalls.size());
    }

    // Test basic delete operation