* Returns a {@code Collector} that accumulates the input elements into a new {@code
   * ImmutableSet}. Elements appear in the resulting set in the encounter order of the stream; if
   * the stream contains duplicates (according to {@link Object#equals(Object)}), only the first
   * duplicate in encounter order will appear in the result.
   *
   * @since 21.0
   */
  public static <E> Collector<E, ?, ImmutableSet<E>> toImmutableSet() {

package amztime

import (
	"errors"
	"net/http"
	"time"
)

// Supported amz date formats.
var amzDateFormats = []string{
	// Do not change this order, x-amz-date format is usually in
	// iso8601Format rest are meant for relaxed handling of other
	// odd SDKs that might be out there.
	"20060102T150405Z",
	time.RFC1123,
	time.RFC1123Z,
	// Add new AMZ date formats here.

    }

    @Test
    void testReadULong() {
        // Test readULong with various values
        byte[] data = new byte[8];
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);

        // Test with a positive value
        buffer.putInt(0, 0x12345678);
        assertEquals(0x12345678, NtlmMessage.readULong(data, 0), "Should read positive ULong correctly.");

package cmd

import (
	"math"
	"sync"
	"sync/atomic"
	"time"
)

const (
	dynamicTimeoutIncreaseThresholdPct = 0.33 // Upper threshold for failures in order to increase timeout
	dynamicTimeoutDecreaseThresholdPct = 0.10 // Lower threshold for failures in order to decrease timeout
	dynamicTimeoutLogSize              = 16
	maxDuration                        = math.MaxInt64

  /*
   * While the current implementation returns `this`, that's not something we mean to guarantee.
   * Callers of TestContainerGenerator.order need to be prepared for implementations to return a new
   * collection.
   */
  @SuppressWarnings("CanIgnoreReturnValueSuggester")
  @Override
  public List<Integer> order(List<Integer> insertionOrder) {
    sort(insertionOrder);
    return insertionOrder;
  }

    }

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return generator.order(insertionOrder);
    }

    @SuppressWarnings("unchecked")
    @Override
    public K[] createKeyArray(int length) {
      return (K[]) new Object[length];
    }

    }

    @Test
    @Order(3)
    void crawlingInfoDeleteAllTest() {
        logger.info("start crawlingInfoDeleteAllTest");
        testDeleteAllCrawlingInfo();
    }

    @Test
    @Order(4)
    void failureUrlTest() {
        logger.info("start failureUrlTest");
        testReadFailureUrl();
        testDeleteFailureUrl();
    }

    @Test
    @Order(5)
    void searchListTest() {

// WalkVersionsSortOrder represents the sort order in which versions of an
// object should be returned by ObjectLayer.Walk method
type WalkVersionsSortOrder uint8

const (
	// WalkVersionsSortAsc - Sort in ascending order of ModTime
	WalkVersionsSortAsc WalkVersionsSortOrder = iota
	// WalkVersionsSortDesc - Sort in descending order of ModTime
	WalkVersionsSortDesc
)

 * is not guaranteed to traverse the elements of the MonitorBasedPriorityBlockingQueue in
 * any particular order. If you need ordered traversal, consider using {@code
 * Arrays.sort(pq.toArray())}. Also, method {@code drainTo} can be used to remove some or
 * all elements in priority order and place them in another collection.
 *
 * <p>Operations on this class make no guarantees about the ordering of elements with equal

     * will silently {@link #addNode(Object) add} {@code nodeU} and {@code nodeV} to the network.
     *
     * <p>If {@code edge} already connects {@code nodeU} to {@code nodeV} (in the specified order if
     * this network {@link #isDirected()}, else in any order), then this method will have no effect.
     *
     * @return this {@code Builder} object
     * @throws IllegalArgumentException if {@code edge} already exists in the network and does not