System.clearProperty("lasta.env");
        final List<String> ptList = pathMappingHelper.getProcessTypeList();
        assertEquals(2, ptList.size());
        assertTrue(ptList.contains(Constants.PROCESS_TYPE_DISPLAYING));
        assertTrue(ptList.contains(Constants.PROCESS_TYPE_BOTH));
    }

    public void test_getProcessTypeList_nonCrawlerMode() {
        System.setProperty("lasta.env", "other");
        try {

     * @param lang Language
     * @return List of tokens
     */
    protected List<AnalyzeToken> analyzeText(final SuggestAnalyzer analyzer, final String field, final String text, final String lang) {
        final List<AnalyzeToken> tokens = new ArrayList<>();
        final StringBuilder buf = new StringBuilder(maxAnalyzedContentLength);
        for (final String t : text.split("\\s")) {
            buf.append(t).append(' ');

   * the test of {@code Multisets.forSet()} can suppress them.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getIteratorDuplicateInitializingMethods() {
    return asList(
        getMethod(MultisetIteratorTester.class, "testIteratorKnownOrder"),
        getMethod(MultisetIteratorTester.class, "testIteratorUnknownOrder"),

    assertTrue(set.containsAll(asList("b")));
    assertTrue(set.containsAll(asList("b", "b")));
    assertTrue(set.containsAll(asList("b", "f")));
    assertTrue(set.containsAll(asList("b", "f", "a")));
    assertFalse(set.containsAll(asList("d")));
    assertFalse(set.containsAll(asList("z")));
    assertFalse(set.containsAll(asList("b", "d")));
    assertFalse(set.containsAll(asList("f", "d", "a")));
  }

  }

  public void testCopyOf_iterable_notCollection_nonempty() {
    List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
    ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(iterable(list));
    list.set(2, 2.0);
    assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
  }

  public void testCopyOf_iterable_collection_empty() {

  }

  public void testToArray_withNull() {
    List<@Nullable Double> list = Arrays.asList(0.0, 1.0, null);
    assertThrows(NullPointerException.class, () -> Doubles.toArray(list));
  }

  public void testToArray_withConversion() {
    double[] array = {0.0, 1.0, 2.0};

    List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
    List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);

  }

  public void testBuilderAddAll_iterable() {
    List<String> a = asList("a", "b");
    List<String> b = asList("c", "d");
    ImmutableList<String> list = new ImmutableList.Builder<String>().addAll(a).addAll(b).build();
    assertEquals(asList("a", "b", "c", "d"), list);
    b.set(0, "f");
    assertEquals(asList("a", "b", "c", "d"), list);
  }

     * @return a list of WebConfig objects with the specified IDs
     */
    public List<WebConfig> getWebConfigListByIds(final List<String> idList) {
        if (idList == null) {
            return getAllWebConfigList();
        }
        return getAllWebConfigList(true, true, false, idList);
    }

    /**

    doTestToArrayImpl1(Lists.newArrayList(1));
    doTestToArrayImpl1(Lists.<@Nullable Integer>newArrayList(1, null, 3));
  }

  private void doTestToArrayImpl1(List<Integer> list) {
    Object[] reference = list.toArray();
    Object[] target = ObjectArrays.toArrayImpl(list);
    assertEquals(reference.getClass(), target.getClass());
    assertTrue(Arrays.equals(reference, target));
  }

  public void testToArrayImpl2() {

    list.add("cool");
    assertFalse(any(list.iterator(), predicate));
    list.add("pants");
    assertTrue(any(list.iterator(), predicate));
  }

  public void testAll() {
    List<String> list = new ArrayList<>();
    Predicate<String> predicate = equalTo("cool");

    assertTrue(all(list.iterator(), predicate));
    list.add("cool");
    assertTrue(all(list.iterator(), predicate));