defer store.RUnlock()
	return l
}

// lockless call
func (store *QueueStore[_]) del(key Key) error {
	err := os.Remove(filepath.Join(store.directory, key.String()))

	// Delete as entry no matter the result
	delete(store.entries, key.String())

	return err
}

// List - lists all files registered in the store.
func (store *QueueStore[_]) List() (keys []Key) {
	store.RLock()
	defer store.RUnlock()

     */
    @Nonnull
    Optional<Boolean> failAtEnd();

    /**
     * Indicates whether Maven should never fail the build, regardless of project result.
     *
     * @return an {@link Optional} containing true if the build should never fail, false if it should fail normally, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> failNever();

   *   Iterator<E> i = queue.iterator(); // Must be in synchronized block
   *   while (i.hasNext()) {
   *     foo(i.next());
   *   }
   * }
   * }</pre>
   *
   * <p>Failure to follow this advice may result in non-deterministic behavior.
   *
   * <p>The returned queue will be serializable if the specified queue is serializable.
   *
   * @param queue the queue to be wrapped in a synchronized view

	duration, _ := time.ParseDuration(durationStr)
	if duration < globalNetPerfMinDuration {
		duration = globalNetPerfMinDuration
	}
	result := siteNetperf(r.Context(), duration)
	adminLogIf(r.Context(), gob.NewEncoder(w).Encode(result))

		t.Run(fmt.Sprintf("[%v] %v", i, c.name), func(tt *testing.T) {
			// no updateTokenSecret means re-fetching yields the same result
			obj := []runtime.Object{c.haveTokenSecret}
			if c.updatedTokenSecret != nil {
				// fetching should give a different result than the token secret we pass in
				obj = []runtime.Object{c.updatedTokenSecret}
			}
			client := kube.NewFakeClient(obj...)

}

func TestSparseEntries(t *testing.T) {
	vectors := []struct {
		in   []sparseEntry
		size int64

		wantValid    bool          // Result of validateSparseEntries
		wantAligned  []sparseEntry // Result of alignSparseEntries
		wantInverted []sparseEntry // Result of invertSparseEntries
	}{{
		in: []sparseEntry{}, size: 0,
		wantValid:    true,
		wantInverted: []sparseEntry{{0, 0}},
	}, {

   * each call to this method may claim and hold a thread for an arbitrary length of time. Use of
   * bounded executors or other executors that may fail to execute a task promptly may result in
   * deadlocks.
   *
   * <p>Prefer to create {@code ListenableFuture} instances with {@link SettableFuture}, {@link
   * MoreExecutors#listeningDecorator( java.util.concurrent.ExecutorService)}, {@link

        }
        return pipeIn;
    }

    /**
     * Return the <code>OutputStream</code> used to write
     * information to this pipe instance. The act of writing data
     * to this stream will result in response data recieved in the
     * <code>InputStream</code> associated with this Named Pipe
     * instance (unless of course it does not elicite a response or the pipe is write-only).
     */

            "fixedColor": "rgb(31, 120, 193)",
            "mode": "fixed"
          },
          "mappings": [
            {
              "options": {
                "match": "null",
                "result": {
                  "text": "N/A"
                }
              },
              "type": "special"
            }
          ],
          "thresholds": {
            "mode": "absolute",

    int result = 0;
    for (Segment<K, V, ?, ?> segment : map.segments) {
      AtomicReferenceArray<? extends InternalEntry<K, V, ?>> table = segment.table;
      for (int i = 0; i < table.length(); i++) {
        for (InternalEntry<K, V, ?> e = table.get(i); e != null; e = e.getNext()) {
          if (map.isLiveForTesting(e)) {
            result++;
          }
        }
      }
    }