def otherDir = projectDir.file("sub-dir")

        expect:
        def dirVar = factory.newDirectoryProperty()
        def fileProvider = dirVar.asFile

        dirVar.set(new File("sub-dir"))
        dirVar.present
        dirVar.get().getAsFile() == otherDir
        fileProvider.present
        fileProvider.get() == otherDir
    }

    def "can overwrite project dir via build arguments"() {
        given:
        file('otherDir').createDir()
        file('otherDir/build.gradle') << "assert projectDir.name.endsWith('otherDir')"
        file('otherDir/settings.gradle') << ''

        when:
        withConnection {
            it.newBuild().withArguments('-p', 'otherDir').run()
        }

        then:
        noExceptionThrown()
    }

            }
        """
        def otherDir = file("buildSrc/other")
        otherDir.file("build.gradle") << """
            plugins {
                id("java-library")
            }
            dependencies {
                api gradleApi()
                implementation project(":plugin")
            }
        """

        otherDir.file("src/main/java/SomeOtherPlugin.java") << """

                List<String> paths = []

                @OutputDirectory
                File dir = project.file("build/dir")

                @OutputDirectory
                File otherDir = project.file("build/otherDir")

                @TaskAction
                void generate() {
                    paths.each {
                        def f = new File(dir, it)
                        f.parentFile.mkdirs()

        1 * listener.fileCollectionObserved(fileTree)
    }

    def testCanStopVisitingFiles() {
        File included1 = new File(testDir, 'subDir/included1')
        File included2 = new File(testDir, 'subDir/otherDir/included2')
        [included1, included2].each { File file ->
            file.parentFile.mkdirs()
            file.text = 'some text'
        }

        expect:
        assertCanStopVisiting(fileTree)

		input  *packages.Package
		expect string
	}{{
		input: &packages.Package{
			PkgPath:      "example.com/foo/bar/qux",
			GoFiles:      []string{"/src/prj/file.go"},
			IgnoredFiles: []string{"/otherdir/file.go"},
		},
		expect: filepath.Clean("/src/prj"),
	}, {
		input: &packages.Package{
			PkgPath:      "example.com/foo/bar/qux",
			IgnoredFiles: []string{"/src/prj/file.go"},
		},

	type Thing struct {
		gorm.Model
		SomeID  string
		OtherID string
		Data    string
	}

	DB.Migrator().DropTable(&Thing{})
	DB.Migrator().CreateTable(&Thing{})
	if err := DB.Exec("ALTER TABLE things ADD CONSTRAINT some_id_other_id_unique UNIQUE (some_id, other_id)").Error; err != nil {
		t.Error(err)
	}

	thing := Thing{
		SomeID:  "1234",
		OtherID: "1234",
		Data:    "something",
	}

        when:
        specUnderTest.setEnvironment(OTHERVAR: "otherval")

        then:
        specUnderTest.getEnvironment() == [OTHERVAR: "otherval"]
    }

    def "adding variables after setting environment is working"() {
        given:
        specUnderTest.setEnvironment(SOMEVAR: "someval")

        when:
        specUnderTest.environment(OTHERVAR: "otherval")

		return types.NewErr("type conversion error from '%s' to '%s'", quantityTypeValue, typeVal)
	}
}

func (d Quantity) Equal(other ref.Val) ref.Val {
	otherDur, ok := other.(Quantity)
	if !ok {
		return types.MaybeNoSuchOverloadErr(other)
	}
	return types.Bool(d.Quantity.Equal(*otherDur.Quantity))
}

func (d Quantity) Type() ref.Type {
	return quantityTypeValue
}

func (d Quantity) Value() interface{} {
	return d.Quantity

	default:
		return types.NewErr("type conversion error from '%s' to '%s'", FormatType, typeVal)
	}
}

func (d *Format) Equal(other ref.Val) ref.Val {
	otherDur, ok := other.(*Format)
	if !ok {
		return types.MaybeNoSuchOverloadErr(other)
	}
	return types.Bool(d.Name == otherDur.Name)
}

func (d *Format) Type() ref.Type {
	return FormatType
}

func (d *Format) Value() interface{} {
	return d