var _ volume.AttachableVolumePlugin = &fcPlugin{}

var _ volume.DeviceMountableVolumePlugin = &fcPlugin{}

func (plugin *fcPlugin) NewAttacher() (volume.Attacher, error) {
	return &fcAttacher{
		host:    plugin.host,
		manager: &fcUtil{},
	}, nil
}

func (plugin *fcPlugin) NewDeviceMounter() (volume.DeviceMounter, error) {
	return plugin.NewAttacher()
}

    }

    def "only closure literals can be used as rules"() {
        when:
        buildScript """
            class MyPlugin extends RuleSource {
                @Model
                String foo() {
                  "foo"
                }
            }

            apply type: MyPlugin

            def c = {};
            model {
                foo(c)
            }
        """

        // Simulating IdeaPlugin to only expose these values when 'java' plugin is applied
        if (project.getPlugins().hasPlugin(JavaPlugin.class)) {
            model.setExplicitSourceLanguageLevel(ideaModuleExt.getRawLanguageLevel());
            model.setExplicitTargetBytecodeVersion(ideaModuleExt.getRawTargetBytecodeVersion());
        }

 *
 * <ul>
 * <li>Creates a {@link org.gradle.language.c.tasks.CCompile} task for each {@link org.gradle.language.c.CSourceSet} to compile the C sources.</li>
 * </ul>
 */
@Incubating
public abstract class CPlugin implements Plugin<Project> {
    @Override
    public void apply(Project project) {
        project.getPluginManager().apply(NativeComponentPlugin.class);
        project.getPluginManager().apply(CLangPlugin.class);
    }

            ${ruleBasedTasks()}

            class MyPlugin extends RuleSource {
                @Mutate
                void applyMessages(ModelMap<EchoTask> tasks) {
                    tasks.afterEach {
                        message += " message!"
                    }
                }
            }

            apply type: MyPlugin

            task foo(type: EchoTask) { message = 'custom' }

        task(':b').originPlugin.displayName == "MyPlugin"
    }

    def "reports task origin for tasks defined in configuration callbacks"() {
        given:
        buildFile << """
            apply plugin: MyPlugin

            configurations {
                foo
            }

            class MyPlugin implements Plugin<Project> {
                void apply(Project project) {

                            .getMethod("findPlugin", Class::class.java)
                            .invoke(convention, T::class.java)
                    }
            }.let { findPlugin ->
                DeprecationLogger.whileDisabled(findPlugin)?.let { plugin ->
                    // Second lookup to trigger deprecation warning if convention is found
                    findPlugin.create()

inline fun <reified T : Any> Convention.findPlugin(): T? =
    findPlugin(T::class)


/**
 * Locates the plugin convention object with the given type.
 *
 * @param conventionType the convention plugin type.
 * @return the convention plugin, or null if there is no such convention plugin
 * @throws [IllegalStateException] when there are multiple matching objects
 * @see [Convention.findPlugin]
 */

            .thenReturn(convention)
        whenever(convention.findPlugin(eq(CustomConvention::class.java)))
            .thenReturn(javaConvention)

        project.the<CustomConvention>()

        inOrder(convention) {
            verify(convention).findByType(any<TypeOf<CustomConvention>>())
            verify(convention, times(2)).findPlugin(eq(CustomConvention::class.java))
            verifyNoMoreInteractions()
        }

        writeBuildSrcPlugin("buildSrc", "MyPlugin")
        buildFile << """
            apply plugin: MyPlugin
            // nuke buildSrc classes so we can't use them
            project.delete(file("buildSrc/build/classes"))
        """
        when:
        succeeds("myTaskMyPlugin")
        then:
        outputContains("From MyPlugin")
    }