.thenReturn(extensionContainer)
        whenever(extensionContainer.getByType(eq(extensionType)))
            .thenReturn(extension)

        gradle.the<MyExtension>()
        gradle.configure<MyExtension> {}

        inOrder(extensionContainer) {
            verify(extensionContainer).getByType(eq(extensionType))
            verify(extensionContainer).configure(eq(extensionType), any<Action<MyExtension>>())

        when:
        container.add('i', impl)
        container.add('c', child)

        then:
        container.findByType(Capability) == impl
        container.getByType(Impl) == impl
        container.findByType(Parent) == child
        container.getByType(Parent) == child
    }

    def "can create ExtensionAware extensions"() {
        given:
        container.add("foo", Parent)

        }
    }

    @Test
    fun getByType() {

        val extensions = mock<ExtensionContainer> {
            on { getByType(any<TypeOf<SomeInterface<Long>>>()) } doReturn mock<SomeInterface<Long>>()
        }

        extensions.getByType<SomeInterface<Long>>()

        inOrder(extensions) {
            verify(extensions).getByType(any<TypeOf<SomeInterface<Long>>>())
            verifyNoMoreInteractions()

    @Override
    public Collection<CallInterceptionRequest> postProcessRequest(CallInterceptionRequest originalRequest) {
        Optional<ExecutableElement> maybeOriginatingElement = originalRequest.getRequestExtras().getByType(OriginatingElement.class)
            .map(OriginatingElement::getElement);

        if (!maybeOriginatingElement.isPresent()) {
            return Collections.singletonList(originalRequest);
        }

 */
inline fun <reified T : Any> ExtensionAware.the(): T =
    extensions.getByType(typeOf<T>())


/**
 * Returns the extension of the specified [extensionType].
 *
 * @param T the extension type.
 * @param extensionType the reified extension type.
 */
fun <T : Any> ExtensionAware.the(extensionType: KClass<T>): T =
    extensions.getByType(extensionType.java)


/**

        when:
        def list = storage.getByName("list")
        def set = storage.getByType(typeOf(Set))

        then:
        list == listExtension
        set == setExtension

        when:
        storage.getByName("foo")

        then:
        thrown UnknownDomainObjectException

        when:
        storage.getByType(typeOf(String))

        then:
        thrown UnknownDomainObjectException
    }

        interceptionRequests.forEach(request -> {
            if (request.getRequestExtras().getByType(RequestExtra.InterceptGroovyCalls.class).isPresent()) {
                String implementationName = request.getRequestExtras().getByType(RequestExtra.InterceptGroovyCalls.class)
                    .map(RequestExtra.InterceptGroovyCalls::getImplementationClassName)

    public Collection<CallInterceptionRequest> filterRequestsForResource(Collection<CallInterceptionRequest> interceptionRequests) {
        return interceptionRequests.stream()
            .filter(request -> request.getRequestExtras().getByType(PropertyUpgradeRequestExtra.class).isPresent())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {

    }

    def "registers javaToolchains extension"() {
        expect:
        project.extensions.getByType(JavaToolchainService) == project.extensions.getByName("javaToolchains")
    }

    def "toolchain service dependencies are satisfied"() {
        expect:
        project.extensions.getByType(JavaToolchainService).launcherFor(Actions.doNothing()).get().executablePath.asFile.isFile()
    }

            return p.getExtensions().getByType(JavaPluginExtension.class).getSourceCompatibility();
        }
    };
    public static final Function<Project, JavaVersion> TARGET_COMPATIBILITY = new Function<Project, JavaVersion>() {
        @Override
        public JavaVersion apply(Project p) {
            return p.getExtensions().getByType(JavaPluginExtension.class).getTargetCompatibility();
        }
    };