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

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

import org.gradle.model.ModelMap
import org.gradle.model.internal.manage.schema.SpecializedMapSchema
import org.gradle.model.internal.type.ModelType
import spock.lang.Specification

class SpecializedModelMapStrategyTest extends Specification {

    Scope::Impl::NameMap* name_map = new Scope::Impl::NameMap;
    for (const Node* node : graph->nodes()) {
      const string& name = node->name();
      (*name_map)[name] = 0;
      // Add all name prefixes ('/' separated).
      size_t idx = -1;
      while ((idx = name.find(kScopeSeparator, idx + 1)) != string::npos) {
        (*name_map)[name.substr(0, idx)] = 0;
      }
    }

        def backingCollection = Mock(DomainObjectCollection)
        def instantiator = Mock(NamedEntityInstantiator)
        def modelMap = DomainObjectCollectionBackedModelMap.wrap("thing", SomeType, backingCollection, instantiator, Named.Namer.INSTANCE, Actions.doNothing())

        when:
        modelMap.create("alma")

        then:
        1 * instantiator.create("alma", SomeType) >>  { new SomeType(name: "alma") }

        return components;
    }

    public static Set<ComponentSpec> getAllTestSuites(ModelRegistry registry) {
        Set<ComponentSpec> components = new LinkedHashSet<>();
        ModelMap<ComponentSpec> testSuites = modelElement(registry, "testSuites", modelMap(ComponentSpec.class));
        if (testSuites != null) {
            components.addAll(testSuites.values());
        }
        return components;
    }

    @Nullable

        given:
        buildFile << """
class Rules extends RuleSource {
    @Model
    void strings(${type.name}<String> s) {
    }

    @Mutate
    void tasks(ModelMap<Task> tasks, @Path("strings") def strings) {
        tasks.create("show") {
            doLast {
                println "strings: \$strings"
            }
        }
    }
}

apply plugin: Rules
"""

package sample.documentation

import org.gradle.api.Task
import org.gradle.api.tasks.Copy
import org.gradle.model.ModelMap
import org.gradle.model.Path
import org.gradle.model.RuleSource
import org.gradle.platform.base.*

// tag::component-registration[]
// tag::binary-registration[]
// tag::binaries-generation[]
// tag::text-tasks-generation[]
class DocumentationPlugin extends RuleSource {
// end::binary-registration[]

                ModelMap<NativeBinarySpecInternal> projectBinaries = modelRegistry.realize("binaries", ModelTypes.modelMap(NativeBinarySpecInternal.class));
                ModelMap<Task> projectTasks = modelRegistry.realize("tasks", ModelTypes.modelMap(Task.class));

                    @Model
                    List<String> strings() {
                      []
                    }

                    @Mutate
                    void addTasks(ModelMap<Task> tasks, List<String> strings) {
                        tasks.create("value") {
                            it.doLast {
                                println "value: $strings"
                            }

                void tryToMutateInputModelSet(ModelMap<Task> tasks, ModelSet<Person> people) {
                    people.create {}
                }
            }

            apply type: RulePlugin
        '''

        then:
        fails "tasks"

        and:
        failure.assertHasCause("Exception thrown while executing model rule: RulePlugin#tryToMutateInputModelSet(ModelMap<Task>, ModelSet<Person>)")

 */

package org.gradle.nativeplatform.test.cunit.plugins;

import org.gradle.api.Incubating;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.model.Defaults;
import org.gradle.model.ModelMap;
import org.gradle.model.RuleSource;
import org.gradle.nativeplatform.NativeComponentSpec;
import org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec;
import org.gradle.nativeplatform.test.internal.NativeTestSuites;