}

    @Override
    public boolean isPropertyRelevant() {
        return true;
    }

    @Override
    public void visitPropertyValue(String propertyName, PropertyValue value, PropertyMetadata propertyMetadata, PropertyVisitor visitor) {
        propertyMetadata.getAnnotation(ServiceReference.class).ifPresent(annotation -> {
            String serviceName = annotation.value();

        when:
        withEntryPoint(GET_PROPERTY, propertyName) {
            property = instance.metaClass.getMetaProperty(propertyName)
        }

        then:
        property != null
        (property instanceof CallInterceptingMetaClass.InterceptedMetaProperty) == shouldIntercept

        where:
        propertyName | shouldIntercept
        "testString" | true
        "metaClass"  | false

        property(name) { jsonString(value) }
    }

    private
    inline fun property(name: String, value: () -> Unit) {
        propertyName(name)
        value()
    }

    private
    fun propertyName(name: String) {
        simpleString(name)
        write(':')
    }

    private
    fun simpleString(name: String) {
        write('"')
        write(name)

            "output", staleFileAddedBetweenExecutions
        )

        when:
        def overlaps = detector.detect(previousOutputFiles, outputFilesBeforeExecution)

        then:
        overlaps.propertyName == "output"
        overlaps.overlappedFilePath == "/absolute/path"
    }

    def "detects overlap when there is a stale #type in an output directory"() {

            String propertyName = request.getInterceptedCallable().getCallableName();
            String setterName = "set" + TextUtil.capitalize(propertyName);
            scopeExpressions.add(CodeBlock.of("$1T.writesOfPropertiesNamed($2S)", INTERCEPTED_SCOPE_CLASS, propertyName));

        for (Method method : methods) {
            if (isGetter(method)) {
                String propertyName = getPropertyName(method.getName());
                try {
                    Object propertyValue = method.invoke(parameter);
                    properties.put(propertyName, propertyValue);
                } catch (IllegalAccessException | InvocationTargetException e) {

            work.visitOutputs(context.getWorkspace(), new UnitOfWork.OutputVisitor() {
                @Override
                public void visitOutputProperty(String propertyName, TreeType type, UnitOfWork.OutputFileValueSupplier value) {
                    File root = value.getValue();
                    switch (type) {
                        case FILE:

        metadata.visitValidationFailures(null, validationContext)

        then:
        validationContext.problems.isEmpty()

        when:
        def properties = metadata.propertiesMetadata.groupBy { it.propertyName }

        then:
        metadata.getAnnotationHandlerFor(properties.prop1) == handler1
        metadata.getAnnotationHandlerFor(properties.prop2) == handler2
    }

    /**
     * {@link PropertyDesc}を持っているかどうかを返します。
     *
     * @param propertyName
     *            プロパティ名。{@literal null}や空文字列であってはいけません
     * @return {@link PropertyDesc}を持っているかどうか
     */
    boolean hasPropertyDesc(String propertyName);

    /**
     * {@link PropertyDesc}を返します。
     *
     * @param propertyName
     *            プロパティ名。{@literal null}や空文字列であってはいけません
     * @return {@link PropertyDesc}

        changedFiles.collectMany { propertyName, files ->
            files.collect { file ->
                "${type} property '${propertyName}' file ${file.absolutePath} has changed.".toString()
            }
        }
    }

    List<String> filesAdded(Map<String, List<File>> addedFiles) {
        addedFiles.collectMany { propertyName, files ->
            files.collect { file ->