private static final String JAVA_SRC_DIR_PATH = 'src/main/java'

    def "compiler warnings emitted from compilation task are grouped"() {
        given:
        def javaSourceFile = file("$JAVA_SRC_DIR_PATH/MyClass.java")
        def expectedOutput = "${javaSourceFile.absolutePath}:4: warning: [deprecation] Legacy in unnamed package has been deprecated"

#include "mlir/Transforms/Passes.h"  // from @llvm-project
#include "xla/mlir_hlo/mhlo/transforms/passes.h"

namespace mlir::quant::stablehlo {

void AddQuantizationLoweringPasses(mlir::OpPassManager& pm) {
  // These passes are grouped together and must run in this specific order.
  pm.addNestedPass<mlir::func::FuncOp>(CreateConvertTFQuantOpsToMHLOPass());
  pm.addNestedPass<mlir::func::FuncOp>(mhlo::createChloLegalizeToHloPass());

}

// other cases where the fix for this issue affects the error message

const (
	x int = 10 /* ERROR unexpected literal "foo" in grouped declaration; possibly missing semicolon or newline or \) */ "foo"
)

var _ = []int{1, 2, 3 /* ERROR unexpected name int in composite literal; possibly missing comma or } */ int }

type _ struct {

	VB0 int // at end
)

const (
	// Single const declarations inside ()'s are considered ungrouped
	// and show up in sorted order.
	Cungrouped = 0
)

var (
	// Single var declarations inside ()'s are considered ungrouped
	// and show up in sorted order.
	Vungrouped = 0
)

// T2 should be third.
type T2 struct{}

// Grouped types are sorted nevertheless.
type (
	// TG2 should be third.
	TG2 struct{}

 *
 * <p><a id="iteration"></a>
 *
 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
 * current implementations, the iteration order always keeps multiple entries with the same key
 * together. Any creation method that would customarily respect insertion order (such as {@link
 * #copyOf(Multimap)}) instead preserves key-grouped order by inserting entries for an existing key

#include "tensorflow/compiler/jit/compilability_check_util.h"
#include "tensorflow/core/common_runtime/optimization_registry.h"

namespace tensorflow {

// The attribute that marks nodes to be grouped into functions by the
// encapsulate subgraphs pass.
extern const char* const kXlaClusterAttr;

// Marks a subset of nodes in the graph which are to be clustered

import org.gradle.integtests.fixtures.executer.LogContent

abstract class AbstractGroupedProjectConfigureLoggingFunctionalTest extends AbstractConsoleGroupedTaskFunctionalTest {
    def "project configuration messages are grouped"() {
        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildFile << """
            println "root project"
            // Some nested build operations

        then:
        0 * downstreamListener._
    }

    def "forwards log events that are not grouped during execution of build operation that is grouped"() {
        given:

 *
 * <p><a id="iteration"></a>
 *
 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
 * current implementations, the iteration order always keeps multiple entries with the same key
 * together. Any creation method that would customarily respect insertion order (such as {@link
 * #copyOf(Multimap)}) instead preserves key-grouped order by inserting entries for an existing key

        and:
        def pageErrors = []
        def activeGroup = selectInnerTextOf(
            configurationCacheReport,
            "div.group-selector.group-selector--active",
            { pageErrors.add(it) }
        )
        pageErrors == []
        activeGroup == "Problems grouped by message1"
    }

    private String selectInnerTextOf(File configurationCacheReport, String selector, Consumer<String> onPageError) {