// Test unregistration
        assertTrue(mockService.unregisterWitness(regId));
        assertEquals(0, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration(regId));

        // Test duplicate unregistration
        assertFalse(mockService.unregisterWitness(regId));
    }

    @Test
    void testMockServiceNotifications() {
        // Test notification sending (just logs for mock)

            decodedContext.decode(buffer, 0, encoded);

            assertArrayEquals(ciphers, decodedContext.getCiphers());
        }

        @Test
        @DisplayName("Should handle duplicate ciphers")
        void testDuplicateCiphers() throws SMBProtocolDecodingException {
            int[] ciphers = { EncryptionNegotiateContext.CIPHER_AES128_CCM, EncryptionNegotiateContext.CIPHER_AES128_CCM,

 * keys according to the above key ordering, and for each key they iterate across the values
 * according to the value ordering.
 *
 * <p>The multimap does not store duplicate key-value pairs. Adding a new key-value pair equal to an
 * existing key-value pair has no effect.
 *
 * <p>Null keys and values are permitted (provided, of course, that the respective comparators

          Function<? super T, ? extends V> valueFunction) {
    checkNotNull(comparator);
    checkNotNull(keyFunction);
    checkNotNull(valueFunction);
    /*
     * We will always fail if there are duplicate keys, and the keys are always sorted by
     * the Comparator, so the entries can come in an arbitrary order -- so we report UNORDERED.
     */
    return Collector.of(

        map.put(FieldNames.TIMESTAMP, timestamp.toInstant().toEpochMilli());
        return map;
    }

    /**
     * Concatenates values to a destination list, avoiding duplicates.
     * @param dest The destination list.
     * @param newValues The new values to add.
     * @param <T> The type of the values.
     */

"^file:.*"         → fileSystemClient
"^ftp://.*"        → ftpClient
"^smb://.*"        → smbClient
"^storage://.*"    → storageClient
```

### Services

**UrlQueueService**: URL queue management (FIFO), duplicate detection via `visited()`
**DataService**: Access result persistence, iteration

**Implementations**:
- `UrlQueueServiceImpl`, `DataServiceImpl`: In-memory (default)

    }
  }

  // TODO: test adding element of wrong type

  /**
   * Returns {@link Method} instances for the {@code setCount()} tests that assume multisets support
   * duplicates so that the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getSetCountDuplicateInitializingMethods() {
    return asList(

    return Ordering.from(comparator).immutableSortedCopy((Iterable<@NonNull E>) getDelegate());
  }

  /**
   * Returns an {@code ImmutableSet} containing all of the elements from this fluent iterable with
   * duplicates removed.
   *
   * <p><b>{@code Stream} equivalent:</b> pass {@link ImmutableSet#toImmutableSet} to {@code
   * stream.collect()}.
   *
   * @throws NullPointerException if any element is {@code null}

   * collection in unspecified order.
   *
   * @param collection the elements that the set should contain
   * @return a new {@code CompactHashSet} containing those elements (minus duplicates)
   */
  public static <E extends @Nullable Object> CompactHashSet<E> create(
      Collection<? extends E> collection) {
    CompactHashSet<E> set = createWithExpectedSize(collection.size());
    set.addAll(collection);

     */
    public static PathMappingHelper getPathMappingHelper() {
        return getComponent(PATH_MAPPING_HELPER);
    }

    /**
     * Gets the duplicate host helper component.
     * @return The duplicate host helper.
     */
    public static DuplicateHostHelper getDuplicateHostHelper() {
        return getComponent(DUPLICATE_HOST_HELPER);
    }

    /**