public DescribingAndSpec<T> and(Closure closure, String description) {
        return and(new ClosureSpec<>(closure), description);
    }

    public static <T> DescribingAndSpec<T> empty() {
        return Cast.uncheckedNonnullCast(EMPTY);
    }

        this.argument = argument;
    }

    private static String toMessage(Closure<?> closure, Object argument) {
        List<Object> classNames = CollectionUtils.collect(Cast.<Class<?>[]>uncheckedNonnullCast(closure.getParameterTypes()), Class::getName);
        return String.format(

    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

        }

        private EntriesFromMapProvider(ProviderInternal<? extends Map<? extends K, ? extends V>> providerOfEntries, boolean ignoreAbsent) {
            this.providerOfEntries = ignoreAbsent ? neverMissing(Cast.uncheckedNonnullCast(providerOfEntries)) : providerOfEntries;
            this.ignoreAbsent = ignoreAbsent;
        }

        @Override
        public MapCollector<K, V> absentIgnoring() {

        }
    }

    @Override
    public boolean addPending(final ProviderInternal<? extends T> provider) {
        if (provider instanceof ChangingValue) {
            Cast.<ChangingValue<T>>uncheckedNonnullCast(provider).onValueChange(previousValue -> {
                values.remove(previousValue);
                pending.add(collectorFromProvider(provider));
            });
        }

        this.buildOperationRunner = buildOperationRunner;
        this.specFactory = specFactory;
        IsolationScheme<WorkAction<?>, WorkParameters> isolationScheme = new IsolationScheme<>(Cast.uncheckedNonnullCast(WorkAction.class), WorkParameters.class, WorkParameters.None.class);
        workerServer = new DefaultWorkerServer(internalServices, instantiatorFactory, isolationScheme, Collections.singleton(WorkerExecutor.class));
    }

    }

    /**
     * Typed and() method for a single {@link Spec}.
     *
     * @since 4.3
     */
    public AndSpec<T> and(Spec<? super T> spec) {
        return and(Cast.<Spec<? super T>[]>uncheckedNonnullCast(new Spec<?>[]{spec}));
    }

    @SuppressWarnings("rawtypes")
    public AndSpec<T> and(Closure spec) {
        return and(new ClosureSpec<>(spec));
    }

    public static <T> AndSpec<T> empty() {

            }
        }

        return !hasNonReadMode;
    }

    public static boolean optionsAllowReading(Set<?> options) {
        return optionsAllowReading(Cast.<Set<OpenOption>>uncheckedNonnullCast(options).toArray(new OpenOption[0]));
    }

    public static void tryReportFileOpened(Path path, String consumer) {
        File file = toFileIfAvailable(path);
        if (file != null) {