*/
package org.gradle.api;

/**
 * <p>A {@code UnknownDomainObjectException} is the super class of all exceptions thrown when a given domain object
 * cannot be located.</p>
 */
public class UnknownDomainObjectException extends GradleException {
    public UnknownDomainObjectException(String message) {
        super(message);
    }

    public UnknownDomainObjectException(String message, Throwable cause) {
        super(message, cause);

     *
     * @param type extension type
     * @return extension, never null
     * @throws UnknownDomainObjectException When the given extension is not found.
     */
    <T> T getByType(Class<T> type) throws UnknownDomainObjectException;

    /**
     * Looks for the extension of a given type (useful to avoid casting). If none found it will throw an exception.
     *

    @Override
    public T getAt(String name) throws UnknownDomainObjectException {
        return getDelegate().getAt(name);
    }

    @Override
    public T getByName(String name) throws UnknownDomainObjectException {
        return getDelegate().getByName(name);
    }

    @Override
    public T getByName(String name, Closure configureClosure) throws UnknownDomainObjectException {

    }

    @Override
    T getByName(String name) throws UnknownDomainObjectException {
        return null
    }

    @Override
    T getByName(String name, Closure configureClosure) throws UnknownDomainObjectException {
        return null
    }

    @Override
    T getByName(String name, Action<? super T> configureAction) throws UnknownDomainObjectException {
        return null
    }

    @Override

 * limitations under the License.
 */
package gradlebuild.docs.model;

import groovy.lang.Closure;
import org.gradle.api.UnknownDomainObjectException;

public interface ClassMetaDataRepository<T> {
    T get(String fullyQualifiedClassName) throws UnknownDomainObjectException;

    T find(String fullyQualifiedClassName);

    void put(String fullyQualifiedClassName, T metaData);

    void each(Closure cl);

 * limitations under the License.
 */
package org.gradle.api.artifacts;

import org.gradle.api.UnknownDomainObjectException;

/**
 * <p>An {@code UnknownConfigurationException} is thrown when a configuration referenced by name cannot be found.</p>
 */
public class UnknownConfigurationException extends UnknownDomainObjectException {
    public UnknownConfigurationException(String message) {
        super(message);
    }

            .thenReturn(convention)
        whenever(convention.getByType(eq(conventionType)))
            .thenThrow(UnknownDomainObjectException::class.java)

        try {
            project.the<CustomConvention>()
            fail("UnknownDomainObjectException not thrown")
        } catch (ex: UnknownDomainObjectException) {
            // expected
        }

        inOrder(convention) {

     *
     * @param name The object name
     * @return The object with the given name. Never returns null.
     * @throws UnknownDomainObjectException when there is no such object in this collection.
     */
    T getByName(String name) throws UnknownDomainObjectException;

    /**
     * Locates an object by name, failing if there is no such object. The given configure closure is executed against

                the<Unregistered>()
                throw Exception("UnknownDomainObjectException not thrown")
            } catch(ex: UnknownDomainObjectException) {}

            try {
                the(Unregistered::class)
                throw Exception("UnknownDomainObjectException not thrown")
            } catch(ex: UnknownDomainObjectException) {}

            try {
                configure<Unregistered> {}

 */

package org.gradle.kotlin.dsl

import org.gradle.api.UnknownDomainObjectException
import org.gradle.api.plugins.ExtensionContainer

import kotlin.reflect.KProperty


/**
 * Looks for the extension of a given name. If none found it will throw an exception.
 *
 * @param name extension name
 * @return extension
 * @throws [UnknownDomainObjectException] When the given extension is not found.
 *