}

        override fun getDependencyLocking(): DependencyLockingHandler {
            onAccess("dependencyLocking")
            return delegate.dependencyLocking
        }

        override fun getPlugins(): PluginContainer {
            onAccess("plugins")
            return delegate.plugins
        }

        override fun apply(closure: Closure<*>) {
            onAccess("apply")

    }

    /**
     * @return a Map of plugins field with {@code Plugins#getKey()} as key
     * @see Plugin#getKey()
     */
    public Map<String, Plugin> getPluginsAsMap() {
        return getPlugins().stream().collect(Collectors.toMap(plugin -> plugin.getKey(), plugin -> plugin));
    }
            ]]>
          </code>
        </codeSegment>
        <codeSegment>
          <version>4.1.0+</version>

    }

    public String getLifecyclePhase() {
        return mojoExecution.getLifecyclePhase();
    }

    public Plugin getPlugin() {
        final MojoDescriptor mojoDescriptor = getMojoExecution().getMojoDescriptor();
        return mojoDescriptor.getPluginDescriptor().getPlugin();
    }

    @Override
    public String toString() {

    }

    def "fails when getting unknown plugin"() {
        when:
        container.getPlugin("unknown")

        then:
        thrown(UnknownPluginException)
    }

    def "fails when getting plugin of unknown type"() {
        when:
        container.getPlugin(plugin1Class)

        then:
        thrown(UnknownPluginException)
    }

			if err != nil {
				t.Fatal(err)
			}

			if tc.wantPlugins != nil {
				gotPlugins := make(map[string]*config.Plugins)
				for n, p := range sched.Profiles {
					gotPlugins[n] = p.ListPlugins()
				}

				if diff := cmp.Diff(tc.wantPlugins, gotPlugins); diff != "" {
					t.Errorf("Unexpected plugins diff (-want, +got): %s", diff)
				}
			}

                                .collect(Collectors.joining(System.lineSeparator() + "\t"))
                        + System.lineSeparator(),
                cause);
        this.plugin = plugin;
    }

    public Plugin getPlugin() {
        return plugin;
    }

				},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			logger, _ := ktesting.NewTestContext(t)
			gotPlugins := mergePlugins(logger, test.defaultPlugins, test.customPlugins)
			if d := cmp.Diff(test.expectedPlugins, gotPlugins); d != "" {
				t.Fatalf("plugins mismatch (-want +got):\n%s", d)
			}
		})
	}

Method <org.gradle.plugin.devel.GradlePluginDevelopmentExtension.getPlugins()> does not have raw return type assignable to org.gradle.api.provider.Provider in (GradlePluginDevelopmentExtension.java:0)

        assert actual == version
    }

    void hasPlugin(String alias, String id, String version) {
        assert model.hasPlugin(alias)
        def plugin = model.getPlugin(alias)
        assert plugin != null : "Expected a plugin with alias '$alias' but it wasn't found"
        assert plugin.id == id
        assert plugin.version.requiredVersion == version
    }

                    .collect(Collectors.joining(", "));
            PluginIncompatibleException pie = new PluginIncompatibleException(
                    pluginDescriptor.getPlugin(),
                    "The plugin " + pluginDescriptor.getId() + " has unmet prerequisites: " + messages,
                    prerequisiteExceptions.get(0));