f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // Simple FileEntry stub for tests
    private static final class FE implements FileEntry {
        private final String name;

        FE(String name) {
            this.name = name;
        }

        @Override

        });

        assertEquals(5, page1.size());

        // Get second page (5 items)
        final List<OpenSearchAccessResult> page2 = dataService.getAccessResultList(builder -> {
            builder.setQuery(QueryBuilders.termQuery("sessionId", sessionId));
            builder.setFrom(5);
            builder.setSize(5);
        });

        assertEquals(5, page2.size());

        dataService.delete(sessionId);

   * nullness perspective. The signature below at least has the virtue of being relatively simple.
   */
  @SuppressWarnings("nullness")
  public final <T extends @Nullable Object> T[] toArray(T[] other) {
    checkNotNull(other);
    int size = size();

    if (other.length < size) {
      Object[] internal = internalArray();
      if (internal != null) {

        return true;
      }
      if (object instanceof DoubleArrayAsList) {
        DoubleArrayAsList that = (DoubleArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

      byteCount: Long,
    ) {
      assertLockNotHeld()

      sendBuffer.write(source, byteCount)
      while (sendBuffer.size >= EMIT_BUFFER_SIZE) {
        emitFrame(false)
      }
    }

    /**
     * Emit a single data frame to the connection. The frame's size be limited by this stream's
     * write window. This method will block until the write window is nonempty.
     */
    @Throws(IOException::class)

        when(mockNegotiate.getNegotiatedMpxCount()).thenReturn(65535);
        when(mockNegotiate.getNegotiatedSessionKey()).thenReturn(0x12345678);
    }

    /** Simple test stub of {@link ServerData} */
    private static class ServerDataStub extends ServerData {
        public ServerDataStub() {
            this.security = SmbConstants.SECURITY_USER;

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    // this loop is faster for RandomAccess instances, which ImmutableLists are
    int size = size();
    for (int i = 0; i < size; i++) {
      dst[offset + i] = get(i);
    }
    return offset + size;
  }

  /**
   * Returns a view of this immutable list in reverse order. For example, {@code ImmutableList.of(1,

 * Fix: Do not directly support any authentication schemes other than "Basic".
 * Fix: Respect read timeouts on recycled connections.
 * Fix: Transmit multiple cookie values as a single header with delimiter.
 * Fix: Ensure `null` is never returned from a connection's `getHeaderFields()`.
 * Fix: Persist proper `Content-Encoding` header to cache for GZip responses.

        assertEquals(itemsPerThread * numThreads, allUrls.size());

        urlQueueService.delete(sessionId);
    }

    public void test_poll_maxCrawlingQueueSizeTx() {
        final String sessionId = "poll_session5";
        final int maxSize = 5;
        urlQueueService.setMaxCrawlingQueueSize(maxSize);

        // Insert more items than max crawling queue size

	MinIOTaggingProxied = "X-Minio-Tagging-Proxied"
	// Header indicates the actual replicated object size
	// In case of SSEC objects getting replicated (multipart) actual size would be needed at target
	MinIOReplicationActualObjectSize = "X-Minio-Replication-Actual-Object-Size"

	// predicted date/time of transition
	MinIOTransition            = "X-Minio-Transition"