//
// Eg 1. An update in canonical form:
//  * indices shape(A,B,C)
//  * updates shape(A,B,D,E,F)
// Then:
//  * D,E,F are the update window dims [2,3,4]
//  * C is the index vector dimension
//  * A,B iterate over the updates and indices
//
// If `update_window_dims` are not the trailing dimensions then updates must be
// transposed.
//
// Eg 2. An update in non-canonical form:
//  * indices shape(a,b,c)
//  * updates shape(d,e,f,a,b)

        pluginDefinesTask()
        taskTypeWithInputFileProperty()
        buildFile << """
            apply plugin: SomePlugin
            task consumer(type: InputFileTask) {
                inFile = producer.outFile
                outFile = file("out.txt")
            }
        """

        when:
        run("consumer")

        then:

		// indices in the first place (if it returned fewer than that then
		// there cannot be more).
		for n1 := n; ; n1 += 2 * (n - len(result)) /* overflow ok */ {
			indices := x.Lookup(lit, n1)
			if len(indices) == 0 {
				return
			}
			slices.Sort(indices)
			pairs := make([]int, 2*len(indices))
			result = make([][]int, len(indices))
			count := 0
			prev := 0

	case *ast.IndexExpr:
		return &IndexExpr{
			Orig:    e,
			X:       e.X,
			Lbrack:  e.Lbrack,
			Indices: []ast.Expr{e.Index},
			Rbrack:  e.Rbrack,
		}
	case *ast.IndexListExpr:
		return &IndexExpr{
			Orig:    e,
			X:       e.X,
			Lbrack:  e.Lbrack,
			Indices: e.Indices,
			Rbrack:  e.Rbrack,
		}
	}
	return nil

		ptest = new(Package)
		*ptest = *p
		ptest.Error = ptestErr
		ptest.Incomplete = incomplete
		ptest.ForTest = p.ImportPath
		ptest.GoFiles = nil
		ptest.GoFiles = append(ptest.GoFiles, p.GoFiles...)
		ptest.GoFiles = append(ptest.GoFiles, p.TestGoFiles...)
		ptest.Target = ""
		// Note: The preparation of the vet config requires that common
		// indexes in ptest.Imports and ptest.Internal.RawImports

        expect:
        cp1.asFiles == [file1, file2]
        cp2.asFiles == [file1, file2]
    }

    def "can add classpaths together"() {
        def file1 = new File("a.jar")
        def file2 = new File("b.jar")
        def cp1 = DefaultClassPath.of(file1)
        def cp2 = DefaultClassPath.of(file2)

        expect:
        def cp3 = cp1 + cp2
        cp3.asFiles == [file1, file2]
    }

private
fun buildOutputModel(scriptFile: File, classPath: ClassPath, sourcePath: ClassPath, implicitImports: List<String>, exceptions: List<Exception>) =
    StandardKotlinDslScriptModel(
        classPath.asFiles,
        sourcePath.asFiles,
        implicitImports,
        editorReports = emptyList(), // TODO:isolated support editor reports
        exceptions = getExceptionsForFile(scriptFile, exceptions)
    )


private

			filenames <- filename
			nfiles++
		}
		return nil
	}

	// test Go files provided via -files, if any
	if *files != "" {
		for _, filename := range strings.Split(*files, ",") {
			fi, err := os.Stat(filename)
			handleFile(filename, fs.FileInfoToDirEntry(fi), err)
		}
		return // ignore files under -root
	}

	// otherwise, test all Go files under *root
	goroot := *root

# Overlay in an existing directory
go list -overlay overlay.json  -f '{{.GoFiles}}' .
stdout '^\[f.go\]$'

# Overlays in a non-existing directory
go list -overlay overlay.json -f '{{.GoFiles}}' ./dir
stdout '^\[g.go\]$'

# Overlays in an existing directory with already existing files
go list -overlay overlay.json -f '{{.GoFiles}}' ./dir2
stdout '^\[h.go i.go\]$'

# Overlay that removes a file from a directory

                scriptFile = null,
                projectDir = folder("project"),
                gradleHomeDir = folder("gradle"),
                sourceDistributionResolver = mock()
            ).asFiles,
            hasItems(
                folder("project/buildSrc/src/main/foo"),
                folder("project/buildSrc/src/main/bar"),
                folder("gradle/src/gradle-foo"),