List<@Nullable String> list = new ArrayList<>();
                for (String element : elements) {
                  list.add((element == null) ? null : "q" + element);
                }
                return Collections2.transform(
                    list, from -> isNullOrEmpty(from) ? null : from.substring(1));
              }
            })
        .named("Collections2.transform")
        .withFeatures(

                List<@Nullable String> list = new ArrayList<>();
                for (String element : elements) {
                  list.add((element == null) ? null : "q" + element);
                }
                return Collections2.transform(
                    list, from -> isNullOrEmpty(from) ? null : from.substring(1));
              }
            })
        .named("Collections2.transform")
        .withFeatures(

    static FactoryMethodReturnsNullButNotAnnotated returnsNull() {
      return null;
    }
  }

  static class FactoryMethodReturnsNullAndAnnotated {
    private FactoryMethodReturnsNullAndAnnotated() {}

    public static @Nullable FactoryMethodReturnsNullAndAnnotated returnsNull() {
      return null;
    }
  }

  static class FactoryMethodAcceptsNull {

   */
  /*
   * By declaring <T> instead of <T extends @Nullable Object>, we declare this method as requiring a
   * stream whose elements are non-null. However, the method goes out of its way to still handle
   * nulls in the stream. This means that the method can safely be used with a stream that contains
   * nulls as long as the *last* element is *not* null.
   *

  protected final void afterDone() {
    super.afterDone();

    @RetainedLocalRef ImmutableCollection<? extends Future<?>> localFutures = futures;
    releaseResources(OUTPUT_FUTURE_DONE); // nulls out `futures`

    if (isCancelled() & localFutures != null) {
      boolean wasInterrupted = wasInterrupted();
      for (Future<?> future : localFutures) {
        future.cancel(wasInterrupted);
      }
    }
    /*

  }

  /*
   * We don't permit nulls, but we wrap every comparator with nullsFirst().
   * Why? We want for queries like containsKey(null) to return false, but the
   * GWT SortedMap implementation that we delegate to throws
   * NullPointerException if the comparator does. Since our construction
   * methods ensure that null is never present in the map, it's OK for the

    }

    @Test
    @DisplayName("Null inputs: read(byte[]) and write* with nulls throw NPE")
    void nullInputs_throwNPE() throws Exception {
        SmbRandomAccessFile raf = newInstance("rw", false, true, false);
        assertThrows(NullPointerException.class, () -> raf.read((byte[]) null));
        assertThrows(NullPointerException.class, () -> raf.writeBytes(null));

    if (delegate != null) {
      metadata =
          Ints.constrainToRange(size(), CompactHashing.DEFAULT_SIZE, CompactHashing.MAX_SIZE);
      delegate.clear(); // invalidate any iterators left over!
      table = null;
      size = 0;
    } else {
      Arrays.fill(requireKeys(), 0, size, null);
      Arrays.fill(requireValues(), 0, size, null);
      CompactHashing.tableClear(requireTable());

      newDelegate.add(element(i));
    }
    this.table = newDelegate;
    this.entries = null;
    this.elements = null;
    incrementModCount();
    return newDelegate;
  }

  @VisibleForTesting
  boolean isUsingHashFloodingResistance() {
    return delegateOrNull() != null;
  }

  /** Stores the hash table mask as the number of bits needed to represent an index. */

   *
   * @throws NullPointerException if any key or value in {@code map} is null
   */
  @SuppressWarnings("unchecked")
  public static <K, V> ImmutableSortedMap<K, V> copyOfSorted(SortedMap<K, ? extends V> map) {
    Comparator<? super K> comparator = map.comparator();
    if (comparator == null) {
      // If map has a null comparator, the keys should have a natural ordering,