def "returns null when file does not exist"() {
        when:
        def result = cache.get()

        then:
        result == null
        1 * fileAccess.readFile(!null) >> { it[0].get() }
    }

    def "get returns last value written to file"() {
        when:
        cache.set('some value')

        then:
        1 * fileAccess.writeFile(!null) >> { it[0].run() }
        tmpDir.file('state.bin').assertIsFile()

        then:
        _ * work.timeout >> Optional.of(duration)

        then:
        1 * timeoutHandler.start(_ as Thread, duration, work, buildOperationRef) >> timeout

        then:
        1 * delegate.execute(work, context) >> delegateResult

        then:
        1 * timeout.stop() >> true

        then:
        def ex = thrown Exception
        ex.message == "Timeout has been exceeded"

	fi
	if [ -n "$PID_FILE" ] && [ ! -e "$PID_FILE" ]; then
		touch "$PID_FILE" && chown "$FESS_USER":"$FESS_GROUP" "$PID_FILE"
	fi

	if [ -n "$MAX_OPEN_FILES" ]; then
		ulimit -n $MAX_OPEN_FILES
	fi

	if [ -n "$MAX_LOCKED_MEMORY" ]; then
		ulimit -l $MAX_LOCKED_MEMORY
	fi

	if [ -n "$MAX_MAP_COUNT" -a -f /proc/sys/vm/max_map_count ]; then
		sysctl -q -w vm.max_map_count=$MAX_MAP_COUNT
	fi

	# Start Daemon

        adapter.getProperty("foo")

        then:
        thrown(MissingPropertyException)
    }

    def "setting missing property throws MPE"() {
        when:
        adapter.setProperty("foo", 12)

        then:
        thrown(MissingPropertyException)
    }

    def "invoking method throws MME"() {
        when:
        adapter.invokeMethod("foo", "bar")

        then:

            }
            println("script log statement")
        """

        when:
        configurationCacheRun("assemble")

        then:
        outputContains("script log statement")

        when:
        configurationCacheRun("assemble")

        then:
        outputDoesNotContain("script log statement")
    }

    def "can enable configuration cache using gradle property in gradle.properties"() {

        def supplier = Mock(Supplier)

        when:
        def lazy = factory(supplier)

        then:
        0 * supplier._

        when:
        lazy.use {
            assert it == 123
        }

        then:
        1 * supplier.get() >> 123

        when:
        lazy.get()

        then:
        0 * supplier.get()

        when:
        lazy.use {

    private val backingValueParameterReference: KaContractParameterValue,
    private val backingOccurrencesRange: EventOccurrencesRange,
) : KaContractEffectDeclaration {
    override val token: KaLifetimeToken get() = backingValueParameterReference.token

    public val valueParameterReference: KaContractParameterValue get() = withValidityAssertion { backingValueParameterReference }

dialects=("sqlite" "mysql" "postgres" "sqlserver" "tidb")

if [[ $(pwd) == *"gorm/tests"* ]]; then
  cd ..
fi

if [ -d tests ]
then
  cd tests
  go get -u -t ./...
  go mod download
  go mod tidy
  cd ..
fi

# SqlServer for Mac M1
if [[ -z $GITHUB_ACTION ]]; then
  if [ -d tests ]
  then
    cd tests
    if [[ $(uname -a) == *" arm64" ]]; then
      MSSQL_IMAGE=mcr.microsoft.com/azure-sql-edge docker-compose start || true

		switch x := x.(type) {
		case *Line:
			f.add(&errs, x, x.Token[0], x.Token[1:], fix)

		case *LineBlock:
			if len(x.Token) > 1 {
				errs = append(errs, Error{
					Filename: file,
					Pos:      x.Start,
					Err:      fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
				})
				continue
			}
			switch x.Token[0] {
			default:
				errs = append(errs, Error{
					Filename: file,

        inDirectory a
        configurationCacheRun ':ok'

        then:
        configurationCache.assertStateStored()

        when:
        inDirectory b
        configurationCacheRun ':ok'

        then:
        configurationCache.assertStateLoaded()

        when:
        inDirectory a
        configurationCacheRun ':ok'

        then:
        configurationCache.assertStateLoaded()
    }