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"

     * Determines the published coordinates for an external dependency constraint to component-level precision.
     *
     * @return null if the external dependency constraint could not be resolved.
     */
    @Nullable
    ResolvedCoordinates resolveComponentCoordinates(DependencyConstraint dependency);

    /**
     * Determines the published coordinates for a project dependency constraint to component-level precision.
     *

    }

    @Override
    public VersionConstraint parseVersionConstraint(String constraint) {
        requireNonNull(constraint, "constraint");
        return new DefaultVersionConstraint(versionScheme, constraint);
    }

    static class DefaultVersion implements Version {
        private final VersionScheme versionScheme;

    @Test
    fun `can declare dependency constraints`() {

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

        }

        private boolean isNotRequiredVersionOnly(VersionConstraint constraint) {
            return !constraint.getPreferredVersion().isEmpty()
                || !constraint.getStrictVersion().isEmpty()
                || !constraint.getRejectedVersions().isEmpty()
                || constraint.getBranch() != null;
        }

    }

    private VersionRef selectVersionFromRepository(VersionControlRepositoryConnection repository, VersionConstraint constraint) {
        // TODO: match with status, order versions correctly

        if (constraint.getBranch() != null) {
            return repository.getBranch(constraint.getBranch());
        }

        String version = constraint.getRequiredVersion();
        VersionSelector versionSelector = versionSelectorScheme.parseSelector(version);

        _[~t] t
        _[~t|t] t
        _[t|~t] t
        _[~t|~t] t
)

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

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

     * Indicates if the lock state must be strictly validated.
     *
     * If {@code true}, each locked dependency is added as a strict constraint,
     * and the resolution result must exactly match the set of locked dependencies.
     *
     * If {@code false}, each locked dependency is added a regular (lenient) constraint,
     * and the resolution result is not verified against the set of locked dependencies.
     *

                ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES)
            );
        }
        return addInternalDependencyConstraint(dependencyConstraint);
    }

    // For internal use only, allows adding a dependency constraint without issuing a deprecation warning