*
     * @return The class name. May return null.
     */
    @Nullable
    @UsedByScanPlugin("test-retry")
    String getClassName();

    /**
     * Is this test a composite test?
     *
     * @return true if this test is a composite test.
     */
    boolean isComposite();

    /**
     * Returns the parent of this test, if any.
     *
     * @return The parent of this test. Null if this test has no parent.

// use as a composite key.
func (ks *singleKeyStrategy) CompositeKeyFor(obj map[string]interface{}) (interface{}, bool) {
	v, ok := obj[ks.key]
	if !ok {
		return nil, false
	}

	switch v.(type) {
	case bool, float64, int64, string:
		return v, true
	default:
		return nil, false // non-scalar
	}
}

// multiKeyStrategy computes a composite key of all key values.

        }
    }

    def expectTestPasses() {
        suiteDescriptor.id >> "suite"
        suiteDescriptor.parent >> null
        suiteDescriptor.composite >> true

        testDescriptor.id >> "test"
        testDescriptor.parent >> suiteDescriptor
        testDescriptor.composite >> false
        testDescriptor.className >> "class"
        testDescriptor.classDisplayName >> "class"
        testDescriptor.name >> "method"

        @Override
        public CompositeIdGenerator.CompositeId read(Decoder decoder) throws Exception {
            return new CompositeIdGenerator.CompositeId(decoder.readLong(), decoder.readLong());
        }

        @Override
        public void write(Encoder encoder, CompositeIdGenerator.CompositeId value) throws Exception {

 * limitations under the License.
 */

package org.gradle.composite.internal;

import org.gradle.api.Action;
import org.gradle.api.artifacts.DependencySubstitution;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.component.ProjectComponentIdentifier;
import org.gradle.api.internal.composite.CompositeBuildContext;
import org.gradle.internal.Actions;
import org.gradle.internal.Pair;

// license that can be found in the LICENSE file.

// Issue 8961. Empty composite literals to small globals were not filled in
package main

type small struct { a int }
var foo small

func main() {
	foo.a = 1
	foo = small{}
	if foo.a != 0 {
		println("expected foo.a to be 0, was", foo.a)
		panic("composite literal not filled in")
	}

// license that can be found in the LICENSE file.

package main

type T struct {
	x, y *T
}

func main() {
	// legal composite literals
	_ = struct{}{}
	_ = [42]int{}
	_ = [...]int{}
	_ = []int{}
	_ = map[int]int{}
	_ = T{}

	// illegal composite literals: parentheses not allowed around literal type
	_ = (struct{}){}    // ERROR "parenthesize"
	_ = ([42]int){}     // ERROR "parenthesize"

 * limitations under the License.
 */

package org.gradle.integtests.composite

import org.gradle.integtests.fixtures.build.BuildTestFile
import org.gradle.integtests.fixtures.resolve.ResolveTestFixture
import org.gradle.test.fixtures.maven.MavenModule

/**
 * Tests for resolving dependency artifacts with substitution within a composite build.
 */

// license that can be found in the LICENSE file.

// Test that error message for composite literals with
// missing type is at the right place.

package p

type T struct {
	f map[string]string
}

var _ = T{
	f: {                // ERROR "missing type in composite literal|may only omit types within"
		"a": "b",
	},

        assertJunit(rootTestOp, this.operations)
    }

    def "emits test operations as expected for composite builds"() {
        given:
        resources.maybeCopy('TestExecutionBuildOperationsIntegrationTest')
        settingsFile.text = """
            rootProject.name = "composite"
            includeBuild "emitsBuildOperationsForJUnitTests", { name = 'junit' }