import org.gradle.internal.HasInternalProtocol;

import javax.annotation.Nullable;

/**
 * Allows adding 'namespaced' DSL extensions to a target object.
 */
@HasInternalProtocol
public interface ExtensionContainer {

    /**
     * Adds a new extension to this container.
     *
     * Adding an extension of name 'foo' will:
     * <ul>
     * <li> add 'foo' dynamic property

 *
 * @see [ExtensionContainer.getByType]
 * @since 5.0
 */
inline fun <reified T : Any> ExtensionContainer.getByType(): T =
    getByType(typeOf<T>())


/**
 * Looks for the extension of a given type.
 *
 * @param T the extension type
 * @return the extension or null if not found
 *
 * @see [ExtensionContainer.findByType]
 * @since 5.0
 */

            .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>>())

            );
        }
        return convention;
    }

    @Override
    public ExtensionContainer getExtensions() {
        if (extensionContainer == null) {
            this.extensionContainer = toType(object, ExtensionAware.class).getExtensions();
        }
        return extensionContainer;
    }

    @Override
    public ConventionMapping getConventionMapping() {

class VisualStudioPluginRules {
    static class VisualStudioExtensionRules extends RuleSource {
        @Model
        public static VisualStudioExtensionInternal visualStudio(ExtensionContainer extensionContainer) {
            return (VisualStudioExtensionInternal) extensionContainer.getByType(VisualStudioExtension.class);
        }
    }

    static class VisualStudioPluginRootRules extends RuleSource {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl

import org.gradle.api.Action
import org.gradle.api.plugins.ExtensionContainer
import org.gradle.api.reflect.TypeOf

import com.nhaarman.mockito_kotlin.any
import com.nhaarman.mockito_kotlin.anyVararg
import com.nhaarman.mockito_kotlin.doNothing
import com.nhaarman.mockito_kotlin.doReturn

    val dependencyConstraintHandler = DependencyConstraintHandler::class.internalName

    val extensionAware = ExtensionAware::class.internalName

    val extensionContainer = ExtensionContainer::class.internalName

    val namedDomainObjectProvider = NamedDomainObjectProvider::class.internalName

    val taskProvider = TaskProvider::class.internalName

        @Model
        NativeToolChainRegistryInternal toolChains(ExtensionContainer extensionContainer) {
            return Cast.cast(NativeToolChainRegistryInternal.class, extensionContainer.getByType(NativeToolChainRegistry.class));
        }

        @Model
        BuildTypeContainer buildTypes(ExtensionContainer extensionContainer) {
            return extensionContainer.getByType(BuildTypeContainer.class);
        }

        @Model

 */

package org.gradle.api.publish.plugins;

import org.gradle.api.Task;
import org.gradle.api.internal.artifacts.ivyservice.projectmodule.ProjectPublicationRegistry;
import org.gradle.api.plugins.ExtensionContainer;
import org.gradle.api.publish.PublishingExtension;
import org.gradle.internal.service.ServiceRegistry;
import org.gradle.model.Model;
import org.gradle.model.ModelMap;
import org.gradle.model.Mutate;

 * limitations under the License.
 */

package org.gradle.api.internal.plugins;

import org.gradle.api.plugins.ExtensionContainer;

import java.util.Map;

public interface ExtensionContainerInternal extends ExtensionContainer {
    /**
     * Provides access to all known extensions.
     * @return A map of extensions, keyed by name.
     */
    Map<String, Object> getAsMap();