@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class AbstractListTester<E extends @Nullable Object> extends AbstractCollectionTester<E> {
  /*
   * Previously we had a field named list that was initialized to the value of
   * collection in setUp(), but that caused problems when a tester changed the
   * value of list or collection but not both.
   */
  protected final List<E> getList() {

        NbtAddress[] addresses = (NbtAddress[]) addressArrayField.get(response);
        assertNotNull(addresses);
        assertEquals(3, addresses.length);

        // Verify MAC address was parsed
        Field macAddressField = NodeStatusResponse.class.getDeclaredField("macAddress");
        macAddressField.setAccessible(true);
        byte[] parsedMac = (byte[]) macAddressField.get(response);

   *       Futures#getUnchecked}.
   * </ul>
   *
   * @throws ExecutionException if the computation threw an exception
   * @throws CancellationException if the computation was cancelled
   */
  @CanIgnoreReturnValue
  @ParametricNullness
  public static <V extends @Nullable Object> V getUninterruptibly(Future<V> future)
      throws ExecutionException {
    boolean interrupted = false;

     * handleException() at all.
     */
    if (throwable instanceof Error) {
      /*
       * TODO(cpovirk): Do we really want to log this if we called setException(throwable) and it
       * returned true? This was intentional (CL 46470009), but it seems odd compared to how we
       * normally handle Error.
       *
       * Similarly, do we really want to log the same Error more than once?
       */
      log(throwable);
    }

      node.next = nextSibling;
      node.nextSibling = nextSibling;
      if (nextSibling.previousSibling == null) { // nextSibling was key head
        keyList.head = node;
      } else {
        nextSibling.previousSibling.nextSibling = node;
      }
      if (nextSibling.previous == null) { // nextSibling was head
        head = node;
      } else {
        nextSibling.previous.next = node;
      }

    calls that use a pooled connection.


## Version 4.3.1

_2020-01-07_

 *  Fix: Don't crash with a `NullPointerException` when a web socket is closed before it connects.
    This regression was introduced in OkHttp 4.3.0.
 *  Fix: Don't crash with an `IllegalArgumentException` when using custom trust managers on
    Android 10. Android uses reflection to look up a magic `checkServerTrusted()` method and we

## Check the Virtual Environment is Active { #check-the-virtual-environment-is-active }

Check that the virtual environment is active (the previous command worked).

/// tip

This is **optional**, but it's a good way to **check** that everything is working as expected and you are using the virtual environment you intended.

///

//// tab | Linux, macOS, Windows Bash

<div class="termy">

```console
$ which python

          Assert.fail(
              "input bit("
                  + i
                  + ") was found not to affect all "
                  + hashBits
                  + " output bits; The unaffected bits are "
                  + "as follows: "
                  + ~(same & diff)
                  + ". This was "
                  + "determined after "
                  + count
                  + " trials.");

     * @param fromIndex        the source index name
     * @param toIndex          the destination index name
     * @param waitForCompletion whether to wait for the operation to complete
     * @return true if the copy operation was successful, false otherwise
     */
    public boolean copyDocIndex(final String fromIndex, final String toIndex, final boolean waitForCompletion) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

  private static void assertFailsToDecode(
      BaseEncoding encoding, String cannotDecode, @Nullable String expectedMessage) {
    // We use this somewhat weird pattern with an enum for each assertion we want to make as a way
    // of dealing with the fact that one of the assertions is @GwtIncompatible but we don't want to
    // have to have duplicate @GwtIncompatible test methods just to make that assertion.