}

var _ = []T{
	// lone comments
	// in composite lit
}

var _ = [][]T{
	{
		// lone comments
		// in composite lit
	},
}

// TODO: gofmt doesn't add these tabs; make it so that these golden
// tests run the printer in a way that it's exactly like gofmt.

var _ = []T{	// lone comment
}

var _ = []T{	// lone comments
	// in composite lit
}

func _()	{}

func _()	{}

	kind := t.Kind_ & abi.KindMask
	if kind == abi.Array || kind == abi.Struct {
		// for composite objects we have to read every address
		// because a write might happen to any subobject.
		racereadrangepc(addr, t.Size_, callerpc, pc)
	} else {
		// for non-composite objects we can read just the start
		// address, as any write must write the first byte.
		racereadpc(addr, callerpc, pc)
	}
}

                if (parentId.isPresent()) {
                    Object candidateId = parentId.get().getId();
                    if (candidateId instanceof CompositeIdGenerator.CompositeId) {
                        return createNestedTestSuite(node, displayName, (CompositeIdGenerator.CompositeId) candidateId);
                    }
                }
            }
            if (node.getType().isTest()) {

}

var _ = []T{
// lone comments
// in composite lit
}

var _ = [][]T{
	{
		// lone comments
		// in composite lit
	},
}

// TODO: gofmt doesn't add these tabs; make it so that these golden
// tests run the printer in a way that it's exactly like gofmt.

var _ = []T{// lone comment
}

var _ = []T{// lone comments
// in composite lit
}

func _() {}

//

  }
  return false;
}

/* Resources may be merged with an execute op when they are on its device or a
 * `COMPOSITE`. Note that a `COMPOSITE` represents a set of devices, they
 * are typically associated with packed variables. Presently, we assume this
 * set spans all the devices. So, a variable on a `COMPOSITE` will have a local
 * instance on the execute op's device.
 */

    }
  }
}

bool IsCompositeDevice(mlir::Attribute attr) {
  const auto str_attr = attr.dyn_cast_or_null<mlir::StringAttr>();
  return str_attr &&
         (str_attr.getValue().find("COMPOSITE") != llvm::StringRef::npos);
}
}  // namespace

// Rewrites unpartitioned resource reads and writes to partitioned resource
// reads and writes. The TPU computation from the frontend is generated in such

            }
        """

        plugin.file('src/main/resources/META-INF/gradle-plugins/com.company.composite.properties') << """
            implementation-class=org.gradle.test.CompositePlugin
        """

        plugin.build()

        buildFile << """
            plugins {
                id "com.company.composite"
            }
        """

        when:
        def result = runner('helloWorld1')

        def exception = thrown(Exception)
        exception.cause.message.containsIgnoreCase("project 'sub' not found in project ':other-build'.")
    }

    def "handles overlapping names between composite and a subproject within the composite"() {
        given:
        settingsFile << """
            rootProject.name = 'root-project'
            includeBuild('lib')
        """
        file('lib/settings.gradle') << """

[cols="20%,80%",options="header"]
|======================
|Test type                               |Tooling support
|<<manual-tests,Manual tests>>           |<<composite_builds.adoc#composite_builds,Gradle composite builds>>
|<<unit-tests,Unit tests>>               |Any JVM-based test framework
|<<integration-tests,Integration tests>> |Any JVM-based test framework

    }

    def 'constructs empty tree when composite tree created with empty list'() {
        def tree = factory.treeOf([])

        expect:
        emptyTree(tree)
    }

    def 'returns source file tree when composite tree created with single entry'() {
        def source = Stub(FileTreeInternal)
        def tree = factory.treeOf([source])