* {@code map} and the instances generated by {@code factory} are. Concurrent read operations will
   * work correctly. To allow concurrent update operations, wrap the multimap with a call to {@link
   * #synchronizedMultimap}.
   *
   * <p>Call this method only when the simpler methods {@link ArrayListMultimap#create()}, {@link
   * HashMultimap#create()}, {@link LinkedHashMultimap#create()}, {@link

    public void remove() {
      checkRemove(false);
    }
  }

  /**
   * Returns the empty {@code Iterator} that throws {@link IllegalStateException} instead of {@link
   * UnsupportedOperationException} on a call to {@link Iterator#remove()}.
   */
  // Casting to any type is safe since there are no actual elements.
  @SuppressWarnings("unchecked")
  static <T extends @Nullable Object> Iterator<T> emptyModifiableIterator() {

     * (Android vs. Java), by platform release (Android 4.4 vs. Android 9), and with user
     * customizations.
     *
     * Most TLS clients that connect to hosts on the public Internet should call this method.
     * Otherwise it is necessary to manually prepare a comprehensive set of trusted roots.
     *
     * If the host platform is compromised or misconfigured this may contain untrustworthy root

    assertEquals(-2, binarySearch(0, 1) { index -> 2.compareTo(table[index]) })
  }

  @Test fun binarySearchEmptyRange() {
    assertEquals(-1, binarySearch(0, 0) { error("unexpected call") })
  }

  /** Confirm the compact table has the exact same behavior as the plain table. */
  @Test fun comparePlainAndCompactTables() {
    val buffer = Buffer()
    for (codePoint in 0..0x10ffff) {

        // Create spy on real object
        FileEndOfFileInformation realObject = new FileEndOfFileInformation(4096L);
        FileEndOfFileInformation spy = Mockito.spy(realObject);

        // Call methods
        byte level = spy.getFileInformationLevel();
        int size = spy.size();
        byte[] buffer = new byte[8];
        int encoded = spy.encode(buffer, 0);
        int decoded = spy.decode(buffer, 0, 8);

    }

    @Test
    @DisplayName("close() does nothing (no delegate interactions)")
    void close_isNoop() throws Exception {
        // Verify close() is a no-op and does not call handle/tree/fd
        SmbPipeInputStream stream = newStreamWithInit(true);

        // reset to ignore constructor interactions
        reset(handle, tree, fd);

        assertDoesNotThrow(stream::close);

<div class="termy">

```console
$ python -m venv .venv
```

</div>

/// details | What that command means

* `python`: use the program called `python`
* `-m`: call a module as a script, we'll tell it which module next
* `venv`: use the module called `venv` that normally comes installed with Python
* `.venv`: create the virtual environment in the new directory `.venv`

///

////

    } catch (AssertionFailedError expected) {
      return;
    }
    fail("Should have failed");
  }

  /** An interface for the 2 ways that a chaining call might be defined. */
  private interface ChainingCalls {
    // A method that is defined to 'return this'
    @CanIgnoreReturnValue
    ChainingCalls chainingCall();

 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs
 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *

    }

    @Nested
    @DisplayName("Mockito interactions")
    class MockitoInteractions {

        @Mock
        SSPContext mockCtx;

        // Helper exercising all SSPContext methods to verify call interactions.
        private void useContext(SSPContext ctx) throws Exception {
            ctx.getSigningKey();
            ctx.isEstablished();
            ctx.initSecContext(new byte[] { 1, 2, 3 }, 1, 1);