((Supplier<Object>) () -> {
                    try {
                        new FileInputStream(new File("$filePath")).close();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    return null;
                }).get()"""
            }

            @Override
            String getGroovyExpression() {

    @Inject
    protected ObjectFactory getObjectFactory() {
        throw new UnsupportedOperationException();
    }

    @Inject
    protected VersionSelectorScheme getVersionSelectorScheme() {
        throw new UnsupportedOperationException();
    }

    @Inject
    protected VersionComparator getVersionComparator() {
        throw new UnsupportedOperationException();
    }

    @Inject

    public void formatProgress(StringBuilder builder, long progressedSize, long size) {
        if (progressedSize < 0L) {
            throw new IllegalArgumentException("progressed file size cannot be negative: " + size);
        }
        if (size >= 0 && progressedSize > size) {
            throw new IllegalArgumentException(
                    "progressed file size cannot be greater than size: " + progressedSize + " > " + size);
        }

            // with the delegate
            if (targetMetadata.hasProperty(null, propertyName) == null) {
                if (propertyName == "class") {
                    return javaClass
                }
                throw MissingPropertyException(propertyName)
            }

		return
	}
	e := efaceOf(&obj)
	etyp := e._type
	if etyp == nil {
		throw("runtime.SetFinalizer: first argument is nil")
	}
	if etyp.Kind_&abi.KindMask != abi.Pointer {
		throw("runtime.SetFinalizer: first argument is " + toRType(etyp).string() + ", not pointer")
	}
	ot := (*ptrtype)(unsafe.Pointer(etyp))
	if ot.Elem == nil {
		throw("nil elem type!")
	}

	if inUserArenaChunk(uintptr(e.data)) {

        // Let IO and configuration cache exceptions surface to the top.
        if (error is IOException || error is ConfigurationCacheThrowable) {
            throw error
        }
        throw ConfigurationCacheError(
            "Configuration cache state could not be cached: $trace: ${StructuredMessage.build(message)}",
            error.maybeUnwrapInvocationTargetException()
        )
    }

            return method;
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException(e);
        }
    }

    private static boolean callStaticAgentMethod(Method method, Object... args) {
        try {
            return (boolean) method.invoke(null, args);
        } catch (IllegalAccessException e) {
            throw new IllegalArgumentException(e);
        } catch (InvocationTargetException e) {

        override fun outputStream(): OutputStream =
            throw UnsupportedOperationException()

        override fun inputStream(): InputStream =
            file.also(::markAccessed).inputStream()

        override fun delete() {
            throw UnsupportedOperationException()
        }

        override fun moveFrom(file: File) {
            throw UnsupportedOperationException()
        }

        then:
        thrown(RuntimeException)
    }

    def "RuntimeExcpetion is thrown if a version lower than the minimal tested is specified"() {
        given:
        def spec = new GradleVersionSpec("3.0")

        when:
        spec.toSpec("<1.3")

        then:
        thrown(RuntimeException)
    }

            }

            return daemonGreeter.parseDaemonOutput(outputConsumer.getProcessOutput(), args);
        } catch (GradleException e) {
            throw e;
        } catch (Exception e) {
            throw new GradleException("Could not start Gradle daemon.", e);
        } finally {
            LOGGER.info("An attempt to start the daemon took {}.", clock.getElapsed());
        }
    }