}
                    docs.add(doc);
                    doc = documentReader.read();
                    if (doc == null || docs.size() >= docPerReq) {
                        @SuppressWarnings("unchecked")
                        final SuggestIndexResponse res = indexFromDocument(ctx, docs.toArray(new Map[docs.size()]));
                        errors.addAll(res.getErrors());

@NullMarked
public class UnmodifiableCollectionTests {

  public static void assertMapEntryIsUnmodifiable(Entry<?, ?> entry) {
    try {
      // fine because the call is going to fail without modifying the entry
      @SuppressWarnings("unchecked")
      Entry<?, @Nullable Object> nullableValueEntry = (Entry<?, @Nullable Object>) entry;
      nullableValueEntry.setValue(null);
      fail("setValue on unmodifiable Map.Entry succeeded");

        builder.append(prefix);
        builder.append(lenientToString(args[i]));
        prefix = ", ";
      }
      builder.append(']');
    }

    return builder.toString();
  }

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static String lenientToString(@Nullable Object o) {
    if (o == null) {
      return "null";
    }
    try {
      return o.toString();

import jcifs.dcerpc.ndr.NdrLong;
import jcifs.dcerpc.ndr.NdrObject;

/**
 * DCE/RPC interface for Distributed File System (DFS) operations.
 * Provides structures and methods for DFS management and enumeration.
 */
@SuppressWarnings("all")
public class netdfs {

    /**
     * Default constructor for netdfs
     */
    public netdfs() {
        // Default constructor
    }

    /**

      }
    },
    OLD {
      @Override
      <T> Facade<T> newFacade() {
        return new OldAbstractFutureFacade<T>();
      }
    };

    abstract <T> Facade<T> newFacade();
  }

  @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
  static void awaitWaiting(Thread t) {
    while (true) {
      Thread.State state = t.getState();
      switch (state) {
        case RUNNABLE:

    return MapTestSuiteBuilder.using(
            new TestStringMapGenerator() {
              @Override
              // We are testing Hashtable / testing our tests on Hashtable.
              @SuppressWarnings("JdkObsolete")
              protected Map<String, String> create(Entry<String, String>[] entries) {
                return populate(new Hashtable<String, String>(), entries);
              }
            })

  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testIdentitySerializable() {
    checkCanReserializeSingleton(Functions.identity());
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testToStringFunction_apply() {
    assertThat(Functions.toStringFunction().apply(3)).isEqualTo("3");
    assertThat(Functions.toStringFunction().apply("hiya")).isEqualTo("hiya");

  }

  public void testValuesToString_ordered() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertThat(table.values().toString()).isEqualTo("[b, a, c]");
  }

  @SuppressWarnings({"deprecation", "InlineMeInliner"}) // test of a deprecated method
  public void testRowComparator() {
    sortedTable = TreeBasedTable.create();
    assertThat(sortedTable.rowComparator()).isEqualTo(Ordering.natural());

            }

            if (dependencyArtifact != null) {
                artifacts.add(dependencyArtifact);
            }
        }

        return artifacts;
    }

    @SuppressWarnings("checkstyle:methodlength")
    private ProjectRelocation retrieveRelocatedProject(Artifact artifact, MetadataResolutionRequest repositoryRequest)
            throws ArtifactMetadataRetrievalException {

  ): T = tags.computeIfAbsent(type, computeIfAbsent)

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type.kotlin, computeIfAbsent)

  @SuppressWarnings("CloneDoesntCallSuperClone") // We are a final type & this saves clearing state.
  override fun clone(): Call = RealCall(client, originalRequest, forWebSocket)

  override fun request(): Request = originalRequest