void decodeFrom(InputStream inputStream, Closure<Decoder> closure) {
        def decoder = new KryoBackedDecoder(inputStream, 10)
        closure.call(decoder)
    }

    def "can encode and decode empty byte stream"() {
        when:
        def bytes = encode { Encoder encoder ->
            encoder.encodeChunked {}
            encoder.writeString("done")
        }

        then:
        decode(bytes) { Decoder decoder ->

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.stream;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import com.google.inject.AbstractModule;
import com.google.inject.binder.AnnotatedBindingBuilder;
import com.google.inject.name.Names;
import org.apache.maven.api.di.MojoExecutionScoped;

package org.gradle.internal.serialize;

import java.io.EOFException;

public interface ObjectReader<T> {
    /**
     * Reads the next object from the stream.
     *
     * @throws EOFException When the next object cannot be fully read due to reaching the end of stream.
     */
    T read() throws EOFException, Exception;

import org.gradle.workers.WorkerExecutor;

import javax.inject.Inject;
import java.io.IOException;
import java.nio.file.Files;
import java.util.List;
import java.util.stream.Stream;

import static com.google.common.collect.ImmutableList.toImmutableList;
import static java.util.stream.Collectors.joining;
import static org.gradle.api.problems.Severity.ERROR;

/**

// Test2json converts go test output to a machine-readable JSON stream.
//
// Usage:
//
//	go tool test2json [-p pkg] [-t] [./pkg.test -test.v=test2json]
//
// Test2json runs the given test command and converts its output to JSON;
// with no command specified, test2json expects test output on standard input.
// It writes a corresponding stream of JSON events to standard output.

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.lifecycle;

import java.util.*;
import java.util.stream.Collectors;

import org.apache.maven.lifecycle.mapping.LifecyclePhase;

/**
 * Lifecycle definition, with eventual plugin bindings (when they are not packaging-specific).
 */
public class Lifecycle {

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.internal.jvm.Jvm
import org.gradle.test.fixtures.plugin.PluginBuilder

import javax.inject.Inject
import java.util.stream.Stream

class TestTaskPropertiesServiceIntegrationTest extends AbstractIntegrationSpec {

    def "provides task configuration to plugin"() {
        given:
        new PluginBuilder(file("buildSrc")).with {

    public DefaultTypeRegistry(
            List<TypeProvider> providers, LanguageRegistry languageRegistry, LegacyArtifactHandlerManager manager) {
        this.types = nonNull(providers, "providers").stream()
                .flatMap(p -> p.provides().stream())
                .collect(Collectors.toMap(Type::id, identity()));
        this.languageRegistry = nonNull(languageRegistry, "languageRegistry");
        this.usedTypes = new ConcurrentHashMap<>();

import org.gradle.internal.logging.ConsoleRenderer;
import org.gradle.internal.serialization.Cached;
import org.gradle.util.internal.ClosureBackedAction;

import javax.inject.Inject;
import java.util.stream.Stream;

/**
 * Generates an HTML dependency report. This report
 * combines the features of the ASCII dependency report and those of the ASCII