if (match == null) {
            throw new AssertionFailedError("""Could not find problems summary in output:
${text}
""")
        }

        def summary = match.right
        def matcher = headerPattern.matcher(summary.first)
        assert matcher.matches()
        def totalProblems = matcher.group(1).toInteger()

        this.selected = selected;
        this.replaced = computeReplaced(selected);

        doRestart(selected);
    }

    private boolean computeReplaced(ComponentState selected) {
        // This module might be resolved to a different module, through replacedBy
        return !selected.getId().getModule().equals(getId());
    }

    private void doRestart(ComponentState selected) {

----
====

This feature is helpful if you work with tasks provided by Gradle.

            }
        """
    }

    def removeTestClass() {
        // Removes MyTest.class to trigger a new build because it's input of test task.
        // Previously we made changes to the source files, but that might trigger
        // two builds - one is from `MyTest.java` change, another one is from
        // `MyTest.class` change. The timing of these two builds and cancellation
        // resulted in flakiness. To resolve this issue,

        sourceSets.all(sourceSet -> buildOutputCleanupRegistry.registerOutputs(sourceSet.getOutput()));
    }

    /**
     * Unless there are other concerns, we'd prefer to run jar tasks prior to test tasks, as this might offer a small performance improvement
     * for common usage.  In practice, running test tasks tends to take longer than building a jar; especially as a project matures. If tasks

    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory);

// If *pstr starts with the given prefix, modifies *pstr to be right
// past the prefix and returns true; otherwise leaves *pstr unchanged
// and returns false.  None of pstr, *pstr, and prefix can be NULL.
GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);

        expect:
        def result = resolve(include('TEST(FILE, NAME)'))
        result.complete
        result.files.file as List == [header]
    }

    def "right-hand side of token concatenation can be empty"() {
        given:
        def header = systemIncludeDir.createFile("test.h")

        macros << macro("FILENAME", '<test.h>')

        if (leftArg == null) return tree.parsingError(node, "Missing left hand side in binary expression")
        if (rightArg == null) return tree.parsingError(node, "Missing right hand side in binary expression")

        return when (operationToken) {
            EQ -> elementOrFailure {
                val lhs = checkForFailure(propertyAccessStatement(tree, leftArg!!))

                printForCopyInTest()
            }
            assert actualMessage == expected
        }

        private void printForCopyInTest() {
            println("Incorrect test expectation. You might want to verify this message an copy this expectation in the test if you changed the rendering:")
            println()
            println('outputEquals """')
            println(actualMessage)
            println('"""')

The "architecture" dimension covers processor architectures like x86-64 and PowerPC.

A variant is a combination of values for these dimensions, consisting of exactly one value for each dimension.
You might have a "debug x86-64" or a "release PowerPC" variant.

Gradle has built-in support for several dimensions and several values within each dimension.