// Arrange
            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, new int[] { 1, 2 });
            byte[] smallBuffer = new byte[100]; // Make buffer large enough
            byte[] largeBuffer = new byte[1000];

            // Act
            int smallEncodedSize = context.encode(smallBuffer, 0);
            int largeEncodedSize = context.encode(largeBuffer, 500);

                        response.received = false;

                        responseTable.put(nid, response);
                        ensureOpen(timeout + 1000);
                        socket.send(out);

                        if (LogStream.level > 3) {
                            log.println(request);

		return healEntryResult{
			bytes:   sz,
			skipped: true,
		}
	}

	// Collect updates to tracker from concurrent healEntry calls
	results := make(chan healEntryResult, 1000)
	quitting := make(chan struct{})
	defer func() {
		close(results)
		<-quitting
	}()

	go func() {
		for res := range results {
			if res.entryDone {
				tracker.setObject(res.name)

    protected boolean useLease = true;
    /** Lease timeout in milliseconds */
    protected int leaseTimeout = 30000;
    /** Maximum number of concurrent leases */
    protected int maxLeases = 1000;
    /** Preferred lease version (1 or 2) */
    protected int leaseVersion = 2;
    /** Lease break timeout in seconds (per MS-SMB2 spec) */
    protected int leaseBreakTimeout = 60;

        if (CACHE_POLICY == 0) {
            return;
        }
        long expiration = -1;
        if (CACHE_POLICY != FOREVER) {
            expiration = System.currentTimeMillis() + CACHE_POLICY * 1000;
        }
        cacheAddress(hostName, addr, expiration);
    }

    static void cacheAddress(final Name hostName, final NbtAddress addr, final long expiration) {
        if (CACHE_POLICY == 0) {

            throw new CrawlingAccessException("Could not parse " + responseData.getUrl(), e);
        }
        final Document document = parser.getDocument();

        final StringBuilder buf = new StringBuilder(1000);
        buf.append(getResultDataHeader());
        for (final Map.Entry<String, String> entry : fieldRuleMap.entrySet()) {
            final String path = entry.getValue();
            try {

        assertFalse(result);
    }

    /**
     * Test thread safety of enum
     */
    public void test_threadSafety() throws Exception {
        final int threadCount = 100;
        final int iterationsPerThread = 1000;
        final Set<Exception> exceptions = new HashSet<>();

        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {

    static Stream<Arguments> equalsHashParams() {
        return Stream.of(
                // byte[] id based equality (same id and tree id)
                Arguments.of(new byte[] { 0x0A, 0x0B }, new byte[] { 0x0A, 0x0B }, 100L, true),
                // fid based equality (null fileId, same fid and tree id)
                Arguments.of(null, null, 200L, true));
    }

    @ParameterizedTest(name = "equals/hashCode consistent for treeId={2}")

            Arrays.fill(salt, (byte) 0xFF);

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode at position 100
            int encoded = context.encode(buffer, 100);
            assertEquals(context.size(), encoded);

            // Verify salt is at correct position
            for (int i = 0; i < salt.length; i++) {

        if (StringUtil.isBlank(configName)) {
            configName = StringUtils.abbreviate(configPath, 30);
        }

        // normalize
        final StringBuilder buf = new StringBuilder(1000);
        for (int i = 0; i < configPath.length(); i++) {
            final char c = configPath.charAt(i);
            if (c == '\\') {
                buf.append('/');
            } else if (c == ' ') {