assertThat(ClassPath.getClassPathFromManifest(new File("some.jar"), null)).isEmpty();
  }

  public void testGetClassPathFromManifest_noClassPath() throws IOException {
    File jarFile = new File("base.jar");
    assertThat(ClassPath.getClassPathFromManifest(jarFile, manifest(""))).isEmpty();
  }

  public void testGetClassPathFromManifest_emptyClassPath() throws IOException {

  protected AbstractMapBasedMultimap(Map<K, Collection<V>> map) {
    checkArgument(map.isEmpty());
    this.map = map;
  }

  /** Used during deserialization only. */
  final void setMap(Map<K, Collection<V>> map) {
    this.map = map;
    totalSize = 0;
    for (Collection<V> values : map.values()) {
      checkArgument(!values.isEmpty());
      totalSize += values.size();
    }
  }

  /**

  }

  public void testIsEmpty() {
    assertThat(ImmutableLongArray.of().isEmpty()).isTrue();
    assertThat(ImmutableLongArray.of(0).isEmpty()).isFalse();
    assertThat(ImmutableLongArray.of(0, 1, 3).isEmpty()).isFalse();
    assertThat(ImmutableLongArray.of(0, 1, 3).subArray(1, 1).isEmpty()).isTrue();
    assertThat(ImmutableLongArray.of(0, 1, 3).subArray(1, 2).isEmpty()).isFalse();
  }

  public void testGet_good() {

        this.took = took;
        if (errors != null && !errors.isEmpty()) {
            this.errors.addAll(errors);
        }
    }

    /**
     * Checks if the response has any errors.
     * @return True if there are errors, false otherwise.
     */
    public boolean hasError() {
        return !errors.isEmpty();
    }

    /**
     * Returns the list of errors.

            }
        }
        if (!unresolvedSelectors.isEmpty()) {
            String requiredSelectors = unresolvedSelectors.stream()
                    .filter(pas -> !pas.activationSettings().optional())
                    .map(ProjectActivation.ProjectActivationSettings::selector)
                    .collect(Collectors.joining(", "));
            if (!requiredSelectors.isEmpty()) {
                throw new MavenExecutionException(

     */
    public static RelevanceEvaluationResult withRelevantDocs(final List<String> relevantDocIds, final List<Integer> relevantIndexes) {
        final boolean hasRelevant = relevantDocIds != null && !relevantDocIds.isEmpty();
        return new RelevanceEvaluationResult(relevantDocIds, relevantIndexes, hasRelevant);
    }

    /**
     * Creates a result with no relevant documents found.
     *

            assertFalse(content.contains("${fess.dictionary.path}"));
        } finally {
            // Restore original property
            if (originalPath.isEmpty()) {
                System.clearProperty("fess.dictionary.path");
            } else {
                System.setProperty("fess.dictionary.path", originalPath);
            }
        }
    }

    @Test

        if (missingClassExcludes == null && (missingClasses.isEmpty() == false)) {
            getLogger().info("Found missing classes, but task is configured to ignore all of them:\n {}", formatClassList(missingClasses));
            missingClasses.clear();
        }

        violationsClasses.removeAll(violationsExcludes);
        if (missingClasses.isEmpty() && violationsClasses.isEmpty()) {

      if (connections.isEmpty()) cleanupQueue.cancelAll()
      true
    } else {
      scheduleCloser()
      false
    }
  }

  fun evictAll() {
    val i = connections.iterator()
    while (i.hasNext()) {
      val connection = i.next()
      val socketToClose =
        connection.withLock {
          if (connection.calls.isEmpty()) {
            i.remove()

        assertEquals("", fieldsStr);
        String[] fields = fieldsStr.isEmpty() ? new String[0] : fieldsStr.split(",");
        assertEquals(0, fields.length);
    }

    @Test
    public void test_indexAdminFloatFields() {
        String fieldsStr = fessConfig.getIndexAdminFloatFields();
        assertEquals("", fieldsStr);
        String[] fields = fieldsStr.isEmpty() ? new String[0] : fieldsStr.split(",");