}
        this.fileId = Arrays.copyOf(fileId, 16);
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    /**
     * Get the file ID
     * @return the 16-byte file ID
     */
    public byte[] getFileId() {
        return Arrays.copyOf(fileId, 16);
    }

    @Override
    public int size() {

        }
        this.key = Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Get the lease key bytes
     *
     * @return copy of the 16-byte lease key
     */
    public byte[] getKey() {
        return Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Write the lease key to a buffer
     *

     */
    public HandleGuid getCreateGuid() {
        return createGuid;
    }

    /**
     * Get the file ID
     * @return copy of the 16-byte file ID
     */
    public byte[] getFileId() {
        return Arrays.copyOf(fileId, 16);
    }

    /**
     * Get the handle type
     * @return the handle type
     */
    public HandleType getType() {
        return type;

    void testEquals() {
        byte[] testBytes1 = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
        byte[] testBytes2 = Arrays.copyOf(testBytes1, 16);
        byte[] testBytes3 = new byte[] { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20 };

        Smb2LeaseKey key1 = new Smb2LeaseKey(testBytes1);

            headers.entrySet().stream().filter(e -> e.getKey() != null).forEach(
                    e -> map.put(e.getKey().toLowerCase(Locale.ROOT), e.getValue() == null ? List.of() : List.copyOf(e.getValue())));
            this.headers = Map.copyOf(map);
        }
    }

    /**
     * Gets the headers of the response.
     *
     * @return the headers.
     */
    public Map<String, List<String>> getHeaders() {

     */
    public void addQuery(final String s) {
        if (query == null) {
            query = new String[] { s };
        } else {
            final String[] newQuery = Arrays.copyOf(query, query.length + 1);
            newQuery[query.length] = s;
            query = newQuery;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded facet query: query={}", s);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Loaded Ingester: {}", ingester.getClass().getSimpleName());
        }
        final Ingester[] newIngesters = Arrays.copyOf(ingesters, ingesters.length + 1);
        newIngesters[ingesters.length] = ingester;
        Arrays.sort(newIngesters, (o1, o2) -> o1.priority - o2.priority);
        ingesters = newIngesters;
    }

    /**

            to.hashesExternal = true;
            to.ansiHash = from.ansiHash != null ? Arrays.copyOf(from.ansiHash, from.ansiHash.length) : null;
            to.unicodeHash = from.unicodeHash != null ? Arrays.copyOf(from.unicodeHash, from.unicodeHash.length) : null;
        } else {
            NtlmPasswordAuthenticator.cloneInternal(to, from);
        }
    }

    /**
     * Compares two {@code NtlmPasswordAuthentication} objects for

                bytes[byteIndex++] = (byte) (0x80 | ((c >> 6) & 0x3F));
                bytes[byteIndex++] = (byte) (0x80 | (c & 0x3F));
            }
        }

        return Arrays.copyOf(bytes, byteIndex);
    }

    /**
     * Convert byte array to char array (UTF-8)
     */
    private char[] bytesToChars(byte[] bytes) {
        if (bytes == null) {
            return null;

            logger.debug("Web protocols already contains: protocol={}", protocol);
            return;
        }
        webProtocols = Arrays.copyOf(webProtocols, webProtocols.length + 1);
        webProtocols[webProtocols.length - 1] = prefix;
    }

    /**
     * Adds a new file protocol to the supported protocols list.