return session;
    }

    private DeployRequest createDeployRequestWithConsumerPom() {
        DeployRequest request = new DeployRequest();
        List<Artifact> artifacts = List.of(
                new DefaultArtifact("com.example", "test", "", "jar", "1.0.0"),
                new DefaultArtifact("com.example", "test", "", "pom", "1.0.0"), // main POM

                return null;
            }
        };

        assertNull(extractorFactory.getExtractor("test"));
        final List<String> list = new ArrayList<String>();
        list.add("test");
        extractorFactory.addExtractor(list, extractor);
        assertEquals(extractor, extractorFactory.getExtractor("test"));
    }

    public void test_getExtractor() {
        String key;

     * @throws Exception
     */
    @Test
    public void testToList() throws Exception {
        final Object a = new int[] { 1, 5 };
        final List<Integer> list = ArrayUtil.toList(a);
        assertThat(list.get(0), is(Integer.valueOf(1)));
        assertThat(list.get(1), is(Integer.valueOf(5)));
    }

    /**
     *
     */
    @Test
    public void testIsArray() {

    ALL_INTEGER_CANDIDATES = Iterables.concat(NONZERO_INTEGER_CANDIDATES, ImmutableList.of(0));
  }

  /*
   * This list contains values that attempt to provoke overflow in long operations. It contains
   * positive values on or near 2^N for N near multiples of 8 (near byte boundaries). This list is
   * a superset of POSITIVE_INTEGER_CANDIDATES.
   */
  static final ImmutableSet<Long> POSITIVE_LONG_CANDIDATES;

        .plus(Integer::class, 5 as Integer)
    assertThat(tags[String::class]).isEqualTo("hello")
    assertThat(tags[Integer::class]).isEqualTo(5)
  }

  /** The implementation retains no nodes from the original linked list. */
  @Test
  fun replaceFirstElement() {
    val tags =
      EmptyTags
        .plus(String::class, "a")
        .plus(Integer::class, 5 as Integer)
        .plus(Boolean::class, true)

    private static final Logger logger = LogManager.getLogger(DictionaryManager.class);

    /** List of dictionary creators for handling different dictionary types */
    protected List<DictionaryCreator> creatorList = new ArrayList<>();

    /**
     * Default constructor for DictionaryManager.
     * Creates a new dictionary manager with an empty creator list.
     */
    public DictionaryManager() {
        // Default constructor
    }

     * deduped.
     *
     * TODO: See if duped headers should be preserved on decode and verify.
     */
    private fun assertSetEquals(
      message: String,
      expected: List<Header>,
      observed: List<Header>,
    ) {
      assertThat(LinkedHashSet(observed), message)
        .isEqualTo(LinkedHashSet(expected))
    }
  }

    chain: Array<out X509Certificate>,
    authType: String,
    host: String,
  ): List<Certificate> {
    if (host in insecureHosts) return listOf()
    try {
      val method =
        checkServerTrustedMethod
          ?: throw CertificateException("Failed to call checkServerTrusted")
      return method.invoke(delegate, chain, authType, host) as List<Certificate>
    } catch (e: InvocationTargetException) {
      throw e.targetException

   * Callers of TestContainerGenerator.order need to be prepared for implementations to return a new
   * collection.
   */
  @SuppressWarnings("CanIgnoreReturnValueSuggester")
  @Override
  public List<AnEnum> order(List<AnEnum> insertionOrder) {
    sort(insertionOrder);
    return insertionOrder;
  }

    public interface Hoge {

        /** */
        public static Map<String, Set<Integer>[]> foo = null;

        /**
         * @param arg1
         * @param arg2
         * @return List
         */
        List<String> foo(Set<Integer> arg1, Map<String, Integer> arg2);
    }