0 * _
    }

    def "too many elements are delegated (#current.size() current vs #previous.size() previous items)"() {
        when:
        detector.visitChangesSince(previous, current, "test", visitor)
        then:
        1 * delegate.visitChangesSince(previous, current, "test", visitor)
        0 * _

        where:
        current          | previous
        [one: 1]         | [one: 1, two: 2]

        assertIdsAreShared(scopeIds.ids(1), scopeIds.ids(0))
    }

    void assertIdsAreShared(ScopeIdsFixture.ScopeIds earlier, ScopeIdsFixture.ScopeIds current) {
        assert current.buildInvocation != earlier.buildInvocation
        assert current.workspace == earlier.workspace
        assert current.user == earlier.user
    }

        Method current = methods.get(key);
        if (current == null || shouldReplace(current, method)) {
            // Prefer implementation methods over abstract or bridge methods
            methods.put(key, method);
        }
    }

    private boolean shouldReplace(Method current, Method method) {
        boolean currentAbstract = Modifier.isAbstract(current.getModifiers());

/**
 * Provides information about the current Maven runtime.
 *
 * @since 3.0.2
 */
public interface RuntimeInformation {

    /**
     * Retrieves the current Maven version, for example "3.0.2".
     *
     * @return The current Maven version or an empty string if unknown, never {@code null}.
     */
    String getMavenVersion();

    /**

        }

        Version current;
        try {
            String mavenVersion = getMavenVersion();
            if (mavenVersion.isEmpty()) {
                throw new IllegalArgumentException("Could not determine current Maven version");
            }

            current = versionScheme.parseVersion(mavenVersion);

        changes(
            FileSystemSnapshot.EMPTY,
            FileSystemSnapshot.EMPTY
        ) == []
    }

    def "equal hash for #current.type"() {
        expect:
        changes(previous, current) == []

        where:
        previous                        | current
        regularFile("one", 0x1234)      | regularFile("one", 0x1234)
        missing("one")                  | missing("one")

          double z = aa.getAndAdd(i, y);
          assertBitEquals(x, z);
          assertBitEquals(x + y, aa.get(i));
        }
      }
    }
  }

  /** addAndGet adds given value to current, and returns current value */
  public void testAddAndGet() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i : new int[] {0, SIZE - 1}) {
      for (double x : VALUES) {
        for (double y : VALUES) {

     * Returns the given action when there is no current application.
     */
    <T> Action<T> reapplyCurrentLater(Action<T> action);

    /**
     * Returns details of the current application, if any.
     */
    @Nullable
    Application current();

    /**

    }

    public boolean visitChangesSince(C previous, C current, String propertyTitle, ChangeVisitor visitor) {
        if (Iterables.elementsEqual(rootHasher.apply(previous).entries(), rootHasher.apply(current).entries())) {
            return true;
        }
        return changeDetector.visitChangesSince(indexer.apply(previous), indexer.apply(current), propertyTitle, visitor);
    }

    public interface ChangeDetector<S> {

 * The warnings are produced by the Kotlin compiler when mixing Java versions:
 * <ul>
 *     <li>'compileJava' task (current target is 16) and 'compileKotlin' task (current target is 1.8) jvm target compatibility should be set to the same Java version.</li>
 *     <li>'compileTestJava' task (current target is 16) and 'compileTestKotlin' task (current target is 1.8) jvm target compatibility should be set to the same Java version.</li>
 * </ul>
 * */