private final boolean lowerBoundInclusive;

    private final ArtifactVersion upperBound;

    private final boolean upperBoundInclusive;

    public static final Restriction EVERYTHING = new Restriction(null, false, null, false);

    public Restriction(
            ArtifactVersion lowerBound,
            boolean lowerBoundInclusive,
            ArtifactVersion upperBound,
            boolean upperBoundInclusive) {

import (
	"testing"
	"time"

	"gorm.io/gorm"
)

func TestDefaultValue(t *testing.T) {
	type Harumph struct {
		gorm.Model
		Email   string    `gorm:"not null;index:,unique"`
		Name    string    `gorm:"notNull;default:foo"`
		Name2   string    `gorm:"size:233;not null;default:'foo'"`
		Name3   string    `gorm:"size:233;notNull;default:''"`
		Age     int       `gorm:"default:18"`
		Created time.Time `gorm:"default:2000-01-02"`

     *
     * @return The decrypted server or {@code null}.
     */
    Server getServer();

    /**
     * Gets the decrypted servers.
     *
     * @return The decrypted server, can be empty but never {@code null}.
     */
    List<Server> getServers();

    /**

 */
@Deprecated(since = "4.0.0")
public class MavenToolchainMerger {

    public void merge(PersistedToolchains dominant, PersistedToolchains recessive, String recessiveSourceLevel) {
        if (dominant == null || recessive == null) {
            return;
        }

        recessive.setSourceLevel(recessiveSourceLevel);

        shallowMerge(dominant.getToolchains(), recessive.getToolchains(), recessiveSourceLevel);
    }

        this(session, project, null, null);
    }

    public ProjectExecutionEvent(MavenSession session, MavenProject project, List<MojoExecution> executionPlan) {
        this(session, project, executionPlan, null);
    }

    public ProjectExecutionEvent(MavenSession session, MavenProject project, Throwable cause) {
        this(session, project, null, cause);
    }

    public ProjectExecutionEvent(

        return this;
    }

    @Override
    public void normalize(Model model, ModelBuildingRequest request) {
        if (model == null) {
            return;
        }

        model.setUrl(normalize(model.getUrl()));

        Scm scm = model.getScm();
        if (scm != null) {
            scm.setUrl(normalize(scm.getUrl()));
            scm.setConnection(normalize(scm.getConnection()));

    private final int hashCode;

    /**
     * Creates a new source backed by the specified URL.
     *
     * @param url The file, must not be {@code null}.
     */
    public UrlSource(URL url) {
        this.url = Objects.requireNonNull(url, "url cannot be null");
        this.hashCode = Objects.hashCode(url);
    }

    @Override
    public InputStream getInputStream() throws IOException {

        notBlank(groupId, "groupId can neither be null, empty nor blank");
        notBlank(artifactId, "artifactId can neither be null, empty nor blank");
        notBlank(version, "version can neither be null, empty nor blank");

        return groupId + ":" + artifactId + ":" + version;
    }

    private static void notBlank(String str, String message) {
        final int strLen = str != null ? str.length() : 0;
        if (strLen > 0) {

        // Intentionally notNull because Super POM may not contain a modelId
        Objects.requireNonNull(modelId, "modelId cannot null");

        if (activeProfiles != null) {
            this.activePomProfiles.put(modelId, new ArrayList<>(activeProfiles));
        } else {
            this.activePomProfiles.remove(modelId);
        }

        return this;

        this.lookup = requireNonNull(lookup, "lookup cannot be null");
        this.languageRegistry = requireNonNull(languageRegistry, "languageRegistry cannot be null");
        this.usedTypes = new ConcurrentHashMap<>();
        this.manager = requireNonNull(manager, "artifactHandlerManager cannot be null");
    }

    @Override
    public void onEvent(Object event) {