* The {@link org.gradle.internal.extensibility.ExtensibleDynamicObject} implementation on the other hand does provide extra functionality.
 */
public interface DynamicObject extends MethodAccess, PropertyAccess {
    /**
     * Creates a {@link MissingPropertyException} for getting an unknown property of this object.
     */
    MissingPropertyException getMissingProperty(String name);

            return "<obj>"
        }
    }

    def "get property returns result from first delegate that has the property"() {
        def obj1 = Mock(DynamicObject)
        def obj2 = Mock(DynamicObject)
        def obj3 = Mock(DynamicObject)
        obj.setObjects(obj1, obj2, obj3)

        when:
        def result = obj.getProperty("p")

        then:
        result == 12

        and:

    void setProperty(DynamicObject receiver, String name, @Nullable Object value);
    boolean hasProperty(DynamicObject receiver, String propertyName);
    @Nullable Map<String, ?> getProperties(DynamicObject receiver);
    @Nullable Object invokeMethod(DynamicObject receiver, String name, Object... args);

    DynamicInvokeResult tryGetProperty(DynamicObject receiver, String name);

            inOrder(target, dynamicObject) {
                verify(target as DynamicObjectAware).asDynamicObject
                verify(dynamicObject).tryGetProperty(propertyName)
                verifyNoMoreInteractions()
            }

        class SettingsMock(val settings: Settings, dynamicObject: DynamicObject) : DynamicDelegatedPropertiesMock<Settings>(settings, dynamicObject)

        for (DirectoryTree fileTree : existing) {
            dynamicObject.invokeMethod(childNodeName, Collections.singletonMap("location", fileTree.getDir()));
        }

        dynamicObject.invokeMethod("or", new Closure<Void>(this) {
            public Object doCall(Object ignore) {
                for (final DirectoryTree fileTree : existing) {
                    dynamicObject.invokeMethod("and", new Closure<Void>(this) {

            }
            BeanDynamicObject dynamicObject = dynamicObjects.get(object);
            if (dynamicObject == null) {
                dynamicObject = new BeanDynamicObject(object);
                dynamicObjects.put(object, dynamicObject);
            }
            return dynamicObject;
        }
    }

    private void checkExtensionIsNotReassigned(String name) {

import java.util.Map;

/**
 * Presents a {@link DynamicObject} view of multiple objects at once.
 *
 * Can be used to provide a dynamic view of an object with enhancements.
 */
public abstract class CompositeDynamicObject extends AbstractDynamicObject {

    private static final DynamicObject[] NONE = new DynamicObject[0];

    private DynamicObject[] objects = NONE;
    private DynamicObject[] updateObjects = NONE;

                return DynamicInvokeResult.found();
            }
            DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(property);
            if (dynamicObject.hasMethod("call", arguments)) {
                return dynamicObject.tryInvokeMethod("call", arguments);
            }
        }
        return DynamicInvokeResult.notFound();
    }

        return instantiatorFactory.decorateLenient(services);
    }

    private static AbstractDynamicObject wrap(Object delegateObject, Class<?> publicType, DynamicObject dynamicObject) {
        if (dynamicObject != null) {
            return (AbstractDynamicObject) dynamicObject;
        }
        return new BeanDynamicObject(delegateObject, publicType);
    }

import org.gradle.internal.metaobject.DynamicInvokeResult
import org.gradle.internal.metaobject.DynamicObject


class TrackingDynamicLookupRoutine(
    private val dynamicCallContextTracker: DynamicCallContextTracker
) : DynamicLookupRoutine {

    @Throws(MissingPropertyException::class)
    override fun property(receiver: DynamicObject, propertyName: String): Any? =
        withDynamicCall(receiver) {