@Issue("https://issues.gradle.org/browse/GRADLE-3422")
    def "@ComponentBinaries rule is not applied to component reference field of managed binary"() {
        buildFile << """
            @Managed interface SampleLibrary extends GeneralComponentSpec {}
            @Managed interface SampleBinary extends BinarySpec {
                SampleLibrary getParent()
                void setParent(SampleLibrary parent)
            }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.inspect;

import org.gradle.model.Managed;

@Managed
public interface ManagedWithNestedReferenceOfInvalidManagedType {
    ManagedWithReferenceOfInvalidManagedType getManagedWithNestedInvalidManagedType();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.inspect;

import org.gradle.model.Managed;
import org.gradle.model.ModelMap;

@Managed
public interface ManagedWithReferenceOfInvalidManagedType {
    ModelMap<?> getInvalidManaged();
    void setInvalidManaged(ModelMap<?> invalidManaged);

// tag::type-declaration[]
@Managed interface MyComponent extends ComponentSpec {
    String getPublicData()
    void setPublicData(String data)
}
@Managed interface MyComponentInternal extends MyComponent {
    String getInternalData()
    void setInternalData(String internal)
}
// end::type-declaration[]

// tag::type-registration[]
// tag::internal-view-mutation[]
class MyPlugin extends RuleSource {
// end::internal-view-mutation[]

 * limitations under the License.
 */

package org.gradle.model.internal.manage.instance;

import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.type.ModelType;

/**
 * A marker interface that is implemented by views of managed elements.
 */
public interface ManagedInstance {
    /**
     * Returns the node that this managed instance is backed by.
     */
    MutableModelNode getBackingNode();

        modelNode.lss.@type[0] == "CustomSourceSet"
    }

    def "can create a LSS as property of a managed type"() {
        buildFile << """
        ${registerCustomLanguage()}

        @Managed
        interface BuildType {
            //Readonly
            CustomSourceSet getSources()

            //Read/write
            CustomSourceSet getInputs()

 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema.extract;

import org.gradle.model.Managed;
import org.gradle.model.internal.manage.schema.ManagedImplStructSchema;
import org.gradle.model.internal.manage.schema.ModelProperty;
import org.gradle.model.internal.manage.schema.ModelSchema;
import org.gradle.model.internal.method.WeaklyTypeReferencingMethod;

    }

    /**
     * Returns whether the method has been declared in a <code>@</code>{@link Managed} type or not.
     */
    public static boolean isMethodDeclaredInManagedType(Method method) {
        return method.getDeclaringClass().isAnnotationPresent(Managed.class);
    }

        methods.allMethods().values()*.declaredAnnotations.flatten()*.annotationType() == [Nullable, Incubating]
    }

    @Managed
    abstract class ManagedType  {
        abstract String getValue()
        abstract void setValue(String value)
    }

    def "detects managed property"() {
        expect:

)

type fakeManager struct{}

var _ internal.Manager = &fakeManager{}

func (*fakeManager) Update(_, newObj runtime.Object, managed internal.Managed, _ string) (runtime.Object, internal.Managed, error) {
	return newObj, managed, nil
}

func (*fakeManager) Apply(_, _ runtime.Object, _ internal.Managed, _ string, _ bool) (runtime.Object, internal.Managed, error) {
	panic("not implemented")
}