private VersionParserException parseInvalid(String constraint) {
        try {
            versionParser.parseVersionConstraint(constraint);
            fail("expected exception for constraint " + constraint);
            return null;
        } catch (VersionParserException e) {
            return e;
        }
    }

    @Test

            root(':', ':testproject:') {
                module("group:bom:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")
                    noArtifacts()
                }
                module("group:bom2:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")
                    noArtifacts()
                }

// run

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type Constraint[T any] interface {
	~func() T
}

func Foo[T Constraint[T]]() T {
	var t T

	t = func() T {
		return t
	}
	return t
}

func main() {
	type Bar func() Bar
	Foo[Bar]()

        // These are invalid and the type-checker will complain.
        _[~t] t
        _[~t|t] t
        _[t|~t] t
        _[~t|~t] t
)

type _[_ t, t] /* ERROR "missing type constraint" */ t
type _[_ ~t, t] /* ERROR "missing type constraint" */ t
type _[_ t, ~ /* ERROR "missing type parameter name" */ t] t
type _[_ ~t, ~ /* ERROR "missing type parameter name" */ t] t

type _[_ t|t, t /* ERROR "missing type parameter name" */ |t] t

                    byAncestor()
                    configuration(expectedVariant)
                    constraint('org:core:2.7.9')
                    constraint('org:databind:2.7.9')
                    constraint('org:annotations:2.7.9')
                    constraint('org:kotlin:2.7.9')
                    noArtifacts()
                    module("org:platform:2.7.9")
                }
            }

            platform.hasGradleMetadataRedirectionMarker()
            platform.parsedModuleMetadata.variant("apiElements") {
                constraint("com.acme.foo:core:$v") {
                    exists()
                }
                constraint("com.acme.foo:lib:$v") {
                    exists()
                }
                noMoreDependencies()
            }

     */
    @Nonnull
    VersionRange parseVersionRange(@Nonnull String range);

    /**
     * Parses the specified version constraint specification, for example "1.0" or "[1.0,2.0)".
     *
     * @param constraint the range specification to parse, must not be {@code null}
     * @return the parsed version constraint, never {@code null}
     * @throws VersionParserException if the range specification violates the syntax rules of this scheme
     */

    fun `can declare classpath dependency constraints`() {

        val constraint = mock<DependencyConstraint>()
        val constraintHandler = mock<DependencyConstraintHandler> {
            on { add(any(), any()) } doReturn constraint
            on { add(any(), any(), any()) } doReturn constraint
        }
        val dependencies = newDependencyHandlerMock {
            on { constraints } doReturn constraintHandler

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

import org.codelibs.fess.validation.UriTypeValidator.ProtocolType;

@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = UriTypeValidator.class)
public @interface UriType {

    ProtocolType protocolType();

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"