// Verify query flags
            assertEquals(0xABCDEF00, SMBUtil.readInt4(buffer, 84));

            // Verify file ID
            byte[] actualFileId = new byte[16];
            System.arraycopy(buffer, 88, actualFileId, 0, 16);
            assertArrayEquals(testFileId, actualFileId);

            // Verify total bytes written
            assertEquals(40, bytesWritten);
        } catch (Exception e) {

        final int start = dstIndex;

        while (this.pad-- > 0) {
            dst[dstIndex] = (byte) 0xEE;
            dstIndex++;
        }
        System.arraycopy(this.b, this.off, dst, dstIndex, this.dataLength);
        dstIndex += this.dataLength;

        return dstIndex - start;
    }

    @Override

            int fileNameLength = SMBUtil.readInt4(outputBuffer, offset + 8);

            // Extract filename
            byte[] fileNameBytes = new byte[fileNameLength];
            System.arraycopy(outputBuffer, offset + 12, fileNameBytes, 0, fileNameLength);
            String fileName = new String(fileNameBytes, StandardCharsets.UTF_16LE);

            // Convert action to our enum

            dst[dstIndex] = (byte) 0x00;
            return 1;
        }

        // copy new scope in
        dst[dstIndex] = (byte) '.';
        dstIndex++;
        try {
            System.arraycopy(scope.getBytes(Name.OEM_ENCODING), 0, dst, dstIndex, scope.length());
        } catch (final UnsupportedEncodingException uee) {}
        dstIndex += scope.length();

        dst[dstIndex++] = (byte) 0x00;

import static com.google.common.collect.testing.IteratorFeature.UNMODIFIABLE;
import static com.google.common.truth.Truth.assertThat;
import static java.lang.System.arraycopy;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static java.util.Collections.nCopies;
import static java.util.Collections.singletonList;

     */
    protected Entry<K, V> removeList(final int index) {
        final Entry<K, V> e = listTable[index];
        final int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(listTable, index + 1, listTable, index, numMoved);
        }
        listTable[--size] = null;
        return e;
    }

    /**
     * Ensures capacity when the size exceeds the threshold.
     */

import static com.google.common.collect.testing.Helpers.copyToList;
import static com.google.common.collect.testing.Helpers.copyToSet;
import static java.lang.System.arraycopy;
import static java.util.Arrays.asList;
import static java.util.Collections.frequency;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.fail;

        if (this.parameterCount > 0) {
            System.arraycopy(this.txn_buf, this.bufParameterOffset, dst, this.headerStart + this.parameterOffset, this.parameterCount);
            end = Math.max(end, this.headerStart + this.parameterOffset + this.parameterCount + this.pad2);
        }

        if (this.dataCount > 0) {

        final byte[] dst = new byte[1 + 1 + 6 + sid.sub_authority_count * 4];
        int di = 0;
        dst[di] = sid.revision;
        di++;
        dst[di++] = sid.sub_authority_count;
        System.arraycopy(sid.identifier_authority, 0, dst, di, 6);
        di += 6;
        for (int ii = 0; ii < sid.sub_authority_count; ii++) {
            jcifs.util.Encdec.enc_uint32le(sid.sub_authority[ii], dst, di);
            di += 4;

            final Extractor[] existingExtractors = extractorMap.get(key);

            final Extractor[] newExtractors = new Extractor[existingExtractors.length + 1];
            System.arraycopy(existingExtractors, 0, newExtractors, 0, existingExtractors.length);
            newExtractors[newExtractors.length - 1] = extractor;

            Arrays.sort(newExtractors, Comparator.comparingInt(Extractor::getWeight).reversed());