}
}
-- b/b.go --
package b

import (
	"M/a"
	"M/d"
)

func BFunc() int {
	return -d.FortyTwo + a.AFunc()
}
-- b/b_test.go --
package b

import "testing"

func TestB(t *testing.T) {
	if BFunc() == 1010101 {
		t.Fatalf("bad!")
	}
}
-- c/c.go --
package c

var G int

func CFunc(x, y int) int {
	G += x
	G -= y
	return x + y
}
-- c/c_test.go --

    }
"""
        buildB.buildFile << """
    allprojects {
        apply plugin: 'java'
    }

    dependencies {
        implementation "org.test:b1:1.0"
    }
"""

        when:
        execute(buildA, ":delegate")

        then:
        executed ":buildB:b1:jar", ":buildB:jar"
    }

func TestA(*testing.T) {}
-- a/default.pgo --
-- b/b.go --
package main
import _ "test/dep"
import _ "test/dep2"
func main() {}
-- b/b_test.go --
package main
import "testing"
import _ "test/testdep"
func TestB(*testing.T) {}
-- b/default.pgo --
-- nopgo/nopgo.go --
package main
import _ "test/dep"
import _ "test/dep2"
func main() {}
-- nopgo/nopgo_test.go --
package main
import "testing"

            }
        }.publish()

        when:
        buildFile << """
            dependencies {
                implementation platform(project(":platform"))
                implementation "org.test:b:1.9"
            }
        """


        moduleA.pom.expectGet()
        moduleA.moduleMetadata.expectGet()
        moduleA.artifact.expectGet()

        then:
        succeeds ":compileJava"

import "testing"

func TestA(t *testing.T) {
	// Edge-case testing, mixing unparallel tests too
	t.Logf("LOG: %s", t.Name())
}

func TestFailingA(t *testing.T) {
	t.Errorf("FAIL - %s", t.Name())
}

func TestB(t *testing.T) {
	// Edge-case testing, mixing unparallel tests too
	t.Logf("LOG: %s", t.Name())
}

func TestParallelFailingA(t *testing.T) {
	t.Parallel()
	t.Errorf("FAIL - %s", t.Name())
}

        repo.expectListVersions()
        assertResolvesTo("foo-1.0.jar")
    }

    @ToBeFixedForConfigurationCache
    def "can resolve root of multi-project source dependency"() {
        mappingFor(repo, "org.test:B")
        buildFile << """
            dependencies {
                conf 'org.test:B:latest.integration'
            }
        """
        expect:
        repo.expectListVersions()

            apply plugin: 'java-library'

            dependencies {
                implementation(project(":b")) {
                    capabilities {
                        requireCapability("org.gradle.test:b-my-feature")
                    }
                }
            }

            task verifyClasspath {
                dependsOn(configurations.compileClasspath)

            }
            project(":a") {
                dependencies {
                    common files("a-lib.jar")
                    common project(":b")
                    common "org.test:B:1.0"
                }
            }
            project(":b") {
                dependencies {
                    common project(":c")
                    common files("b-lib.jar")
                }

    }

    void "can version listing can use module identifier to return the version list"() {
        withLister([testA: [1, 2, 3], testB: [1, 2]])
        given:
        repository {
            'org:testA:1'()
            'org:testA:2'()
            'org:testA:3'()
            'org:testB:1'()
            'org:testB:2'()
        }

func lshSigned(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
	// amd64:"TESTB"
	_ = x << v8
	// amd64:"TESTW"
	_ = x << v16
	// amd64:"TESTL"
	_ = x << v32
	// amd64:"TESTQ"
	_ = x << v64
}

// We want to avoid generating a test + panicshift for these cases.
func lshSignedMasked(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
	// amd64:-"TESTB"
	_ = x << (v8 & 7)
	// amd64:-"TESTW"
	_ = x << (v16 & 15)