switch (value.getMaximumNumberOfParameters()) {
                    case 0:
                        return value.call();
                    case 1:
                        return value.call(convention);
                    default:
                        return value.call(convention, conventionAwareObject);
                }
            }
        });
    }

    @Override

import kotlin.test.Test
import kotlin.test.assertEquals


object OriginReplacementTest {
    @Test
    fun `replaces configured object access and function call receiver`() {
        with(resolution("configuring { property = value() }")) {
            val assignment = assignments.single()
            val lhs = replaceInnerReceiverWithTopLevel(assignment.lhs.receiverObject)

            override fun invoke(receiver: Any): DependencyCollector = getterFunction.call(receiver) as DependencyCollector
        }

        data class Property(val property: KProperty<*>) : DependencyCollectorAccessor {
            override fun invoke(receiver: Any): DependencyCollector = property.call(receiver) as DependencyCollector
        }
    }

    private

     *
     * <p>This method is re-entrant, so that an action can call back into this method.</p>
     *
     * <p>Note: this method differs from {@link #withFileLock(Supplier)} in that this method also blocks other threads from this process and all threads from other processes from accessing the cache.</p>

     */
    void loadGradlePropertiesFrom(File settingsDir, boolean setSystemProperties);

    /**
     * Unloads the properties so the next call to {@link #loadGradlePropertiesFrom(File, boolean)} would reload them and
     * re-evaluate any property defining system properties and environment variables.
     */
    void unloadGradleProperties();

            default:
                throw new UnsupportedOperationException("Generating get call for type: " + upgradedPropertyType.asType() + " is not supported");
        }
    }

        1 * target.getExtensions() >> extensions
        1 * softwareType.modelPublicType() >> Foo.class
        1 * softwareType.name() >> "foo"
        1 * propertyValue.call() >> foo
        1 * extensions.add(Foo.class, "foo", foo)

        and:
        1 * delegate.applyImperative(null, plugin)
    }

    def "does not add software types for plugins that are not registered"() {

        def failure1 = new RuntimeException()
        def action1 = new Callable<Void>() {
            Void call() {
                instant.broken1
                throw failure1
            }
        }
        def failure2 = new RuntimeException()
        def action2 = new Callable<Void>() {
            Void call() {
                instant.broken2
                throw failure2
            }
        }

    byte[] instrumentClass(@Nullable String className, @Nullable ProtectionDomain protectionDomain, byte[] classfileBuffer);

    /**
     * This is called by the agent if a throwable is thrown while instrumenting a class during the call of the {@link #instrumentClass(String, ProtectionDomain, byte[])} method,
     * or anywhere else in the agent. Throwing an exception from this method has no effect on the class loading.
     * <p>

        def result2 = recreate(original2).call()

        result2 == "123"
    }

    def "class can include only serializable lambda"() {
        given:
        def cl = transformAndLoad(ClassWithSerializableLambda, ClassWithSerializableLambda.SerializableThing)

        expect:
        def original = cl.thing(123)
        def result = recreate(original).call()

        result == "123"
    }