@DisplayName("Should reject when signature field exceeds buffer size in sign method")
        void testSignSignatureExceedsBuffer() {
            byte[] data = new byte[50]; // Too small for signature field
            assertThrows(IllegalArgumentException.class, () -> digest.sign(data, 0, 50, request, response),
                    "Should throw IllegalArgumentException when signature field exceeds buffer");
        }

        @Test

            throw new SmbException("Path cannot be null or empty");
        }

        // Check length
        if (path.length() > maxPathLength) {
            throw new SmbException("Path exceeds maximum length: " + path.length() + " > " + maxPathLength);
        }

        // Check for null bytes
        if (NULL_BYTE.matcher(path).find()) {

 *
 * This cache limits the number of bytes that it will store on the filesystem. When the number of
 * stored bytes exceeds the limit, the cache will remove entries in the background until the limit
 * is satisfied. The limit is not strict: the cache may temporarily exceed it while waiting for
 * files to be deleted. The limit does not include filesystem overhead or the cache journal so

import org.apache.commons.io.output.DeferredFileOutputStream;

/**
 * ContentOutputStream is a custom output stream that extends DeferredFileOutputStream.
 * It writes data to a temporary file once the data size exceeds a specified threshold.
 *
 * <p>This class ensures that the temporary file is deleted if it is not needed.
 * It uses a logger to log warnings if there are issues deleting the temporary file.</p>
 *
 * <p>Fields:</p>

     * operation to return.
     */
    int FILE_NOTIFY_CHANGE_CREATION = 0x00000040;

    /**
     * Any change to the extended attributes (EA) of a file in the watched directory or subtree causes a change notification wait operation to return.
     */
    int FILE_NOTIFY_CHANGE_EA = 0x00000080;

    /**

- In `Compliance` mode, objects cannot be deleted by anyone until retention period has expired for the given version id. If user has governance bypass permissions, an object's retention date can be extended in `Compliance` mode.
- Once object lock configuration is set to a bucket
  - New objects inherit the retention settings of the bucket object lock configuration automatically

        });
        return failureUrl;
    }

    /**
     * Extracts and returns the stack trace from a throwable as a string.
     * The stack trace is abbreviated if it exceeds the configured maximum length.
     *
     * @param t the throwable to extract the stack trace from
     * @return the stack trace as a string, or empty string if extraction fails
     */

                    }
                    s[_i].decode(_src);
                }
            }
        }
    }

    /**
     * DFS information level 200 structure for extended DFS information
     */
    public static class DfsInfo200 extends NdrObject {

        /**
         * Default constructor for DfsInfo200
         */
        public DfsInfo200() {

        assertThrows(ArrayIndexOutOfBoundsException.class, () -> enc.encode(dst, 2),
                "System.arraycopy should throw when dstIndex + len exceeds dst length");
    }

    @Test
    @DisplayName("encode() throws when dstIndex is negative")
    void encodeThrowsWhenDstIndexNegative() {
        byte[] src = makeSeq(3);

				if strings.HasSuffix(hdr.Name, "/") {
					hdr.Typeflag = TypeDir // Legacy archives use trailing slash for directories
				} else {
					hdr.Typeflag = TypeReg
				}
			}

			// The extended headers may have updated the size.
			// Thus, setup the regFileReader again after merging PAX headers.
			if err := tr.handleRegularFile(hdr); err != nil {
				return nil, err
			}