}

    def "Add multiple dependencies without type"() {
        when:
        List dependencies = mavenLocalModule.dependsOnModules("dep1", "dep2").dependencies

        then:
        dependencies != null
        dependencies.size() == 2
        dependencies.get(0).groupId == 'my-company'
        dependencies.get(0).artifactId == 'dep1'

			}
			return
		}

		if !fi.Mode().IsRegular() {
			sw.Error(fmt.Errorf("%v is not a regular file", file))
			return
		}

		if dup := keepDirs[absDir]; dup != "" && dup != dir {
			base.Errorf(`go: already added "%s" as "%s"`, dir, dup)
		}
		keepDirs[absDir] = dir
	}

	for _, useDir := range args {
		absArg, _ := pathRel(workDir, useDir)

        node("leaf1")
        node("leaf2")

        resolvedConf("root", [dep("root", "mid1")])

        resolvedConf("mid1", [dep("mid1", "leaf1")])
        resolvedConf("mid1", [dep("mid1", "leaf1")]) //dupe
        resolvedConf("mid1", [dep("mid1", "leaf2")])

        resolvedConf("leaf1", [])
        resolvedConf("leaf2", [])

        when:
        def result = builder.getRoot(id("root"))

        then:

	if n < 3 || comp[0][0:3] != "net" {
		return nil, syscall.EPLAN9
	}

	name := comp[2]
	switch file := comp[n-1]; file {
	case "ctl", "clone":
		fd, err := syscall.Dup(int(f.Fd()), -1)
		if err != nil {
			return nil, os.NewSyscallError("dup", err)
		}
		defer close(fd)

		dir := netdir + "/" + comp[n-2]
		ctl = os.NewFile(uintptr(fd), dir+"/"+file)
		ctl.Seek(0, io.SeekStart)
		var buf [16]byte

    }

    def "Add multiple dependencies without type"() {
        when:
        List dependencies = mavenFileModule.dependsOnModules("dep1", "dep2").dependencies

        then:
        dependencies != null
        dependencies.size() == 2
        dependencies.get(0).groupId == 'my-company'
        dependencies.get(0).artifactId == 'dep1'

    NormalizingGroovyCompiler compiler = new NormalizingGroovyCompiler(target)

    def setup() {
        spec.compileClasspath = [new File('Dep1.jar'), new File('Dep2.jar'), new File('Dep3.jar')]
        spec.groovyClasspath = spec.compileClasspath
        spec.sourceFiles = files('House.scala', 'Person1.java', 'package.html', 'Person2.groovy')

	if d.state != spongeAbsorbing {
		panic("sha3: Sum after Read")
	}

	// Make a copy of the original hash so that caller can keep writing
	// and summing.
	dup := d.clone()
	hash := make([]byte, dup.outputLen, 64) // explicit cap to allow stack allocation
	dup.Read(hash)
	return append(in, hash...)

func (fd *FD) RawWrite(f func(uintptr) bool) error {
	return errors.New("not implemented")
}

func DupCloseOnExec(fd int) (int, string, error) {
	nfd, err := syscall.Dup(int(fd), -1)
	if err != nil {
		return 0, "dup", err
	}
	// Plan9 has no syscall.CloseOnExec but
	// its forkAndExecInChild closes all fds
	// not related to the fork+exec.
	return nfd, "", nil

    def setup() {
        spec.sourceFiles = files("Source1.java", "Source2.java", "Source3.java")
        spec.compileClasspath = [new File("Dep1.jar"), new File("Dep2.jar"), new File("Dep3.jar")]
        def compileOptions = TestUtil.newInstance(CompileOptions, TestUtil.objectFactory())
        compileOptions.annotationProcessorPath = TestFiles.fixed(new File("processor.jar"))

	netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
	return netfd, nil
}

// Defined in os package.
func newUnixFile(fd int, name string) *os.File

func (fd *netFD) dup() (f *os.File, err error) {
	ns, call, err := fd.pfd.Dup()
	if err != nil {
		if call != "" {
			err = os.NewSyscallError(call, err)
		}
		return nil, err
	}

	return newUnixFile(ns, fd.name()), nil