* {@link SortedMultiset#firstEntry} {@link SortedMultiset#headMultiset}, {@link
   * SortedMultiset#isEmpty}, {@link SortedMultiset#lastEntry}, {@link SortedMultiset#subMultiset},
   * {@link SortedMultiset#tailMultiset}, the {@code size()} and {@code iterator()} methods of
   * {@link SortedMultiset#entrySet}, and {@link SortedMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link SortedMultiset#elementSet} to forward to this

    }
  }

  private static void checkResults(List<Future<String>> futures)
      throws InterruptedException, ExecutionException {
    for (int i = 0; i < futures.size(); i++) {
      assertEquals(RESULT_VALUE + i, futures.get(i).get());
    }
  }

  private static List<Callable<String>> createTasks(int n) {
    List<Callable<String>> callables = new ArrayList<>();

    assertEquals(
        "multiset.entrySet() iterator.next() returned incorrect entry",
        Multisets.immutableEntry(e0(), 1),
        iterator.next());
    assertFalse(
        "size 1 multiset.entrySet() iterator.hasNext() returned true after next()",
        iterator.hasNext());
    iterator.remove();
    assertTrue(
        "multiset isn't empty after multiset.entrySet() iterator.remove()",

   *
   * <p>Note: this method is idempotent and safe to call from any thread
   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions
    for (int i = 0; i < listeners.size(); i++) {
      listeners.get(i).dispatch();
    }
  }

  /**
   * A special purpose queue/executor that dispatches listener events serially on a configured

            property.setReplacement(methodMetaData.getReplacement());
            return;
        }

        if (methodMetaData.getParameters().size() != 1) {
            return;
        }
        matcher = SETTER_METHOD_NAME.matcher(name);
        if (matcher.matches()) {
            int startName = matcher.start(1);

     *
     * <p>This method returns all duplicate host configurations in the system,
     * ordered by sort order, regular name, and duplicate hostname. The results
     * are limited by the configured maximum fetch size to prevent memory issues.</p>
     *
     * @return a list of all DuplicateHost entities
     */
    public List<DuplicateHost> getDuplicateHostList() {

        return duplicateHostBhv.selectList(cb -> {

        transaction.name = "\\MAILSLOT\\browse";
        assertEquals("\\MAILSLOT\\browse", transaction.name, "Transaction name should be changeable");
    }

    @Test
    @DisplayName("Test default buffer size constant")
    void testBufferSizeConstant() {
        assertEquals(0xFFFF, SmbComTransaction.TRANSACTION_BUF_SIZE, "TRANSACTION_BUF_SIZE should be 0xFFFF");
    }

    @Test

    }

    public List<TaskSegment> calculateTaskSegments(MavenSession session, List<String> tasks) throws Exception {
        List<TaskSegment> taskSegments = new ArrayList<>(tasks.size());

        TaskSegment currentSegment = null;

        for (String task : tasks) {
            if (isBeforeOrAfterPhase(task)) {
                String prevTask = task;

      assertFailsWith<IOException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom 0!")
        assertThat(expected.suppressed.single()).hasMessage("boom 1!")
      }
    }

    taskFaker.runTasks()
    assertEvents(
      "take plan 0",
      "plan 0 TCP connecting...",
      "plan 0 TCP connect failed",
      "take plan 1",

		// However, for now, we only support using the short username.

		isDN := globalIAMSys.LDAPConfig.ParsesAsDN(targetUser)
		opts.claims[ldapUserN] = targetUser // simple username
		var lookupResult *xldap.DNSearchResult
		lookupResult, targetGroups, err = globalIAMSys.LDAPConfig.LookupUserDN(targetUser)
		if err != nil {
			// if not found, check if DN