Dependency target, Dependency source, boolean sourceDominant, Map<Object, Object> context) {
            List<Exclusion> tgt = target.getExclusions();
            if (tgt.isEmpty()) {
                List<Exclusion> src = source.getExclusions();

                for (Exclusion element : src) {
                    Exclusion clone = element.clone();
                    target.addExclusion(clone);

            "isolatedProjectsIntegTest"
        } else {
            "${testCoverage.testType.asCamelCase()}Test"
        }
    return when {
        subprojects.isEmpty() -> {
            testTaskName
        }

        else -> {
            subprojects.joinToString(" ") { "$it:$testTaskName" }
        }
    }

        assertEquals(pom0Basedir, project1.getParent().getBasedir());
        Map map = project1.getArtifactMap();

        assertNotNull(map, "No artifacts");
        assertFalse(map.isEmpty(), "No Artifacts");
        assertTrue(map.size() == 2, "Set size should be 2, is " + map.size());

        assertTrue(map.containsKey("maven-test:t09-a"), "maven-test:t09-a is not in the project");

        if (entry.getKey().equals(key)) {
          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {
        assertNull(collection);
      } else {
        assertEqualIgnoringOrder(expectedValues, collection);
      }
    }
  }

  @CollectionSize.Require(absent = ZERO)

        }

        boolean system = dependency.getSystemPath() != null
                && !dependency.getSystemPath().isEmpty();

        Map<String, String> props = null;
        if (system) {
            props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, dependency.getSystemPath());
        }

    assertThat(a.eventSequence).isEmpty()
    assertThat(b.takeEvent()).isInstanceOf<CallStart>()
    assertThat(b.eventSequence).isEmpty()
    assertThat(c.takeEvent()).isInstanceOf<CallStart>()
    assertThat(c.eventSequence).isEmpty()
    assertThat(d.takeEvent()).isInstanceOf<CallStart>()
    assertThat(d.eventSequence).isEmpty()
  }

            }
        }

        if (!errors.isEmpty()) {
            def changes = errors + warnings
            return acceptOrReject(member, changes, Violation.error(member, changes.join(" ")))
        }
        if (!warnings.isEmpty()) {
            return Violation.warning(member, warnings.join(" "))
        }
        return null
    }

        if (!loaded.isEmpty()) {
            result.add(new CoreExtensions(file, loaded));
        }

        // user
        file = context.userHomeDirectory.resolve(eff.get(Constants.MAVEN_USER_EXTENSIONS));
        loaded = readCoreExtensionsDescriptorFromFile(file, true);
        if (!loaded.isEmpty()) {
            result.add(new CoreExtensions(file, loaded));
        }

  }

  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.ticker = firstNonNull(builder.ticker, Ticker.systemTicker());
  }

  @Override
  public int size() {
    return cachingHashMap.size();
  }

  @Override
  public boolean isEmpty() {
    return cachingHashMap.isEmpty();
  }

  @Override
  public V get(Object key) {
    checkNotNull(key);
    Timestamped<V> value = cachingHashMap.get(key);

    if (value == null) {