@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

            .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.
 *

        return types;
    }

    /**
     * Doesn't actually return anything. Always throws a {@link UnknownDomainObjectException}.
     *
     * @return Nothing.
     */
    private UnknownDomainObjectException unknownExtensionException(final String name) {
        throw new UnknownDomainObjectException("Extension with name '" + name + "' does not exist. Currently registered extension names: " + extensions.keySet());
    }

 *
 * If an object with the given [name] is not found, [UnknownDomainObjectException] is thrown.
 * If the object is found but cannot be cast to the expected type [T], [IllegalArgumentException] is thrown.
 *
 * @param name object name
 * @return the object, never null
 * @throws [UnknownDomainObjectException] When the given object is not found.

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

import java.nio.file.Files
import org.gradle.api.Action
import org.gradle.api.UnknownDomainObjectException
import spock.lang.Specification
import spock.lang.TempDir

class SimpleClassMetaDataRepositoryTest extends Specification {
    @TempDir File tmpDir

        list == listExtension
        set == setExtension

        when:
        storage.getByName("foo")

        then:
        thrown UnknownDomainObjectException

        when:
        storage.getByType(typeOf(String))

        then:
        thrown UnknownDomainObjectException
    }

    def "configure extension"() {
        when:
        def shouldNotExist = "shouldNotExist"