}

  @Override
  public int count(@Nullable Object element) {
    @Nullable ImmutableEntry<?>[] hashTable = this.hashTable;
    if (element == null || hashTable.length == 0) {
      return 0;
    }
    int hash = smearedHash(element);
    int mask = hashTable.length - 1;
    for (ImmutableEntry<?> entry = hashTable[hash & mask];
        entry != null;
        entry = entry.nextInBucket()) {

          ImmutableSet<E> result;
          if (hashTable != null && chooseTableSize(size) == hashTable.length) {
            @Nullable Object[] uniqueElements =
                shouldTrim(size, contents.length) ? Arrays.copyOf(contents, size) : contents;
            result =
                new RegularImmutableSet<E>(
                    uniqueElements, hashCode, hashTable, hashTable.length - 1, size);
          } else {

     * @return The environment for LDAP connection.
     */
    protected Hashtable<String, String> createEnvironment(final String initialContextFactory, final String securityAuthentication,
            final String providerUrl, final String principal, final String credntials) {
        final Hashtable<String, String> env = new Hashtable<>();
        putEnv(env, Context.INITIAL_CONTEXT_FACTORY, initialContextFactory);

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.ldap;

import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.Arrays;
import java.util.Hashtable;

import org.apache.commons.lang3.ArrayUtils;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.entity.FessUser;
import org.codelibs.fess.mylasta.action.FessUserBean;

     *
     * @param <KEY> the key type of the <code>Map</code>
     * @param <VALUE> the value type of the <code>Map</code>
     * @param key the key to be added to the <code>Map</code>
     * @param value the value to be added to the <code>Map</code>
     * @return a {@literal Maps} for constructing a {@link Hashtable} with the specified key and value
     */

    }
  }

  /**
   * Returns a larger power of 2 hashtable size given the current mask.
   *
   * <p>For hashtable sizes less than or equal to 32, the returned power of 2 is 4x the current
   * hashtable size to reduce expensive rehashing. Otherwise the returned power of 2 is 2x the
   * current hashtable size.
   */
  static int newCapacity(int mask) {
    return ((mask < 32) ? 4 : 2) * (mask + 1);

        // Test getEnvironment returns the correct environment
        Hashtable<String, String> env = ldapUser.getEnvironment();
        assertSame(testEnv, env);
        assertEquals("test.value", env.get("test.key"));

        // Test with empty environment
        Hashtable<String, String> emptyEnv = new Hashtable<>();
        LdapUser user = new LdapUser(emptyEnv, "user");

            new TestStringMapGenerator() {
              @Override
              // We are testing Hashtable / testing our tests on Hashtable.
              @SuppressWarnings("JdkObsolete")
              protected Map<String, String> create(Entry<String, String>[] entries) {
                return populate(new Hashtable<String, String>(), entries);
              }
            })
        .withFeatures(

 */
package org.codelibs.core.naming;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.Hashtable;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.codelibs.core.exception.NamingRuntimeException;

/**

            new TestStringMapGenerator() {
              @Override
              // We are testing Hashtable / testing our tests on Hashtable.
              @SuppressWarnings("JdkObsolete")
              protected Map<String, String> create(Entry<String, String>[] entries) {
                return populate(new Hashtable<String, String>(), entries);
              }
            })
        .withFeatures(