}

    public static Number getConfidencePercentage(MeasuredOperationList baseline, MeasuredOperationList current) {
        if (baseline.isEmpty() || current.isEmpty()) {
            // This is a workaround for https://github.com/gradle/gradle-private/issues/1690
            return new BigDecimal(0);
        }

            // The file pom may not contain the modelVersion yet, as it may be set later by the
            // ModelVersionXMLFilter.
            if (m.getModelVersion() != null && !m.getModelVersion().isEmpty()) {
                validateModelVersion(problems, m.getModelVersion(), m, VALID_MODEL_VERSIONS);
            }

            validateStringNoExpression("groupId", problems, Severity.WARNING, Version.V20, m.getGroupId(), m);

            .collect(Collectors.toList());

        StyledTextOutput styledTextOutput = getRenderer().getTextOutput();
        if (!softwareTypes.isEmpty()) {
            renderSectionTitle("Available software types");
            styledTextOutput.println();

            softwareTypes.forEach(type -> {

                Integer depth = usages.remove(Thread.currentThread());
                if (depth > 1) {
                    usages.put(Thread.currentThread(), depth - 1);
                }
                if (usages.isEmpty()) {
                    condition.signalAll();
                    if (state == State.STOPPING) {
                        state = State.STOPPED;
                    }
                }
            } finally {

            classpath.addAll(workerMainClassPath);
        }
        modulePath.addAll(applicationModulePath);
        classpath.addAll(applicationClasspath);

        if (!modulePath.isEmpty() && implementationModulePath != null && !implementationModulePath.isEmpty()) {
            // We add the implementation module path as well, as we do not load modules dynamically through a separate class loader in the worker.

        Preconditions.checkArgument(pattern != null && !pattern.isEmpty(), "pattern must not be null or empty");
        return withPattern(Pattern.compile(pattern), 1);
    }

    public static ExpectedDeprecationWarning withMultiLinePattern(String pattern, int numLines) {
        Preconditions.checkArgument(pattern != null && !pattern.isEmpty(), "pattern must not be null or empty");

    Optional<Object> getOptional() {
      if (extras.isEmpty()) {
        return Optional.ofNullable(element);
      } else {
        throw multiples(false);
      }
    }

    Object getElement() {
      if (element == null) {
        throw new NoSuchElementException();
      } else if (extras.isEmpty()) {
        return element;
      } else {
        throw multiples(false);

            return Iterators.size(iterator());
          }

          @Override
          public boolean isEmpty() {
            return !iterator().hasNext();
          }
        };
      }

      Iterator<Entry<Range<K>, V>> entryIterator() {
        if (subRange.isEmpty()) {
          return Iterators.emptyIterator();
        }
        Cut<K> cutToStart =
            MoreObjects.firstNonNull(

        if (versioning.getRelease() != null && !versioning.getRelease().isEmpty()) {
            merge(RELEASE, infos, versioning.getLastUpdated(), versioning.getRelease(), repository);
        }

        if (versioning.getLatest() != null && !versioning.getLatest().isEmpty()) {
            merge(LATEST, infos, versioning.getLastUpdated(), versioning.getLatest(), repository);
        }

    @Override
    protected void merge(Metadata recessive) {
        List<Plugin> recessivePlugins = recessive.getPlugins();
        List<Plugin> plugins = metadata.getPlugins();
        if (!recessivePlugins.isEmpty() || !plugins.isEmpty()) {
            LinkedHashMap<String, Plugin> mergedPlugins = new LinkedHashMap<>();
            recessivePlugins.forEach(p -> mergedPlugins.put(p.getPrefix(), p));