}
        }

        val becameIdle =
          (finishedCall != null || finishedAsyncCall != null) &&
            (executorIsShutdown || runningAsyncCalls.isEmpty()) &&
            runningSyncCalls.isEmpty()
        val idleCallbackToRun = if (becameIdle) idleCallback else null

        if (executorIsShutdown) {
          return@synchronized Effects(
            callsToExecute =

    public ImmutableBiMap<K, V> build() {
      return buildOrThrow();
    }

    @Override
    public ImmutableBiMap<K, V> buildOrThrow() {
      ImmutableMap<K, V> map = super.buildOrThrow();
      if (map.isEmpty()) {
        return of();
      }
      return new RegularImmutableBiMap<K, V>(super.buildOrThrow());
    }

    @Override
    ImmutableBiMap<K, V> buildJdkBacked() {
      return build();
    }

    @Override
    public Artifact createPluginArtifact(Plugin plugin) {
        VersionRange versionRange;
        try {
            String version = plugin.getVersion();
            if (version == null || version.isEmpty()) {
                version = "RELEASE";
            }
            versionRange = VersionRange.createFromVersionSpec(version);
        } catch (InvalidVersionSpecificationException e) {
            return null;

  }

  public void testIsEmpty() {
    Iterable<String> emptyList = emptyList();
    assertTrue(Iterables.isEmpty(emptyList));

    Iterable<String> singletonList = singletonList("foo");
    assertFalse(Iterables.isEmpty(singletonList));
  }

  public void testSkip_simple() {
    Collection<String> set = ImmutableSet.of("a", "b", "c", "d", "e");

    assertEquals(expected, Optional.of("a").asSet());
  }

  public void testAsSet_absent() {
    assertTrue("Returned set should be empty", Optional.absent().asSet().isEmpty());
  }

  public void testAsSet_presentIsImmutable() {
    Set<String> presentAsSet = Optional.of("a").asSet();
    assertThrows(UnsupportedOperationException.class, () -> presentAsSet.add("b"));
  }

            return;
        }

        if (value instanceof Entity) {
            data.register(key, BeanUtil.copyBeanToNewMap(value));
        } else {
            if (value instanceof final Collection<?> coll && !coll.isEmpty()) {
                // care performance for List that the most frequent pattern
                final Object first = coll instanceof List<?> ? ((List<?>) coll).get(0) : coll.iterator().next();

        while (lines.hasNext()) {
            String line = lines.next();
            if (end.matcher(line).matches()) {
                return;
            }
            if (line.isEmpty()) {
                continue;
            }
            if (false == line.startsWith(leadingSpaces)) {
                log.accept(lines.lastLineNumber, "snippet line should start with [" + leadingSpaces + "]");

            List<ArtifactRepository> requestRepositories, List<ArtifactRepository> pomRepositories) {
        List<ArtifactRepository> repositories = requestRepositories;

        if (pomRepositories != null && !pomRepositories.isEmpty()) {
            Map<String, ArtifactRepository> repos = new LinkedHashMap<>();

            for (ArtifactRepository repo : requestRepositories) {
                if (!repos.containsKey(repo.getId())) {

        assertNotNull(queryMap);
        assertTrue(queryMap instanceof LinkedHashMap);
        assertTrue(queryMap.isEmpty());
    }

    @Test
    public void test_addQuery() {
        assertTrue(facetQueryView.getQueryMap().isEmpty());

        facetQueryView.addQuery("key1", "query1");
        assertEquals(1, facetQueryView.getQueryMap().size());

        multimap.asMap().entrySet(), immutableEntry(sampleKey, sampleValueAsCollection));

    // Test #values()

    assertMultimapRemainsUnmodified(multimap, originalEntries);
    if (!multimap.isEmpty()) {
      Collection<V> values = multimap.asMap().entrySet().iterator().next().getValue();

      assertCollectionIsUnmodifiable(values, sampleValue);
    }

    // Test #entries()