this.implClass = implClass;
            this.label = baseClass.getSimpleName();
            this.jsonElementAdapter = jsonElementAdapter;
            this.implClassAdapter = implClassAdapter;
            if (!baseClass.isAssignableFrom(implClass)) {
                throw new JsonParseException(implClass + " is not a subclass of " + baseClass);
            }
        }

        @Override
        @SuppressWarnings("unchecked")

        String functionalInterfaceClass,
        String implClass,
        String implMethodName,
        String implMethodSignature,
        int implMethodKind
    ) {
        super(capturingClass);
        this.classLoaderHash = classLoaderHash;
        this.functionalInterfaceClass = functionalInterfaceClass;
        this.implClass = implClass;
        this.implMethodName = implMethodName;

        generateConstructors(visitor, implClass, superclassType);
        visitor.visitEnd();

        return classGenerator.define();
    }

    private <T> void generateConstructors(ClassWriter visitor, Class<? extends T> implClass, Type superclassType) {
        for (Constructor<?> constructor : implClass.getConstructors()) {

        def serviceFile = stream('org.gradle.ImplClass')

        when:
        def result = serviceLocator.findFactory(String.class).create()

        then:
        result instanceof String
        1 * classLoader.getResources("META-INF/services/java.lang.String") >> Collections.enumeration([serviceFile])
        1 * classLoader.loadClass('org.gradle.ImplClass') >> String
    }

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.fixtures


fun pluginDescriptorEntryFor(id: String, implClass: String) =

                }

                final Class<?> implClass;
                try {
                    implClass = classLoader.loadClass(implClassName);
                } catch (ClassNotFoundException e) {
                    throw new InvalidPluginException(String.format(

    private
    fun jarWithInvalidPlugin(id: String, implClass: String): File =
        pluginJarWith(
            pluginDescriptorEntryFor(id, implClass),
            "$implClass.class" to publicClass(InternalName(implClass))
        )

    private
    fun jarForPlugin(id: String, implClass: String): File =
        pluginJarWith(
            pluginDescriptorEntryFor(id, implClass),

            try {
                validateType(type);
                ClassGenerator.GeneratedClass<?> implClass = classGenerator.generate(type);
                ClassGenerator.GeneratedConstructor<?> generatedConstructor = InjectUtil.selectConstructor(implClass, type);
                return CachedConstructor.of(generatedConstructor);
            } catch (RuntimeException e) {

                HashCode classLoaderHash = hashCodeSerializer.read(decoder);
                String functionalInterfaceClass = decoder.readString();
                String implClass = decoder.readString();
                String implMethodName = decoder.readString();
                String implMethodSignature = decoder.readString();
                int implMethodKind = decoder.readSmallInt();

        file.also {
            zipTo(
                it,
                pluginIdsToImplClasses.asSequence().map { (id, implClass) ->
                    pluginDescriptorEntryFor(id, implClass)
                }
            )
        }