}

    def dumpString() {
        when:
        def configurationDependency = dependency("dumpgroup1", "dumpname1", "dumpversion1")
        def otherConfSimilarDependency = dependency("dumpgroup1", "dumpname1", "dumpversion1")
        def otherConfDependency = dependency("dumpgroup2", "dumpname2", "dumpversion2")
        def otherConf = conf("dumpConf")
        otherConf.getDependencies().add(otherConfDependency)

			args := strings.Fields(line)
			for _, arg := range args[1:] {
				if strings.HasPrefix(arg, "-L") {
					inst.LibPaths = append(inst.LibPaths, arg[2:])
				}
			}
		}
	}

	argv = append([]string{"-dumpversion"}, args...)
	stdout, err := exec.Command(gccgoPath, argv...).Output()
	if err != nil {
		return
	}
	inst.GccVersion = strings.TrimSpace(string(stdout))

	return
}

	}
	bin, err := exec.LookPath(gccgo)
	if err != nil {
		return
	}

	allDirs, err := exec.Command(bin, "-print-search-dirs").Output()
	if err != nil {
		return
	}
	versionB, err := exec.Command(bin, "-dumpversion").Output()
	if err != nil {
		return
	}
	version := strings.TrimSpace(string(versionB))
	machineB, err := exec.Command(bin, "-dumpmachine").Output()
	if err != nil {
		return
	}

                        version("my.bottom", "1.1")
                    }
                }
            }
        """

        buildFile """
            tasks.register("dumpVersions") {
                def first = libs.versions.my.asProvider()
                def second = libs.versions.my.bottom
                doLast {
                    println "First: \${first.get()}"

				return nil
			}

			var match [][]byte
			if bytes.HasPrefix(out, []byte("gcc")) {
				compiler.name = "gcc"
				cmd, err := cc("-dumpfullversion", "-dumpversion")
				if err != nil {
					return err
				}
				out, err := cmd.Output()
				if err != nil {
					// gcc, but does not support gcc's "-v" flag?!
					return err
				}

		gccgoName = "gccgo"
	}
	gccgoPath, err := exec.LookPath(gccgoName)
	if err != nil {
		t.Skip("gccgo not found")
	}
	cmd := exec.Command(gccgoPath, "-dumpversion")
	output, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("%s -dumpversion failed: %v\n%s", gccgoPath, err, output)
	}
	dot := bytes.Index(output, []byte{'.'})
	if dot > 0 {
		output = output[:dot]
	}