import static com.google.common.base.Preconditions.checkNotNull;

import org.jspecify.annotations.Nullable;

/**
 * GWT emulation of {@link SingletonImmutableSet}.
 *
 * @author Hayward Chan
 */
final class SingletonImmutableSet<E> extends ImmutableSet<E> {
  private final E element;

  SingletonImmutableSet(E element) {
    this.element = checkNotNull(element);
  }

  @Override

 * using the latest values obtained from {@link IteratorTester#newTargetIterator()}.
 *
 * <p>The value you pass to the parameter {@code steps} should be greater than the length of your
 * iterator, so that this class can check that your iterator behaves correctly when it is exhausted.
 *
 * <p>For example, to test {@link java.util.Collections#unmodifiableList(java.util.List)

        request = new Smb2NegotiateRequest(mockConfig, 0);

        // When
        int size = request.size();

        // Then - should include context sizes
        assertTrue(size > 112); // Bigger than without contexts
        assertEquals(0, size % 8); // Should be 8-byte aligned
    }

    @Test
    @DisplayName("Should write bytes to wire format correctly")
    void testWriteBytesWireFormat() {

    }

    // Demonstrates observed equals() asymmetry when this is shorter than argument
    @Test
    @DisplayName("equals: this shorter but same prefix -> true (observed behavior)")
    void equals_thisShorterSamePrefix_true_dueToImplementation() {
        // Arrange: left shorter than right but with identical prefix
        SecurityBlob shorter = new SecurityBlob(new byte[] { 1, 2 });

         * It's very unlikely that any loaded Futures class will see getChecked called with more
         * than a handful of exceptions. But it seems prudent to set a cap on how many we'll cache.
         * This avoids out-of-control memory consumption, and it keeps the cache from growing so
         * large that doing the lookup is noticeably slower than redoing the work would be.
         *

   * @since 15.0
   */
  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @throws TimeoutException if the service has not reached the given state within the deadline

      assertFalse(
          "Inverse should not contain value " + reversed.getValue(),
          inv.containsValue(reversed.getValue()));
      /*
       * TODO(cpovirk): This is a bit stronger than super.expectMissing(), which permits a <key,
       * someOtherValue> pair.
       */
      assertNull(
          "Inverse should not return a mapping for key " + reversed.getKey(),
          inv.get(reversed.getKey()));

     * and the arithmetic mean is always higher than the geometric mean.
     *
     * b) this iteration converges to floor(sqrt(x)). In fact, the number of correct digits doubles
     * with each iteration, so this algorithm takes O(log(digits)) iterations.
     *
     * We start out with a double-precision approximation, which may be higher or lower than the

### Is concurrency better than parallelism? { #is-concurrency-better-than-parallelism }

Nope! That's not the moral of the story.

 *
 * <p>Unlike {@code java.util.HashMap}, iteration is only proportional to the actual {@code size()},
 * which is optimal, and <i>not</i> the size of the internal hashtable, which could be much larger
 * than {@code size()}. Furthermore, this structure places significantly reduced load on the garbage
 * collector by only using a constant number of internal objects.
 *