@Override
    public String extendedToString() {
        StringBuilder buffer = new StringBuilder(256);

        buffer.append(LS).append("Repository Metadata").append(LS).append("--------------------------");
        buffer.append(LS).append("GroupId: ").append(getGroupId());
        buffer.append(LS).append("ArtifactId: ").append(getArtifactId());
        buffer.append(LS).append("Metadata Type: ").append(getClass().getName());

internal const val FRAGMENT_ENCODE_SET_URI = " \"#<>\\^`{|}"

internal fun Buffer.writeCanonicalized(
  input: String,
  pos: Int,
  limit: Int,
  encodeSet: String,
  alreadyEncoded: Boolean,
  strict: Boolean,
  plusIsSpace: Boolean,
  unicodeAllowed: Boolean,
  charset: Charset?,
) {
  var encodedCharBuffer: Buffer? = null // Lazily allocated.
  var codePoint: Int
  var i = pos
  while (i < limit) {

    void testReadSetupWireFormat() {
        notifyChange = new NtTransNotifyChange(mockConfig, 0x1234, FILE_NOTIFY_CHANGE_FILE_NAME, false);
        byte[] buffer = new byte[100];

        int result = notifyChange.readSetupWireFormat(buffer, 10, 50);

        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test readParametersWireFormat returns zero")
    void testReadParametersWireFormat() {

            if (LogStream.level >= 3) {
                log.println("TransTransactNamedPipe data too long for buffer");
            }
            return 0;
        }
        System.arraycopy(pipeData, pipeDataOff, dst, dstIndex, pipeDataLen);
        return pipeDataLen;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override

    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        if (this.wordCount == 0) {
            return 0;
        }
        this.fileAttributes = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.lastWriteTime = SMBUtil.readUTime(buffer, bufferIndex);
        bufferIndex += 4;
        this.fileSize = SMBUtil.readInt4(buffer, bufferIndex);
        return 20;
    }

    T pivotValue = uncheckedCastNullableTToT(buffer[pivotIndex]);
    buffer[pivotIndex] = buffer[right];

    int pivotNewIndex = left;
    for (int i = left; i < right; i++) {
      if (comparator.compare(uncheckedCastNullableTToT(buffer[i]), pivotValue) < 0) {
        swap(pivotNewIndex, i);
        pivotNewIndex++;
      }
    }
    buffer[right] = buffer[pivotNewIndex];
    buffer[pivotNewIndex] = pivotValue;

        bufferIndex += 2;
        parameterOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        parameterDisplacement = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataCount = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataDisplacement = readInt2(buffer, bufferIndex);

        byte[] buffer = new byte[50];
        int used = nullPathCmd.writeBytesWireFormat(buffer, 0);
        // Should write command byte + null terminator only
        assertEquals(2, used, "Null path should result in command byte + NUL");
        assertEquals(0x04, buffer[0] & 0xFF, "First byte must still be 0x04");
        assertEquals(0, buffer[1], "Second byte must be null terminator");
    }

        } else {
          var buffer = Buffer()
          requestBody.writeTo(buffer)

          var gzippedLength: Long? = null
          if ("gzip".equals(headers["Content-Encoding"], ignoreCase = true)) {
            gzippedLength = buffer.size
            GzipSource(buffer).use { gzippedResponseBody ->
              buffer = Buffer()
              buffer.writeAll(gzippedResponseBody)
            }

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        // Create buffer for encoding - initially allocate some space
        byte[] encodeBuffer = new byte[1024];
        NdrBuffer dst = new NdrBuffer(encodeBuffer, 0);
        info1.encode(dst);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        // Use the encoded buffer for decoding
        NdrBuffer src = new NdrBuffer(encodeBuffer, 0);