assertTrue(result.startsWith("NtTransQuerySecurityResponse["));
        assertTrue(result.endsWith("]"));
    }

    @Test
    @DisplayName("Test readParametersWireFormat with zero nextEntryOffset stops iteration")
    void testReadParametersWireFormatZeroNextEntryOffset() throws Exception {
        ByteBuffer buffer = ByteBuffer.allocate(200);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

      boolean hasSetRunning = false;
      try {
        while (true) {
          synchronized (queue) {
            // Choose whether this thread will run or not after acquiring the lock on the first
            // iteration
            if (!hasSetRunning) {
              if (workerRunningState == RUNNING) {
                // Don't want to have two workers pulling from the queue.
                return;
              } else {

    }

    @Override
    public boolean isEmpty() {
      return !Iterables.any(unfiltered, predicate);
    }

    @Override
    public Iterator<E> iterator() {
      return Iterators.filter(unfiltered.iterator(), predicate);
    }

    @Override
    public boolean remove(@Nullable Object element) {
      return contains(element) && unfiltered.remove(element);
    }

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import org.jspecify.annotations.Nullable;

/**
 * CompactLinkedHashMap is an implementation of a Map with insertion or LRU iteration order,
 * maintained with a doubly linked list through the entries. All optional operations (put and
 * remove) are supported. Null keys and values are supported.
 *

        # args, so each arg winds up back in the position where it started, but
        # possibly modified.
        #
        # NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of
        # iterations, nor the values presented in `arg`.
        shift                   # remove old arg
        set -- "$@" "$arg"      # push replacement arg
    done
fi

    return indexBeforeRemove - 1;
  }

  @Override
  public Iterator<E> iterator() {
    Set<E> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.iterator();
    }
    return new Iterator<E>() {
      int expectedMetadata = metadata;
      int currentIndex = firstEntryIndex();
      int indexToRemove = -1;

        } else {
          assertThat(numSuccessfulSetCalls.get()).isEqualTo(1);
        }
      } else {
        assertThat(numSuccessfulSetCalls.get()).isEqualTo(1);
      }
      // reset for next iteration
      numSuccessfulSetCalls.set(0);
      finalResults.clear();
    }
    executor.shutdown();
  }

  // setFuture and cancel() interact in more complicated ways than the other setters.

non-trivial square root Result = Composite W = 41 B = 2c # End of iteration Result = Composite W = 41 B = 16 # End of iteration Result = Composite W = 41 B = 14 # End of iteration Result = Composite W = 41 B = 2 # End of iteration Result = Composite W = 41 B = 3a # End of iteration Result = Composite W = 55 B = 40 # End of iteration Result = Composite W = 55 B = 7 # End of iteration Result = Composite W = 55 B = 23 # End of iteration Result = Composite W = 55 B = 2e # End of iteration Result = Composite...

    }
  }

  /** Overridden column iterator to return columns values in globally sorted order. */
  @Override
  Iterator<C> createColumnKeyIterator() {
    Comparator<? super C> comparator = columnComparator();

    Iterator<C> merged =
        mergeSorted(
            transform(backingMap.values(), (Map<C, V> input) -> input.keySet().iterator()),
            comparator);

 *
 * <p>The ordering of the row and column keys provided when the table is constructed determines the
 * iteration ordering across rows and columns in the table's views. None of the view iterators
 * support {@link Iterator#remove}. If the table is modified after an iterator is created, the
 * iterator remains valid.
 *
 * <p>This class requires less memory than the {@link HashBasedTable} and {@link TreeBasedTable}