int chunk = (bytes[i++] & 0xFF) << 16 | (bytes[i++] & 0xFF) << 8 | (bytes[i++] & 0xFF);
        target.append(alphabet.encode(chunk >>> 18));
        target.append(alphabet.encode((chunk >>> 12) & 0x3F));
        target.append(alphabet.encode((chunk >>> 6) & 0x3F));
        target.append(alphabet.encode(chunk & 0x3F));
      }
      if (i < off + len) {
        encodeChunkTo(target, bytes, i, off + len - i);
      }

     */
    public int size() {
        return 0;
    }

    /**
     * Encode this request (no-op since there's no data)
     *
     * @param dst destination buffer
     * @param dstIndex starting offset
     * @return number of bytes written (always 0)
     */
    public int encode(byte[] dst, int dstIndex) {
        // No data to encode
        return 0;
    }

        // Should write FileInformation data + 6 bytes padding
        assertEquals(46, written); // 40 + 6

        // Verify encode was called
        verify(mockFileInfo).encode(buffer, 0);

        // Check that 6 bytes of padding are zeros
        for (int i = 40; i < 46; i++) {
            assertEquals(0, buffer[i]);
        }
    }

    @Test

pkg time, const DateTime ideal-string #52746
pkg time, const TimeOnly = "15:04:05" #52746
pkg time, const TimeOnly ideal-string #52746
pkg time, method (Time) Compare(Time) int #50770
pkg unicode/utf16, func AppendRune([]uint16, int32) []uint16 #51896
# freebsd riscv64 port
pkg log/syslog (freebsd-riscv64), const LOG_ALERT = 1 #53466
pkg log/syslog (freebsd-riscv64), const LOG_ALERT Priority #53466

    }

    /**
     * Constructs an AvTargetName with the specified target name
     *
     * @param targetName the target name string to encode
     */
    public AvTargetName(final String targetName) {
        this(encode(targetName));
    }

    /**
     * Gets the target name from this AV pair
     *
     * @return the target name
     */
    public String getTargetName() {

      derReader.read("test") {}
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("length encoded with more than 8 bytes is not supported")
    }
  }

  @Test fun `encode tag and length`() {
    val buffer = Buffer()
    val derWriter = DerWriter(buffer)

    derWriter.write("test", tagClass = DerHeader.TAG_CLASS_UNIVERSAL, tag = 30L) {
      derWriter.writeUtf8("a".repeat(201))

          codePoint == '\r'.code
      )
    ) {
      // Skip this character.
    } else if (codePoint == ' '.code && encodeSet === FORM_ENCODE_SET) {
      // Encode ' ' as '+'.
      writeUtf8("+")
    } else if (codePoint == '+'.code && plusIsSpace) {
      // Encode '+' as '%2B' since we permit ' ' to be encoded as either '+' or '%20'.
      writeUtf8(if (alreadyEncoded) "+" else "%2B")
    } else if (codePoint < 0x20 ||

        assertEquals("DHnQ", new String(request.getName()));
        assertTrue(request.size() > 0);

        // Test encoding
        byte[] buffer = new byte[request.size()];
        int encoded = request.encode(buffer, 0);
        assertEquals(request.size(), encoded);
    }

    @Test
    public void testDurableHandleV2Request() {
        DurableHandleV2Request request = new DurableHandleV2Request(120000, false);

         */
        public ShareInfo0() {
        }

        /**
         * The network name of the share.
         */
        public String netname;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(this.netname, 1);

            if (this.netname != null) {
                _dst = _dst.deferred;

        }
        draining = false;
        Java8Compatibility.clear(byteBuffer);
      }

      while (true) {
        // We call encode until there is no more input. The last call to encode will have endOfInput
        // == true. Then there is a final call to flush.
        CoderResult result;
        if (doneFlushing) {
          result = CoderResult.UNDERFLOW;