// Verify correct portion of data is copied
        byte[] expectedData = new byte[partialLength];
        System.arraycopy(TEST_DATA, partialOffset, expectedData, 0, partialLength);
        byte[] copiedData = new byte[partialLength];
        System.arraycopy(dst, dstIndex, copiedData, 0, partialLength);
        assertArrayEquals(expectedData, copiedData);
    }

    @Test

        // MECH_OID
        System.arraycopy(oidDer, 0, buf, i, oidLen);
        i += oidLen;
        // NAME_LEN (4 bytes big-endian)
        buf[i++] = (byte) ((nameLen >>> 24) & 0xFF);
        buf[i++] = (byte) ((nameLen >>> 16) & 0xFF);
        buf[i++] = (byte) ((nameLen >>> 8) & 0xFF);
        buf[i++] = (byte) (nameLen & 0xFF);
        // NAME
        System.arraycopy(nameBytes, 0, buf, i, nameLen);
        return buf;

        final int length = readUShort(src, index);
        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);

            System.arraycopy(password, 0, dst, dstIndex, passwordLength);
            dstIndex += passwordLength;
        } else {
            // no password in tree connect
            dst[dstIndex++] = (byte) 0x00;
        }
        dstIndex += writeString(path, dst, dstIndex);
        try {
            System.arraycopy(service.getBytes("ASCII"), 0, dst, dstIndex, service.length());

    Object[] array = new Object[paramCount + others.length];
    arrayCopy(array, 0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12);
    arrayCopy(array, paramCount, others);
    return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(array));
  }

  private static void arrayCopy(Object[] dest, int pos, Object... source) {
    System.arraycopy(source, 0, dest, pos, source.length);
  }

                }
                System.arraycopy(str.getBytes(UNI_ENCODING), 0, dst, dstIndex, str.length() * 2);
                dstIndex += str.length() * 2;
                dst[dstIndex] = (byte) '\0';
                dstIndex++;
                dst[dstIndex++] = (byte) '\0';
            } else {
                final byte[] b = str.getBytes(OEM_ENCODING);
                System.arraycopy(b, 0, dst, dstIndex, b.length);

            c[ci] = ':';
            ci++;
            do {
                if (si == length) {
                    final int n = 16 - s;
                    System.arraycopy(SPACE_CHARS, 0, c, ci, n * 3);
                    ci += n * 3;
                    System.arraycopy(SPACE_CHARS, 0, d, s, n);
                    break;
                }
                c[ci++] = ' ';
                i = src[srcIndex + si] & 0xFF;

            } else {
                System.arraycopy(this.password, 0, dst, dstIndex, this.passwordLength);
                dstIndex += this.passwordLength;
            }
        } else {
            // no password in tree connect
            dst[dstIndex++] = (byte) 0x00;
        }
        dstIndex += writeString(this.path, dst, dstIndex);
        try {

                flags &= NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED ^ 0xffffffff;
            }

            final byte[] type1 = new byte[size];
            int pos = 0;

            System.arraycopy(NTLMSSP_SIGNATURE, 0, type1, 0, NTLMSSP_SIGNATURE.length);
            pos += NTLMSSP_SIGNATURE.length;

            writeULong(type1, pos, NTLMSSP_TYPE1);
            pos += 4;

     * @param i the starting index in the array
     * @param l the number of bytes to write
     */
    public void writeOctetArray(final byte[] b, final int i, final int l) {
        System.arraycopy(b, i, buf, index, l);
        advance(l);
    }

    /**
     * Reads an octet array from the buffer.
     *
     * @param b the byte array to read into
     * @param i the starting index in the array