*/
package org.gradle.internal.metaobject;

import groovy.lang.GroovyRuntimeException;
import groovy.lang.MissingMethodException;
import groovy.lang.MissingPropertyException;
import org.codehaus.groovy.runtime.metaclass.MissingMethodExecutionFailed;

import javax.annotation.Nullable;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;

/**
 * An empty {@link DynamicObject}.
 */

    }
}

class UsesInheritedPropertiesDuringConstruction extends TestJavaObject {
    UsesInheritedPropertiesDuringConstruction() {
        assert metaClass != null
        assert getMetaClass() != null
        assert metaClass.getProperty(this, "someValue") == "value"
        assert asDynamicObject.getProperty("someValue") == "value"
        assert getProperty("someValue") == "value"

        for (Field field : type.getDeclaredFields()) {
            if (Modifier.isStatic(field.getModifiers()) || (GroovyObject.class.isAssignableFrom(type) && field.getName().equals("metaClass"))) {
                continue;
            }
            collector.add(field, "A Named implementation class must not define any instance fields.");
        }
    }

        and:
        propertyNames(new WithProperties()) == ['class', 'metaClass', 'prop1', 'prop2', 'something', 'somethingElse', 'writeOnly'] as Set
    }

    def "read property"() {
        expect:
        readableProperty(JavaTestSubject, String, "myProperty").getValue(myProperties) == "myValue"

        }
        // Ignore irrelevant synthetic metaClass field injected by the Groovy compiler
        if (instanceFields.size() == 1 && isSyntheticMetaClassField(instanceFields.get(0))) {
            return false;
        }
        return true;
    }

    private boolean isSyntheticMetaClassField(Field field) {
        return field.isSynthetic() && field.getType() == MetaClass.class;
    }

[CAUTION]
--
Avoid using https://groovy-lang.org/metaprogramming.html#_metaclasses[Groovy MetaClass] programming techniques in your build scripts. Gradle provides its own API for adding <<writing_build_scripts#sec:extra_properties,dynamic runtime properties>>.

                    }
                }
                edge("org:databind:{strictly 2.6.7.1}", "org:databind:2.6.7.1")
            }
        }

    }

    def setup() {
        repoSpec.metaClass.platform = this.&platform.curry(repoSpec)
    }

    /**
     * Generates a BOM, or Gradle metadata
     * @param repo
     * @param platformGroup
     * @param platformName
     * @param platformVersion

    }

    @Test
    public void respectsPropertiesAddedToMetaClassOfJavaObject() throws Exception {
        Bean bean = newInstance(Bean.class);

        call("{ it.metaClass.getConventionProperty = { -> 'value'} }", bean);
        assertThat(call("{ it.hasProperty('conventionProperty') }", bean), notNullValue());
        assertThat(call("{ it.getConventionProperty() }", bean), equalTo((Object) "value"));

}

abstract class ForcingPlatformAlignmentTest extends AbstractAlignmentSpec {

    def setup() {
        Assume.assumeTrue(GradleContextualExecuter.embedded)
        repoSpec.metaClass.platform = this.&platform.curry(repoSpec)
    }

    def "can force a virtual platform version by forcing one of its leaves through resolutionStrategy.force"() {
        repository {

            if (!viewMethods.contains(methodKey)) {
                continue;
            }

            if (methodBinding instanceof DirectMethodBinding) {
                // TODO:LPTR What is with the "metaClass" property here?
                boolean isGetterMethod = methodBinding.getAccessorType() == GET_GETTER
                    || methodBinding.getAccessorType() == IS_GETTER;
                if (isGetterMethod