/**
     * Constructs KerberosRelevantAuthData from token bytes.
     *
     * @param token the authorization data token
     * @param keys map of Kerberos keys indexed by key type
     * @throws PACDecodingException if decoding fails
     */
    public KerberosRelevantAuthData(byte[] token, Map<Integer, KerberosKey> keys) throws PACDecodingException {
        ASN1Sequence authSequence;
        try {

    private List<ArtifactTransformation> artifactTransformations;

    @Inject
    public DefaultArtifactTransformationManager(Map<String, ArtifactTransformation> artifactTransformations) {
        this.artifactTransformations = Stream.of("release", "latest", "snapshot")
                .map(artifactTransformations::get)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    @Override

            concreteImplementation.setKey(key);
            assertEquals(key, concreteImplementation.getKey());
        }

        @Test
        @DisplayName("Should set cache map")
        void testSetCacheMap() {
            Map<String, DfsReferralDataInternal> cacheMap = new HashMap<>();

            // Test with mock
            doNothing().when(mockReferralData).setCacheMap(cacheMap);

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.client.smb;

import java.util.HashMap;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * Holds a map of SMB authentication configurations, allowing retrieval of the appropriate
 * authentication based on a given path.
 *

     * Returns the key type if this field is a parameterized {@link Map}.
     *
     * @return the key type if this field is a parameterized {@link Map}, otherwise {@literal null}
     */
    Class<?> getKeyClassOfMap();

    /**
     * Returns the value type if this field is a parameterized {@link Map}.
     *
     * @return the value type if this field is a parameterized {@link Map}, otherwise {@literal null}
     */

     *
     * @return the key type if this property is a parameterized {@link Map}, otherwise {@literal null}
     */
    Class<?> getKeyClassOfMap();

    /**
     * Returns the value type if this property is a parameterized {@link Map}.
     *
     * @return the value type if this property is a parameterized {@link Map}, otherwise {@literal null}
     */

  }

  private void assertMapSize(Map<?, ?> map, int size) {
    assertThat(map).hasSize(size);
    if (size > 0) {
      assertThat(map.isEmpty()).isFalse();
    } else {
      assertThat(map.isEmpty()).isTrue();
    }
    assertCollectionSize(map.keySet(), size);
    assertCollectionSize(map.entrySet(), size);
    assertCollectionSize(map.values(), size);
  }

        c2.setCollectedProjects(List.of());
        MavenProject p = new MavenProject();
        p.setArtifactId("p");
        p.setCollectedProjects(List.of(c1, c2));
        Map<MavenProject, List<MavenProject>> projects = Map.of(p, List.of(), c1, List.of(), c2, List.of());

        BuildPlan plan = calculateLifecycleMappings(projects, "all");
        assertNotNull(plan);

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;

import org.codelibs.fess.crawler.Constants;
import org.codelibs.fess.crawler.entity.AccessResultImpl;
import org.codelibs.fess.crawler.entity.UrlQueueImpl;

    ConcurrentMap<String, AtomicInteger> map = new MapMaker().makeMap();
    multiset = ConcurrentHashMultiset.create(map);
    reserializeAndAssert(multiset);
  }

  public void testSerializationWithMapMaker2() {
    ConcurrentMap<String, AtomicInteger> map = new MapMaker().makeMap();
    multiset = ConcurrentHashMultiset.create(map);
    multiset.addAll(ImmutableList.of("a", "a", "b", "c", "d", "b"));