(locations[1] as LineInFileLocation).path == "build file '$buildFile.path'"
            definition.severity == Severity.WARNING
            solutions.size() == 1
            solutions[0].solution == 'try this instead'
        }

        where:
        detailsConfig              | expectedDetails | documentationConfig                         | expecteDocumentation

                    .solution(String.format("Make '%s' implement '%s'", typeVariables.get(0).getName(), BuildService.class.getName()))

     *
     * @return the locations
     * @since 8.8
     */
    List<Location> getLocations();

    /**
     * Returns the list of solutions.
     *
     * @return the solutions
     * @since 8.8
     */
    List<Solution> getSolutions();

    /**
     * Returns the failure associated with this problem.
     *
     * @return the failure
     * @since 8.8
     */
    @Nullable

                            .solution("Add " + disableCachingAnnotation + "(because = ...)")
                            .solution("Add " + cacheableAnnotation);
                        if (isTask) {
                            builder.solution("Add " + untrackedTaskAnnotation + "(because = ...)");
                        }
                    }

                        debug
                        release
                    }
                }
            }
        """
    }

    @ToBeFixedForConfigurationCache
    def "create visual studio solution for executable that depends on a library in another project"() {
        when:
        app.executable.writeSources(file("exe/src/main"))
        app.library.writeSources(file("lib/src/hello"))

import org.gradle.ide.visualstudio.VisualStudioSolution;

import java.util.List;

public interface VisualStudioSolutionInternal extends VisualStudioSolution {
    /**
     * The list of project artifacts included in this solution.
     */
    List<VisualStudioProjectMetadata> getProjects();

    /**
     * Adds tasks required to build this component.
     */
    void builtBy(Object... tasks);

    return least(k, comparator.reversed());
  }

  /**
   * Returns the minimum of the two values. If the values compare as 0, the first is returned.
   *
   * <p>The recommended solution for finding the {@code minimum} of some values depends on the type
   * of your data and the number of elements you have. Read more in the Guava User Guide article on

		for idx, item := range classes {
			ans[idx] = item.upperBound
		}
		return ans, ubRange.max, nil
	}
	// Now we know the solution is a unique fairProp in [lbRange.min, ubRange.max].
	// See if the solution does not run into any bounds.
	fairProp := requiredSumF / targetSum
	if lbRange.max <= fairProp && fairProp <= ubRange.min { // no bounds matter
		for idx := range classes {

                .contextualLabel("The 'standard-plugin' is deprecated")
                .documentedAt("https://github.com/gradle/gradle/README.md")
                .severity(Severity.WARNING)
                .solution("Please use a more recent plugin version")
        );
        // end::problems-api-report[]
    }

     * Meant to be used only for resolving dependencies.
     */
    public static final ConfigurationRole RESOLVABLE = createNonDeprecatedRole("Resolvable", false, true, false);

    /**
     * Meant as a temporary solution for situations where we need to declare dependencies against a resolvable configuration.
     *