* @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we
   * would declare a return type of `@Nullable T[]`. However, we've decided not to think too hard
   * about arrays for now, as they're a mess. (We previously discussed this in the review of
   * ObjectArrays, which is the main caller of this method.)
   */

        SMBUtil.writeInt8(expectedIndexNumber, buffer, bufferIndex);

        // Decode
        int bytesDecoded = fileInternalInfo.decode(buffer, bufferIndex, 8);

        // Verify
        assertEquals(8, bytesDecoded);
        assertEquals(expectedIndexNumber, fileInternalInfo.getIndexNumber());
    }

    @Test
    @DisplayName("Test decode with zero index number")

- Choice of erasure set size is automatic based on the number of drives available, let's say for example if there are 32 servers and 32 drives which is a total of 1024 drives. In this scenario 16 becomes the erasure set size. This is decided based on the greatest common divisor (GCD) of acceptable erasure set sizes ranging from *4 to 16*.

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        // Verify - the decode method strips null termination, so filename should match
        assertEquals(expectedFilename, fileBothDirectoryInfo.getFilename());
    }

    @Test
    @DisplayName("Test decode with null-terminated non-Unicode filename")

    }

    @Test
    @DisplayName("Test decode with minimum valid length")
    void testDecodeMinimumValidLength() throws SMBProtocolDecodingException {
        // Prepare minimum valid buffer - exactly 24 bytes
        byte[] buffer = new byte[28];
        Arrays.fill(buffer, 0, 24, (byte) 0xAA);

        // Decode with len = 24 (minimum valid)
        int bytesConsumed = response.decode(buffer, 0, 24);

        @Test
        @DisplayName("Decode error handling should work correctly")
        void testDecodeErrorHandling() throws Exception {
            // Given
            when(mockHandle.getMaxXmit()).thenReturn(1024);
            when(mockHandle.getMaxRecv()).thenReturn(1024);
            DcerpcBind bindMessage = new DcerpcBind(mockBinding, mockHandle);

            // When - Decode with error response

            // Setup for SamrSamEntry decode chain
            mockDeferredBuffer.deferred = mockDeferredBuffer;
            when(mockDeferredBuffer.dec_ndr_short()).thenReturn(0, 0, 0);

            // When: Decoding output
            message.decode_out(mockNdrBuffer);

            // Then: Should decode all output parameters
            verify(samArray).decode(mockNdrBuffer);

        // Decode and verify
        fileStandardInfo.decode(buffer, 0, buffer.length);
        assertEquals(expectedEndOfFile, fileStandardInfo.getSize());
    }

    @Test
    @DisplayName("Test size method returns 22")
    void testSize() {
        assertEquals(22, fileStandardInfo.size());
    }

    @Test
    @DisplayName("Test decode with valid data")

  }

  @Test fun `cannot decode malformed utc time`() {
    val bytes = "170d3139313231362333303231305a".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.UTC_TIME.fromDer(bytes)
    }.also { expected ->
      assertThat(expected).hasMessage("Failed to parse UTCTime 191216#30210Z")
    }
  }

  @Test fun `cannot decode generalized time with offset`() {

        // Use the encoded buffer for decoding
        NdrBuffer src = new NdrBuffer(encodeBuffer, 0);
        netdfs.DfsInfo1 decodedInfo1 = new netdfs.DfsInfo1();
        decodedInfo1.decode(src);

        assertEquals(info1.entry_path, decodedInfo1.entry_path);
    }

    @Test
    void testDfsInfo1_EncodeDecode_NullEntryPath() throws NdrException {
        netdfs.DfsInfo1 info1 = new netdfs.DfsInfo1();