]
                }
              ]
            }
          },
          "current": {
            "value": "0",
            "averageValue": "0",
            "averageUtilization": 3
          }
        },
        "resource": {
          "name": "nameValue",
          "current": {
            "value": "0",
            "averageValue": "0",
            "averageUtilization": 3

                  ]
                }
              ]
            }
          },
          "current": {
            "value": "0",
            "averageValue": "0",
            "averageUtilization": 3
          }
        },
        "resource": {
          "name": "nameValue",
          "current": {
            "value": "0",
            "averageValue": "0",
            "averageUtilization": 3

        expect:
        JavaVersion.current() == current
        JavaVersion.current().java6 == isJava6
        JavaVersion.current().java7 == isJava7
        JavaVersion.current().java8 == isJava8
        JavaVersion.current().java9 == isJava9
        JavaVersion.current().java10 == isJava10
        JavaVersion.current().java11 == isJava11
        JavaVersion.current().java12 == isJava12

        and:

        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]

        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) {

    }

    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> {