func f() {
	var _ int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context|multiple-value "
	var a int = three() // ERROR "assignment mismatch: 1 variable but three returns 3 values|multiple-value function call in single-value context|multiple-value "

 */
public interface PmdReports extends ReportContainer<SingleFileReport> {

    /**
     * The pmd (single file) HTML report
     *
     * @return The pmd (single file) HTML report
     */
    @Internal
    SingleFileReport getHtml();

    /**
     * The pmd (single file) XML report
     *
     * @return The pmd (single file) XML report
     */
    @Internal
    SingleFileReport getXml();

constexpr char kInvalidExecutorGraphMsg[] =
    "functions must be of a single Graph with single op Islands: ";

}  // namespace

mlir::LogicalResult VerifyExportSuitable(mlir::ModuleOp module) {
  mlir::WalkResult result = module.walk([&](mlir::func::FuncOp function) {
    if (!llvm::hasSingleElement(function)) {
      function.emitError(kInvalidExecutorGraphMsg)
          << "only single block functions are supported";

		anywhere in the text of a single document.
		<pre>Fess AND CodeLibs</pre>
	</dd>
	</dd>
	<dt>OR</dt>
	<dd>
		OR operator matches documents where any terms exist anywhere in the
		text of a single document.
		<pre>Fess OR CodeLibs</pre>
	</dd>
	<dt>Wildcard</dt>
	<dd>
		single and multiple character wildcard searches within single terms

        CapabilitiesConflictHandler.CandidateDetails single = null;
        for (Capability capabilityVersion : capabilityVersions) {
            Collection<? extends CapabilitiesConflictHandler.CandidateDetails> candidates = details.getCandidates(capabilityVersion);
            int size = candidates.size();
            if (size >= 1) {
                if (size == 1 && single == null) {
                    single = candidates.iterator().next();

            """.trimIndent(),
            resolver
        )

        val unresolvedFunctionCall = result.errors.single { it.errorReason is ErrorReason.UnresolvedFunctionCallSignature }.element as FunctionCall
        val assignmentInBlock = (unresolvedFunctionCall.args.single() as FunctionArgument.Lambda).block.statements.single() as Assignment

            .mutate(FlavorContainer) { it.add named(Flavor, "flavor1") }

        then:
        single(toolChains).name == 'tc'
        platforms.size() == 1
        single(buildTypes).name == 'bt'
        single(flavors).name == 'flavor1'
    }

    def "creates binaries for executable"() {
        when:
        project.pluginManager.apply(NativeComponentModelPlugin)

		availableCPUs cpuset.CPUSet
		expect        []int
	}{
		{
			"single socket HT, 4 cores free",
			topoSingleSocketHT,
			cpuset.New(0, 1, 2, 3, 4, 5, 6, 7),
			[]int{0, 1, 2, 3},
		},
		{
			"single socket HT, 3 cores free",
			topoSingleSocketHT,
			cpuset.New(0, 1, 2, 4, 5, 6),
			[]int{0, 1, 2},
		},
		{
			"single socket HT, 3 cores free (1 partially consumed)",
			topoSingleSocketHT,

        def java = events.operation("Apply plugin org.gradle.java to root project 'single'")
        def javaBase = events.operation("Apply plugin org.gradle.api.plugins.JavaBasePlugin to root project 'single'")
        def base = events.operation("Apply plugin org.gradle.api.plugins.BasePlugin to root project 'single'")

        help.parent == configureRootProject

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * Single entry module library
 */
public class SingleEntryModuleLibrary extends ModuleLibrary {

    private ModuleVersionIdentifier moduleVersion;

    /**
     * Creates single entry module library
     *
     * @param library a path to jar or class folder in idea format