* AtomicInteger).
   */

  /** The number of occurrences of each element. */
  private final transient ConcurrentMap<E, AtomicInteger> countMap;

  /**
   * An instance created in {@link #readObject} to be returned from {@link #readResolve}. This field
   * is used only by those methods, and it is never set in a "normal" instance.
   *

     * and immediately refreshes the index to ensure the change is visible.
     * If the configuration already exists (based on ID), it will be updated;
     * otherwise, a new configuration will be created.</p>
     *
     * @param dataConfig the data configuration to store
     * @throws IllegalArgumentException if dataConfig is null
     */
    public void store(final DataConfig dataConfig) {

        this.rdmaProvider = RdmaProviderFactory.getProvider(context.getConfig());
        this.bufferManager = new RdmaBufferManager(rdmaProvider);
        this.statistics = new RdmaStatistics();

        log.debug("Created RDMA transport with provider: {}", rdmaProvider.getClass().getSimpleName());
    }

    /**
     * Establishes RDMA connection to the remote server.
     *
     * @throws IOException if connection fails
     */

     *
     * @param form the create form containing synonym data
     * @param hook the validation error hook for handling errors
     * @return OptionalEntity containing the created synonym item or empty if creation failed
     */
    protected OptionalEntity<SynonymItem> createSynonymItem(final CreateForm form, final VaErrorHook hook) {
        try {

  }

  public void testConcatPeformingFiniteCycle() {
    Iterable<Integer> iterable = asList(1, 2, 3);
    int n = 4;
    Iterable<Integer> repeated = Iterables.concat(nCopies(n, iterable));
    assertThat(repeated).containsExactly(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3).inOrder();
  }

  public void testPartition_badSize() {
    Iterable<Integer> source = singleton(1);

     *
     * @return error count
     */
    public long getOperationErrors() {
        return operationErrors.get();
    }

    /**
     * Get total number of connections created
     *
     * @return connection count
     */
    public long getConnectionsCreated() {
        return connectionsCreated.get();
    }

    /**
     * Get number of currently active connections

 * </pre>
 *
 * @author koichik
 * @param <K> the key type of the {@literal Map}
 * @param <V> the value type of the {@literal Map}
 */
public class Maps<K, V> {

    /** The target <code>Map</code> to be created. */
    protected Map<K, V> map;

    /**
     * Returns a {@literal Maps} for constructing a {@link Map} with the specified key and value.
     *
     * @param <KEY> the key type of the <code>Map</code>

        }
    }

    @Test
    public void testFileBasedCacheWithEmptyFile() throws IOException {
        tempFile = File.createTempFile("empty", ".tmp", Curl.tmpDir);
        // File is created but empty

        ContentCache cache = new ContentCache(tempFile);

        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);

        getRole(form).ifPresent(entity -> {
            try {
                roleService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
                logger.info("Created role: {}", entity.getName());
            } catch (final Exception e) {
                logger.warn("Failed to create role: {}", form.name, e);

    /**
     * Creates a user bean from the given user entity.
     *
     * @param user the user entity to create a bean from
     * @return the created user bean
     */
    @Override
    protected FessUserBean createUserBean(final FessUser user) {
        return new FessUserBean(user);
    }

    /**