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

package org.gradle.model;

import org.gradle.api.Named;

@Managed
public interface NamedThingInterface extends Named {
    String getOther();

    void setOther(String string);

        when:
        registry.registerWithInitializer("foo", NamedThingInterface, nodeInitializerRegistry)

        then:
        registry.realize("foo", NamedThingInterface).name == "foo"

        when:
        registry.registerWithInitializer("bar", NamedThingInterface, nodeInitializerRegistry)

        then:
        registry.realize("bar", NamedThingInterface).name == "bar"
    }


    @Managed

import static org.gradle.model.internal.core.NodeInitializerContext.forType

class ManagedNodeBackedModelMapTest extends NodeBackedModelMapSpec<NamedThingInterface, SpecialNamedThingInterface> {

    Class<NamedThingInterface> itemClass = NamedThingInterface
    Class<SpecialNamedThingInterface> specialItemClass = SpecialNamedThingInterface.class

    def setup() {

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

package org.gradle.model;

@Managed
public interface SpecialNamedThingInterface extends NamedThingInterface, Special {
    String getSpecial();

    void setSpecial(String string);

- type parameter of $ModelMap.name cannot be a wildcard.""")
    }

    def "can have map of map"() {
        def type = ModelTypes.modelMap(ModelTypes.modelMap(NamedThingInterface))

        expect:
        schemaStore.getSchema(type) instanceof ModelMapSchema
    }

    static abstract class WritableMapProperty {
        abstract void setMap(ModelMap<NamedThingInterface> map)
        abstract ModelMap<NamedThingInterface> getMap()
    }

    @Managed
    static abstract class WritableSetProperty {
        abstract void setSet(ModelSet<NamedThingInterface> set)
        abstract ModelSet<NamedThingInterface> getSet()
    }

    def "map cannot be writable"() {