* @param severity
     * @param version
     */
    public ModelProblemCollectorRequest(Severity severity, Version version) {
        this.severity = Objects.requireNonNull(severity, "severity cannot be null");
        this.version = Objects.requireNonNull(version, "version cannot be null");
    }

    public Severity getSeverity() {
        return severity;
    }

    public Version getVersion() {

import org.elasticsearch.gradle.internal.test.rest.transform.RestTestTransformByParentArray;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.Internal;

import java.util.Objects;

/**
 * Adds a match for a REST test. For example add the follow where it did not exist prior to running this: "match":{"_type": "foo"}
 */
public class AddMatch implements RestTestTransformByParentArray {

        if (typeof options.startDate === 'object')
            this.startDate = moment(options.startDate);

        if (typeof options.endDate === 'object')
            this.endDate = moment(options.endDate);

        if (typeof options.minDate === 'object')
            this.minDate = moment(options.minDate);

        if (typeof options.maxDate === 'object')
            this.maxDate = moment(options.maxDate);

var magicHighwayHash256Key = []byte("\x4b\xe7\x34\xfa\x8e\x23\x8a\xcd\x26\x3e\x83\xe6\xbb\x96\x85\x52\x04\x0f\x93\x5d\xa3\x9f\x44\x14\x97\xe0\x9d\x13\x22\xde\x36\xa0")

// Interface for elasticsearch client objects
type esClient interface {
	isAtleastV7() bool
	createIndex(ElasticsearchArgs) error
	ping(context.Context, ElasticsearchArgs) (bool, error)
	stop()
	entryExists(context.Context, string, string) (bool, error)

# ADR-0002 - Avoid using Java serialization

## Status

- ACCEPTED on 2023-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

        // enrich user properties with project packaging
        Properties userProperties = request.getUserProperties();
        userProperties.computeIfAbsent(
                (Object) ProfileActivationContext.PROPERTY_NAME_PACKAGING, (p) -> (Object) rawModel.getPackaging());
        context.setUserProperties(userProperties);
        context.setProjectDirectory(

	if !o.isSorted() {
		t.Fatal("Expected sorted objects")
	}

	// Swap first and last
	o[0], o[len(o)-1] = o[len(o)-1], o[0]
	if o.isSorted() {
		t.Fatal("Expected unsorted objects")
	}

	sorted := o.sort()
	if !o.isSorted() {
		t.Fatal("Expected sorted o objects")
	}
	if !sorted.entries().isSorted() {
		t.Fatal("Expected sorted wrapped objects")
	}
	want := loadMetacacheSampleNames

        // So we just verify that compression/decompression works correctly
        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
    }

    // Helper methods for creating mock objects
    private SearchRequestParams createMockSearchRequestParams() {
        return new MockSearchRequestParams();
    }

    // Mock classes
    private static class MockFessConfig extends FessConfig.SimpleImpl {

	queue        chan *queueItem        // output from workers in order
	err          error                  // global error state, only touched by Reader.Read
	bufferPool   bpool.Pool[[]byte]     // pool of []byte objects for input
	csvDstPool   bpool.Pool[[][]string] // pool of [][]string used for output
	close        chan struct{}          // used for shutting down the splitter before end of stream

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.maven.api.feature.Features;
import org.apache.maven.api.model.Model;
import org.apache.maven.api.services.Interpolator;