def libName = "${dependentProject}2"
                    deps << new Dependency(":" + dependentProject, libName, 'static')
                    includes << "${libName}/header.h"
                }
            } else {
                // odd components depend on the component with index 2
                def libName = "${generatedProjectName}2"

                headers.srcDir "libs/src/hello/headers"
                binaries.withType(StaticLibraryBinary) {
                    def libName = targetPlatform.operatingSystem.windows ? 'hello.lib' : 'libhello.a'
                    staticLibraryFile = file("libs/build/libs/hello/static/english/\${libName}")
                }
                binaries.withType(SharedLibraryBinary) {
                    def os = targetPlatform.operatingSystem

        failure.assertHasCause("A build operation failed.")
        def libName = sharedLibrary("build/binaries/mainSharedLibrary/main").file.name
        failure.assertThatCause(containsText("Linker failed while linking ${libName}"))
    }

    @ToBeFixedForConfigurationCache
    def "build fails when create static library fails"() {
        given:

	cmd := "testp2"
	bin := cmdToRun(cmd)
	libname := "libgo2.a"

	run(t,
		nil,
		"go", "build",
		"-buildmode=c-shared",
		"-installsuffix", "testcshared",
		"-o", libname, "./libgo2",
	)

	linkFlags := "-Wl,--no-as-needed"
	if GOOS == "darwin" || GOOS == "ios" {
		linkFlags = ""
	}

	runCC(t, "-o", cmd, "main2.c", linkFlags, libname)

	defer os.Remove(libname)
	defer os.Remove(bin)

//	a/... b/... ---> liba/c,b/d.so - all matching import paths
//
// Name parts are joined with ','.
func libname(args []string, pkgs []*load.Package) (string, error) {
	var libname string
	appendName := func(arg string) {
		if libname == "" {
			libname = arg
		} else {
			libname += "," + arg
		}
	}
	var haveNonMeta bool
	for _, arg := range args {
		if search.IsMetaPackage(arg) {

    }

    def "maps shared library binary types to visual studio projects"() {
        when:
        targetBinary = new NativeSpecVisualStudioTargetBinary(sharedLibBinary)
        lib.getName() >> "libName"
        sharedLibBinary.getProjectPath() >> ":"
        binaryNamingScheme.getVariantDimensions() >> ["buildTypeOne"]

        then:
        checkNames targetBinary, "libNameDll", 'buildTypeOne'
    }

		modulehashes.SetType(sym.SRODATA)

		for i, shlib := range ctxt.Shlibs {
			// modulehashes[i].modulename
			modulename := filepath.Base(shlib.Path)
			addgostring(ctxt, ldr, modulehashes, fmt.Sprintf("go:link.libname.%d", i), modulename)

			// modulehashes[i].linktimehash
			addgostring(ctxt, ldr, modulehashes, fmt.Sprintf("go:link.linkhash.%d", i), string(shlib.Hash))

			// modulehashes[i].runtimehash

func (b *Builder) buildmodeShared(mode, depMode BuildMode, args []string, pkgs []*load.Package, a1 *Action) *Action {
	name, err := libname(args, pkgs)
	if err != nil {
		base.Fatalf("%v", err)
	}
	return b.linkSharedAction(mode, depMode, name, a1)
}

// linkSharedAction takes a grouping action a1 corresponding to a list of built packages

		cc = append(cc, "-framework", "CoreFoundation")
	}
	libbase := GOOS + "_" + GOARCH
	if runtime.Compiler == "gccgo" {
		libbase = "gccgo_" + libgodir + "_fPIC"
	} else {
		switch GOOS {
		case "darwin", "ios":
			if GOARCH == "arm64" {
				libbase += "_shared"
			}
		case "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "solaris", "illumos":
			libbase += "_shared"
		}
	}

		}
	}

	// fractional part
	if seenDot {
		tok = Float
		if prefix == 'o' || prefix == 'b' {
			s.error("invalid radix point in " + litname(prefix))
		}
		ch, ds = s.digits(ch, base, &invalid)
		digsep |= ds
	}

	if digsep&1 == 0 {
		s.error(litname(prefix) + " has no digits")
	}

	// exponent
	if e := lower(ch); (e == 'e' || e == 'p') && s.Mode&ScanFloats != 0 {
		switch {