* The returned list may contain a mix of Java class path, Java module path, and other types of path elements.
     * This collection has the same content as {@code getDependencies.values()} except that it does not contain
     * null elements.
     *
     * @return the paths of all dependencies
     */
    @Nonnull
    List<Path> getPaths();

    /**

   * {@code put()} or {@code putAll()}, or {@code setValue()} on its entries.
   *
   * <p>In contrast, the maps returned by {@code rowMap().get()} have the same behavior as those
   * returned by {@link #row}. Those maps may support {@code setValue()}, {@code put()}, and {@code
   * putAll()}.
   *
   * @return a map view from each row key to a secondary map from column keys to values

        byte[] dst2 = new byte[256];
        int bytesWritten2 = netShareEnum.writeParametersWireFormat(dst2, 100);

        // Same number of bytes should be written
        assertEquals(bytesWritten1, bytesWritten2);

        // Data should be the same, just at different offsets
        for (int i = 0; i < bytesWritten1; i++) {
            assertEquals(dst1[i], dst2[100 + i]);
        }
    }

 *
 * <p>This uses the same efficient implementation as {@link Ordering#leastOf(Iterable, int)},
 * offering expected O(n + k log k) performance (worst case O(n log k)) for n calls to {@link
 * #offer} and a call to {@link #topK}, with O(k) memory. In comparison, quickselect has the same
 * asymptotics but requires O(n) memory, and a {@code PriorityQueue} implementation takes O(n log

        String ip = "192.168.1.3";

        // Make attempts from same IP with different users
        for (int i = 1; i <= 5; i++) {
            assertTrue(rateLimiter.checkAttempt("user" + i, ip), "Attempt " + i + " should be allowed");
            rateLimiter.recordFailure("user" + i, ip);
        }

        // 6th attempt from same IP should be blocked

    protected long requestInterval = 500;

    /**
     * Sends a list of documents to the search engine for indexing.
     * This method handles thumbnail processing, deletes old documents with the same URL,
     * and performs bulk indexing operations with proper error handling.
     *
     * @param searchEngineClient the search engine client to use for indexing
     * @param docList the list of documents to be indexed

        assertEquals(1, docList.size());
        assertEquals(0, deletedDocIdList.size());

        deletedDocIdList.clear();
        oldDocList.add(new HashMap<>(Map.of(//
                "_id", "001", // same id
                "config_id", "W01", //
                "doc_id", "1", //
                "url", "http://test.com/001"//
        )));
        documentSizeByQuery = oldDocList.size();

    }
  }

  /**
   * Implementation of the InvertedMinMaxPriorityQueue which forwards all calls to a
   * MinMaxPriorityQueue, except poll, which is forwarded to pollMax. That way we can benchmark
   * pollMax using the same code that benchmarks poll.
   */
  static final class InvertedMinMaxPriorityQueue<T> extends ForwardingQueue<T> {
    MinMaxPriorityQueue<T> mmHeap;

    public InvertedMinMaxPriorityQueue(Comparator<T> comparator) {

   * <p><b>Warning:</b> This method, which reencodes the input before processing it, is useful only
   * for cross-language compatibility. For other use cases, prefer {@link #putUnencodedChars}, which
   * is faster, produces the same output across Java releases, and processes every {@code char} in
   * the input, even if some are invalid.
   */
  @CanIgnoreReturnValue
  PrimitiveSink putString(CharSequence charSequence, Charset charset);

        assertEquals(cause, exception.getCause(), "Cause should match the input.");
        assertEquals(cause, exception.getRootCause(), "getRootCause() should return the same cause as getCause().");
    }

    /**
     * Test getErrorCode() method.
     */
    @Test
    void testGetErrorCode() {
        int errorCode = 0x00000005; // DCERPC_FAULT_ACCESS_DENIED