Map<String, String> attributes = Cast.uncheckedNonnullCast(xml.attributes());
            attributes.put("buildForRunning", toYesNo(buildForRunning));
        }

        public void setBuildForTesting(boolean buildForTesting) {
            Map<String, String> attributes = Cast.uncheckedNonnullCast(xml.attributes());
            attributes.put("buildForTesting", toYesNo(buildForTesting));

        assert values.length > 0;
        return new TestProvider<>(Cast.uncheckedNonnullCast(values[0].getClass()), Arrays.asList(values), null);
    }

    public static <T> ProviderInternal<T> withChangingExecutionTimeValues(T... values) {
        assert values.length > 0;
        return new TestProviderWithChangingValue<>(Cast.uncheckedNonnullCast(values[0].getClass()), Arrays.asList(values), null);
    }

        super.convention(provider);
        return this;
    }

    @Override
    public SetProperty<T> unset() {
        return uncheckedNonnullCast(super.unset());
    }

    @Override
    public SetProperty<T> unsetConvention() {
        return uncheckedNonnullCast(super.unsetConvention());
    }

        super.convention(provider);
        return this;
    }

    @Override
    public ListProperty<T> unset() {
        return uncheckedNonnullCast(super.unset());
    }

    @Override
    public ListProperty<T> unsetConvention() {
        return uncheckedNonnullCast(super.unsetConvention());
    }

        changes.accept(propertyName, visitor);
        return Cast.uncheckedNonnullCast(visitor.getChanges());
    }

    @Override
    public Iterable<InputFileDetails> getAllFileChanges() {
        CollectingChangeVisitor visitor = new CollectingChangeVisitor();
        changes.accept(visitor);
        return Cast.uncheckedNonnullCast(visitor.getChanges());
    }

        ClassImplementationSnapshot currentImplementation = Cast.uncheckedNonnullCast(thisExecution.getImplementation());
        ClassImplementationSnapshot previousImplementation = Cast.uncheckedNonnullCast(lastExecution.getImplementation());
        ImmutableList<ImplementationSnapshot> currentAdditionalImplementations = Cast.uncheckedNonnullCast(thisExecution.getAdditionalImplementations());

        File self,
        Function2<?, ?, ?> action,
        @CallerClassName String consumer
    ) {
        Instrumented.fileOpened(self, consumer);
        FilesKt.forEachBlock(self, Cast.uncheckedNonnullCast(action));
    }

    @InterceptCalls
    @StaticMethod(ofClass = FilesKt.class)
    public static void intercept_forEachBlock(
        File self,
        int blockSize,
        Function2<?, ?, ?> action,

                return null;
            }
            // TODO - should preserve the property type (which may be different to the provider type)
            ProviderInternal<S> provider = Cast.uncheckedNonnullCast(state);
            return type.cast(propertyOf(provider.getType(), provider));
        }

        <V> Property<V> propertyOf(Class<V> type, Provider<V> value) {

 * limitations under the License.
 */
package org.gradle.internal.service;

import java.lang.reflect.Method;

import static org.gradle.internal.Cast.uncheckedNonnullCast;

/**
 * A service method factory that will try to use method handles if available, otherwise fallback on reflection.
 */
class DefaultServiceMethodFactory implements ServiceMethodFactory {

        return concat(node, key, isolate(value));
    }

    private <T> Isolatable<T> isolate(@Nullable T value) {
        if (value instanceof String) {
            return Cast.uncheckedNonnullCast(new CoercingStringValueSnapshot((String) value, instantiator));
        } else {
            return isolatableFactory.isolate(value);
        }
    }

    @Override