}
            return Cast.uncheckedNonnullCast(typeInfo.serializer.read(decoder));
        }

        @Override
        public void write(Encoder encoder, T value) throws Exception {
            TypeInfo typeInfo = map(value.getClass());
            encoder.writeSmallInt(typeInfo.tag);
            Cast.<Serializer<T>>uncheckedNonnullCast(typeInfo.serializer).write(encoder, value);
        }

 * limitations under the License.
 */

package org.gradle.internal.extensions.stdlib

import org.gradle.internal.Cast


fun <T> Any.uncheckedCast(): T =

        if (type.isInstance(value)) {
            return type.cast(value);
        }
        if (type.isEnum() && type.getName().equals(value.getDeclaringClass().getName())) {
            return type.cast(Enum.valueOf(Cast.uncheckedNonnullCast(type.asSubclass(Enum.class)), value.name()));
        }
        return null;
    }

import org.gradle.internal.serialize.beans.services.DefaultBeanStateWriterLookup
import org.gradle.internal.cc.impl.services.IsolatedActionCodecsFactory
import org.gradle.internal.Cast.uncheckedNonnullCast
import org.gradle.internal.isolation.IsolatedActionsForTesting.isolatedActionLambdaWith
import org.gradle.internal.serialize.codecs.core.jos.JavaSerializationEncodingLookup
import org.gradle.util.TestUtil

    public void setClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    @Override
    public T read(Decoder decoder) throws Exception {
        try {
            return Cast.uncheckedNonnullCast(new ClassLoaderObjectInputStream(decoder.getInputStream(), classLoader).readObject());
        } catch (StreamCorruptedException e) {
            return null;
        }
    }

    @Override

            return null;
        }

        final DeserializeMap map = classLoaderRegistry.newDeserializeSession();
        try {
            final Map<Short, ClassLoaderDetails> classLoaderDetails = Cast.uncheckedNonnullCast(payload.getHeader());
            StreamByteBuffer buffer = StreamByteBuffer.of(payload.getSerializedModel());

        Object results = connection.run(action, buildCancellationToken, providerParameters);
        return new ProviderBuildResult<>(Cast.uncheckedNonnullCast(results));
    }

    /**
     * This is used by consumers 4.4 and later
     */
    @Override

            setSupplier(new FixedSupplier<>(value.getFixedValue(), Cast.uncheckedCast(value.getSideEffect())));
        } else {
            CollectingProvider<T, C> asCollectingProvider = Cast.uncheckedNonnullCast(value.getChangingValue());
            setSupplier(new CollectingSupplier(new ElementsFromCollectionProvider<>(asCollectingProvider)));
        }
    }

    @Override

            this.provider = ignoreAbsent ? neverMissing(Cast.uncheckedNonnullCast(provider)) : provider;
            this.ignoreAbsent = ignoreAbsent;
        }

        @Nonnull
        private static <T> ProviderInternal<? extends Iterable<? extends T>> neverMissing(ProviderInternal<Iterable<? extends T>> provider) {
            return Cast.uncheckedNonnullCast(provider.orElse(ImmutableList.of()));
        }

        @Override

            setSupplier(noValueSupplier());
        } else if (value.hasFixedValue()) {
            setSupplier(new FixedSupplier<>(uncheckedNonnullCast(value.getFixedValue()), uncheckedCast(value.getSideEffect())));
        } else {
            CollectingProvider<K, V> asCollectingProvider = uncheckedNonnullCast(value.getChangingValue());
            setSupplier(new CollectingSupplier(new EntriesFromMapProvider<>(asCollectingProvider)));
        }