#### A Random Item { #a-random-item }

With `data.items()` we get an <abbr title="Something we can iterate on with a for loop, like a list, set, etc.">iterable object</abbr> with tuples containing the key and value for each dictionary item.

We convert this iterable object into a proper `list` with `list(data.items())`.

The `EventListener.Factory` also makes it possible to limit metrics to a subset of calls. This one captures metrics on a random 10%:

```java
class MetricsEventListener extends EventListener {
  private static final Factory FACTORY = new Factory() {
    @Override public EventListener create(Call call) {
      if (Math.random() < 0.10) {
        return new MetricsEventListener(call);
      } else {
        return EventListener.NONE;

		t.Fatal(err)
	}
	if n != length {
		t.Errorf("erasureCreateFile returned %d, expected %d", n, length)
	}

	// To generate random offset/length.
	r := rand.New(rand.NewSource(UTCNow().UnixNano()))

	buf := &bytes.Buffer{}

	// Verify erasure.Decode() for random offsets and lengths.
	for range iterations {
		offset := r.Int63n(length)
		readLen := r.Int63n(length - offset)

      // access some of the elements
      Random random = new Random();
      List<ReferenceEntry<Object, Object>> reads = new ArrayList<>();
      Iterator<ReferenceEntry<Object, Object>> i = readOrder.iterator();
      while (i.hasNext()) {
        ReferenceEntry<Object, Object> entry = i.next();
        if (random.nextBoolean()) {
          map.get(entry.getKey(), loader);
          reads.add(entry);

import java.util.Arrays;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("Smb2LeaseKey Tests")
class Smb2LeaseKeyTest {

    @Test
    @DisplayName("Should generate random lease key with correct size")
    void testRandomLeaseKeyGeneration() {
        Smb2LeaseKey key = new Smb2LeaseKey();

        assertNotNull(key.getKey());
        assertEquals(16, key.getKey().length);

    byte[] expectedBytes = new byte[size];
    byte[] bytes = newPreFilledByteArray(1024);

    // Setup
    File file = createTempFile();
    Files.write(bytes, file);

    Random random = new Random();
    random.nextBytes(expectedBytes);

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify

# Don't use the bazel cache when a new docker image is created.
RUN echo build --action_env=DOCKER_CACHEBUSTER=$(date +%s%N)$RANDOM >> /etc/bazel.bazelrc

            // Then
            assertNotNull(ra1, "Random access with mode should not be null");
            assertNotNull(ra2, "Random access with sharing should not be null");
            assertSame(mockRandomAccess, ra1, "Should return expected random access");
            assertSame(mockRandomAccess, ra2, "Should return expected random access");
        }
    }

    @Nested

    byte[] expectedBytes = new byte[size];
    byte[] bytes = newPreFilledByteArray(1024);

    // Setup
    File file = createTempFile();
    Files.write(bytes, file);

    Random random = new Random();
    random.nextBytes(expectedBytes);

    // Test
    MappedByteBuffer map = Files.map(file, MapMode.READ_WRITE);
    map.put(expectedBytes);

    // Verify

            // Check that secure nonces provide full diversity (entire nonce is random)
            String nonceHex = bytesToHex(nonce);
            nonceSet.add(nonceHex);
        }

        // Verify that secure nonces provide excellent diversity
        // With 100 nonces and 16 random bytes, we should have all unique nonces
        assertEquals(100, nonceSet.size(), "Secure nonces should all be unique");