assertArgumentNotNull("file", file);
        assertArgumentNotEmpty("encoding", encoding);

        final FileInputStream is = InputStreamUtil.create(file);
        try {
            final Reader reader = ReaderUtil.create(new BufferedInputStream(is, DEFAULT_BUF_SIZE), encoding);
            return read(reader, (int) ChannelUtil.size(is.getChannel()));
        } finally {
            CloseableUtil.close(is);

    private static final String BASE = StringUtil.toHex(getAddress()) + StringUtil.toHex(System.identityHashCode(RANDOM));

    /**
     * Creates a UUID.
     *
     * @return the UUID string
     */
    public static String create() {
        final StringBuilder buf = new StringBuilder(BASE.length() * 2);
        buf.append(BASE);
        final int lowTime = (int) (System.currentTimeMillis() >> 32);

     */
    protected ZipFileUtil() {
    }

    /**
     * Creates and returns a <code>ZipFile</code> for reading the specified Zip file.
     *
     * @param file
     *            File path. Must not be {@literal null} or an empty string.
     * @return A <code>ZipFile</code> for reading the specified Zip file.
     */
    public static ZipFile create(final String file) {
        assertArgumentNotEmpty("file", file);

public class SmbOperationExceptionTest {

    private SmbOperationException exception;

    @BeforeEach
    void setUp() {
        exception = null;
    }

    @Test
    @DisplayName("Should create exception with error code and message")
    void testBasicCreation() {
        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.FILE_NOT_FOUND, "test.txt");

        // Then

     *
     * @param create file creation time
     * @param lastAccess last access time
     * @param lastWrite last write time
     * @param change last change time
     * @param attributes file attributes
     */
    public FileBasicInfo(final long create, final long lastAccess, final long lastWrite, final long change, final int attributes) {
        this.createTime = create;
        this.lastAccessTime = lastAccess;

    resetContainer(getSubjectGenerator().create((Object[]) createArrayWithNullKey()));
  }

  protected void initMultimapWithNullValue() {
    resetContainer(getSubjectGenerator().create((Object[]) createArrayWithNullValue()));
  }

  protected void initMultimapWithNullKeyAndValue() {
    resetContainer(getSubjectGenerator().create((Object[]) createArrayWithNullKeyAndValue()));
  }

    return orderEntriesByKey(insertionOrder);
  }

  @Override
  protected abstract SortedMap<String, String> create(Entry<String, String>[] entries);

  @Override
  public SortedMap<String, String> create(Object... entries) {
    return (SortedMap<String, String>) super.create(entries);
  }

    private SrvCopychunk mockChunk;

    @BeforeEach
    void setUp() {
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create instance with source key and single chunk")
        void testConstructorWithSingleChunk() {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];
            Arrays.fill(sourceKey, (byte) 0xAB);

    void testDecodeMinimumBuffer() throws SMBProtocolDecodingException {
        // First create and encode
        FileBasicInfo original =
                new FileBasicInfo(TEST_CREATE_TIME, TEST_LAST_ACCESS_TIME, TEST_LAST_WRITE_TIME, TEST_CHANGE_TIME, TEST_ATTRIBUTES);

        // Create buffer with exact decode size
        byte[] tempBuffer = new byte[50];
        original.encode(tempBuffer, 0);

    }

    /**
     * Create a test byte array with specified size and pattern
     */
    protected byte[] createTestData(int size) {
        byte[] data = new byte[size];
        for (int i = 0; i < size; i++) {
            data[i] = (byte) (i % 256);
        }
        return data;
    }

    /**
     * Create a test string with specified length
     */