lastName = e.filename;
                resumeKey = e.fileIndex;
            }

            bufferIndex += e.nextEntryOffset;
        }

        /* last nextEntryOffset for NT 4(but not 98) is 0 so we must
         * use dataCount or our accounting will report an error for NT :~(
         */

        //return bufferIndex - start;

        return dataCount;
    }

        byte[] buffer = new byte[Smb2ChannelCapabilities.NETWORK_INTERFACE_INFO_SIZE];
        ByteBuffer bb = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN);

        // Next field (4 bytes) - offset to next entry (0 for last entry)
        bb.putInt(0);

        // InterfaceIndex (4 bytes)
        bb.putInt(interfaceIndex);

        // Capability (4 bytes)
        bb.putInt(capability);

                break;
            } catch (Exception recoveryError) {
                log.warn("RDMA recovery attempt {} failed: {}", retryCount, recoveryError.getMessage());

                // If this was the last attempt, log the full error
                if (retryCount >= maxRetries) {
                    log.error("All RDMA recovery attempts failed", recoveryError);
                }
            }
        }

}

// SRStatus has replication stats at deployment level
type SRStatus struct {
	ReplicatedSize int64 `json:"completedReplicationSize"`
	// Total number of failed operations including metadata updates in the last minute
	Failed RTimedMetrics `json:"failedReplication"`
	// Total number of completed operations
	ReplicatedCount int64 `json:"replicationCount"`
	// Replication latency information

 *
 *  * **b2a**: b2 + 0x80
 *  * **b3a**: b3 + 0x80
 *  * **b2b3**: (b2 << 7) + b3
 *
 * b0
 * --
 *
 * The inclusive start of the range. We get the first 14 bits of this code point from the section
 * and the last 7 bits from this byte.
 *
 * The end of the range is not encoded, but can be inferred by looking at the start of the range
 * that follows.
 *
 * b1
 * --
 *

		// Only replace if needed.
		// Existing requests will use the previous limit,
		// but new requests will use the new limit.
		// There will be a short overlap window,
		// but this shouldn't last long.
		t.requestsPool = make(chan struct{}, apiRequestsMaxPerNode)
	}
	listQuorum := cfg.ListQuorum
	if listQuorum == "" {
		listQuorum = "strict"
	}
	t.listQuorum = listQuorum

        // Assert
        assertEquals(24, resp.length, "LMv2 response length must be 24");
        assertArrayEquals(clientChallenge, Arrays.copyOfRange(resp, 16, 24), "Client challenge must be copied to last 8 bytes");
        assertFalse(Arrays.equals(new byte[24], resp), "Response must not be all zeros");
    }

    @Test
    @DisplayName("getLMv2Response(byte[]): empty client data allowed")

            SMBUtil.writeInt8(creationTime, buffer, bufferIndex + 8);
            // Last Access Time (8 bytes)
            long lastAccessTime = creationTime + 1000000L;
            SMBUtil.writeInt8(lastAccessTime, buffer, bufferIndex + 16);
            // Last Write Time (8 bytes)
            long lastWriteTime = creationTime + 2000000L;

androidx-annotation = "androidx.annotation:annotation:1.9.1"
androidx-espresso-core = "androidx.test.espresso:espresso-core:3.7.0"
androidx-junit = "androidx.test.ext:junit:1.3.0"
#noinspection UnusedVersionCatalogEntry
androidx-lint-gradle = { module = "androidx.lint:lint-gradle", version.ref = "lintGradle" }
androidx-startup-runtime = { module = "androidx.startup:startup-runtime", version.ref = "startupRuntime" }
androidx-test-runner = "androidx.test:runner:1.7.0"

    TreeMultimap<@Nullable String, @Nullable Integer> multimap = createPopulate();
    SortedSet<@Nullable String> keySet = multimap.keySet();

    assertEquals(null, keySet.first());
    assertEquals("google", keySet.last());
    assertEquals(StringLength.COMPARATOR, keySet.comparator());
    assertEquals(Sets.<@Nullable String>newHashSet(null, "tree"), keySet.headSet("yahoo"));
    assertEquals(newHashSet("google"), keySet.tailSet("yahoo"));