}
    File gitignoreFile = tmpDir.file(".gitignore")

    def setup() {
        Directory target = Mock()
        RegularFile ignoreFile = Mock()
        1 * settings.target >> target
        1 * target.file('.gitignore') >> ignoreFile
        1 * ignoreFile.asFile >> gitignoreFile
    }

    def "generates .gitignore file"() {
        setup:
        def generator = new GitIgnoreGenerator()

		synopsis - string offset
		name - string offset
		pkgName - string offset
		ignoreFile - int32 bool // report the file in Ignored(Go|Other)Files because there was an error reading it or parsing its build constraints.
		binaryOnly uint32 bool

	error      string
	parseError string

	name                 string
	synopsis             string // doc.Synopsis of package comment... Compute synopsis on all of these?
	pkgName              string
	ignoreFile           bool   // starts with _ or . or should otherwise always be ignored
	binaryOnly           bool   // cannot be rebuilt from source (has //go:binary-only-package comment)

		encodeFile(e, f)
	}
}

func encodeFile(e *encoder, f *rawFile) {
	e.String(f.error)
	e.String(f.parseError)
	e.String(f.synopsis)
	e.String(f.name)
	e.String(f.pkgName)
	e.Bool(f.ignoreFile)
	e.Bool(f.binaryOnly)
	e.String(f.cgoDirectives)
	e.String(f.goBuildConstraint)

	e.Int(len(f.plusBuildConstraints))
	for _, s := range f.plusBuildConstraints {
		e.String(s)
	}

	e.Int(len(f.imports))

				item.Source = info.Source
			}
			if err := fn(item, nil); err != nil {
				errs = append(errs, err)
			}
		}
		return utilerrors.NewAggregate(errs)
	})
}

func ignoreFile(path string, extensions []string) bool {
	if len(extensions) == 0 {
		return false
	}
	ext := filepath.Ext(path)
	for _, s := range extensions {
		if s == ext {
			return false
		}
	}

				if x, err := constraint.Parse(text); err == nil {
					if !ctxt.eval(x, allTags) {
						shouldBuild = false
					}
				}
			}
		}

		ext := nameExt(name)
		if !shouldBuild || tf.ignoreFile() {
			if ext == ".go" {
				p.IgnoredGoFiles = append(p.IgnoredGoFiles, name)
			} else if fileListForExt(p, ext) != nil {
				p.IgnoredOtherFiles = append(p.IgnoredOtherFiles, name)
			}
			continue
		}

  "rules": {
    "declaration-property-value-allowed-list": {
      "/color/": ["/^var\\(--/", "transparent"]
    },
    "unit-disallowed-list": ["px"],
    "selector-class-pattern": "^[a-zA-Z\\-]+$"
  },
  "ignoreFiles": ["**/*.min.css"]

    }

    def "treats '#extension' as archive"() {
        def archive = file("archive.${extension}")
        def contents = file("archiveContents").createDir()
        def ignoredFile = contents.file("ignored.txt")
        ignoredFile << "this file is ignored"
        def nonIgnoredFile = contents.file("not-ignored.txt")
        nonIgnoredFile << "this file is not ignored"
        contents.zipTo(archive)

import static org.gradle.integtests.fixtures.AvailableJavaHomes.getAvailableJdk

@MultiVersionTest
class DaemonMultiJdkIntegrationTest extends DaemonIntegrationSpec {
    static def version
    @Rule IgnoreIfJdkNotFound ignoreRule = new IgnoreIfJdkNotFound()

    JavaInfo jdk

    static VersionNumber getVersionNumber() {
        VersionNumber.parse(version.toString())
    }

    class IgnoreIfJdkNotFound implements TestRule {

                dependencies {
                    ${dependencies.collect { "implementation ${it}" }.join('\n')}
                }
            """
        }

        def ignoredFile = file('foo.txt') << 'should not throw an error during compile classpath snapshotting'
        file('bar.txt') << 'should be ignored, too'
        file('src/main/java/Hello.java') << 'public class Hello {}'