checkArgument(
        rest.length <= Integer.MAX_VALUE - 1, "the total number of elements must fit in an int");
    int[] array = new int[rest.length + 1];
    array[0] = first;
    System.arraycopy(rest, 0, array, 1, rest.length);
    return new ImmutableIntArray(array);
  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableIntArray copyOf(int[] values) {

        } catch (final UnsupportedEncodingException uee) {
            return 0;
        }

        writeInt2(subCommand & 0xFF, dst, dstIndex);
        dstIndex += 2;
        System.arraycopy(descr, 0, dst, dstIndex, descr.length);
        dstIndex += descr.length;
        writeInt2(0x0001, dst, dstIndex);
        dstIndex += 2;
        writeInt2(maxDataCount, dst, dstIndex);
        dstIndex += 2;

        final int offsetOffset = dstIndex;
        SMBUtil.writeInt2(data.length, dst, dstIndex + 2);
        dstIndex += 4;
        SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, offsetOffset);

        System.arraycopy(data, 0, dst, dstIndex, data.length);
        dstIndex += data.length;
        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *

        count += len; // update number of bytes
        final int partLen = BLOCK_LENGTH - bufferNdx;
        int i = 0;
        if (len >= partLen) {
            System.arraycopy(input, offset, buffer, bufferNdx, partLen);

            transform(buffer, 0);

            for (i = partLen; i + BLOCK_LENGTH - 1 < len; i += BLOCK_LENGTH) {
                transform(input, offset + i);

        assertEquals(6, written, "writeParameterWordsWireFormat should return 6");
        // Only compare the first 6 bytes that were actually written
        byte[] actualWritten = new byte[6];
        System.arraycopy(buffer, 0, actualWritten, 0, 6);
        assertArrayEquals(expected, actualWritten, "wire format should match expectation");
    }

    static Stream<Arguments> validParams() {

        if (len > this.outputBuffer.length) {
            throw new SMBProtocolDecodingException("Payload exceeds buffer size");
        }
        System.arraycopy(buffer, bufferIndex, this.outputBuffer, 0, len);
        return len;

    }

    @Override
    public String toString() {
        return ("TransTransactNamedPipeResponse[" + super.toString() + "]");
    }

     */
    private static String createValidType3Message() {
        // Build a properly formatted Type 3 message
        byte[] message = new byte[200];

        // NTLMSSP signature
        System.arraycopy("NTLMSSP\0".getBytes(), 0, message, 0, 8);

        // Type 3 indicator
        message[8] = 0x03;

        // LM Response (24 bytes at offset 64)
        message[12] = 24; // Length
        message[13] = 0;

        // Signature (16 bytes)
        byte[] signature = new byte[16];
        new SecureRandom().nextBytes(signature);
        System.arraycopy(signature, 0, buffer, index, 16);
        index += 16;

        // Nonce (16 bytes)
        System.arraycopy(testNonce, 0, buffer, index, 16);
        index += 16;

        // Original message size (4 bytes) - little-endian
        int messageSize = 1024;

            // Verify additional information
            assertEquals(0x12345678, SMBUtil.readInt4(buffer, 76));

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

            // Verify that info.encode was called
            verify(mockInfo, times(1)).encode(any(byte[].class), anyInt());

        dstIndex += 4;
        SMBUtil.writeInt4((this.lockSequenceNumber & 0xF) << 28 | this.lockSequenceIndex & 0x0FFFFFFF, dst, dstIndex);
        dstIndex += 4;
        System.arraycopy(this.fileId, 0, dst, dstIndex, 16);
        dstIndex += 16;

        for (final Smb2Lock l : this.locks) {
            dstIndex += l.encode(dst, dstIndex);
        }
        return dstIndex - start;
    }