//        when:
//        run 'merge'
//
//        then:
//        outputContains 'Transforming p1.zip'
//        outputContains 'Transforming p2.zip'
//        result.assertTasksExecuted ':p1:produce', ':p1:zip', ':p2:produce', ':p2:zip', ':merge'
//        file('merge.txt').text == 'p1.zip,p2.zip'
    }

    @Issue('https://github.com/gradle/gradle/issues/29147')

    def "reports project structure with single composite"() {
        given:
        createDirs("p1", "p2", "p2/p22", "another")
        file("settings.gradle") << """rootProject.name = 'my-root-project'
include('p1')
include('p2')
include('p2:p22')
includeBuild('another')"""
        file('another/settings.gradle').touch()

        when:
        run ":projects"

        then:

		p1.From.Type = obj.TYPE_CONST
		p1.From.Offset = offset
		p1.To.Type = obj.TYPE_REG
		p1.To.Reg = REG_R12
		p2 := obj.Appendp(p1, c.newprog)
		p2.As = AMOVD
		p2.From.Type = obj.TYPE_REG
		p2.From.Reg = REG_R12
		p2.To.Type = obj.TYPE_REG
		p2.To.Reg = REG_LR
		p3 := obj.Appendp(p2, c.newprog)
		p3.As = obj.ACALL
		p3.To.Type = obj.TYPE_REG
		p3.To.Reg = REG_LR
	}

	var source *obj.Addr

				st.MakePod().Name("p").UID("p").Priority(highPriority).Obj(),
			},
			initPods: []*v1.Pod{
				st.MakePod().Name("p1").UID("p1").Node("node1").Priority(midPriority).Obj(),
				st.MakePod().Name("p2").UID("p2").Node("node2").Priority(midPriority).Obj(),
			},
			expected: [][]Candidate{
				{
					&candidate{
						victims: &extenderv1.Victims{

            receivedProblems.sort { p1, p2 ->
                if (p1.fqid != p2.fqid) {
                    return p1.fqid <=> p2.fqid
                }
                if (p1.contextualLabel != p2.contextualLabel) {
                    return p1.contextualLabel <=> p2.contextualLabel
                }
                if (p1.details != p2.details) {
                    return p1.details <=> p2.details
                }

	}
	return direct, indirect
}

func dfsImports(dest *[]string, seen map[string]bool, p *packages.Package) {
	for _, p2 := range p.Imports {
		if seen[p2.PkgPath] {
			continue
		}
		seen[p2.PkgPath] = true
		*dest = append(*dest, p2.PkgPath)
		dfsImports(dest, seen, p2)
	}
}

// verifyInverseRules checks that all packages that import a package are allowed to import it.

// Compare returns an integer comparing two AddrPorts.
// The result will be 0 if p == p2, -1 if p < p2, and +1 if p > p2.
// AddrPorts sort first by IP address, then port.
func (p AddrPort) Compare(p2 AddrPort) int {
	if c := p.Addr().Compare(p2.Addr()); c != 0 {
		return c
	}
	return cmp.Compare(p.Port(), p2.Port())
}

func (p AddrPort) String() string {
	var b []byte
	switch p.ip.z {

        ArtifactRepository repo = getRepo("a");

        Mirror mirrorA = newMirror("a", "a", null, "http://a");
        Mirror mirrorB = newMirror("b", "a", "p2", "http://b");

        Mirror mirrorC = newMirror("c", "*", null, "http://c");
        Mirror mirrorD = newMirror("d", "*", "p2", "http://d");

        assertSame(mirrorA, mirrorSelector.getMirror(repo, Arrays.asList(mirrorA)));

		{p1: unscheduled5Hours, p2: unscheduled8Hours},
		{p1: ready5Hours, p2: ready10Hours},
	}
	for i, test := range equalityTests {
		t.Run(fmt.Sprintf("Equality tests %d", i), func(t *testing.T) {
			featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LogarithmicScaleDown, !test.disableLogarithmicScaleDown)
			if test.p2 == nil {
				test.p2 = test.p1
			}

                }
            }

            task t

            use(SomeCategory) {
                assert project.show("p1") == "project p1 path ':'"
                assert show("p2") == "project p2 path ':'"
                assert t.show("t1") == "task t1 path ':t'"
                tasks.t {
                    assert show("t2") == "task t2 path ':t'"
                }
            }
        '''