void addTasks(ModelMap<Task> tasks) {
                    tasks.create("requested") {
                        dependsOn "dependency"
                        finalizedBy "finalizer"
                    }
                }
            }

            apply type: Rules

            tasks.create("dependency", EchoTask)
            tasks.create("finalizer", EchoTask)
        """

        when:

     */
    ExternalModuleDependency create(CharSequence dependencyNotation);

    /**
     * Create an {@link ExternalModuleDependency} from a series of strings.
     *
     * @param group the group (optional)
     * @param name the name
     * @param version the version (optional)
     * @return the new dependency
     */
    ExternalModuleDependency create(@Nullable String group, String name, @Nullable String version);

        expect:
        generator.generate(Bean).generatedClass == Bean
    }

    def "can create instance of final class when a subclass is not required"() {
        expect:
        create(FinalBean) != null
    }

    def "can create instance of private class when a subclass is not required"() {
        expect:
        create(PrivateBean) != null
    }

	}

	t.Run("Polymorphic", func(t *testing.T) {
		pet := Pet{Name: "create"}

		if err := DB.Create(&pet).Error; err != nil {
			t.Fatalf("errors happened when create: %v", err)
		}

		pet.Toy = Toy{Name: "Update-HasOneAssociation-Polymorphic"}

		if err := DB.Save(&pet).Error; err != nil {
			t.Fatalf("errors happened when create: %v", err)
		}

		var pet2 Pet
		DB.Preload("Toy").Find(&pet2, "id = ?", pet.ID)

      "namespaced": true,
      "singularName": "localsubjectaccessreview",
      "verbs": [
        "create"
      ]
    },
    {
      "kind": "SelfSubjectAccessReview",
      "name": "selfsubjectaccessreviews",
      "namespaced": false,
      "singularName": "selfsubjectaccessreview",
      "verbs": [
        "create"
      ]
    },
    {
      "kind": "SelfSubjectRulesReview",

     */
    DependencyConstraint create(CharSequence dependencyConstraintNotation);

    /**
     * Create a {@link DependencyConstraint} from a series of strings.
     *
     * @param group the group (optional)
     * @param name the name
     * @param version the version (optional)
     * @return the new dependency constraint
     * @since 8.7
     */

  "resources": [
    {
      "kind": "CSIDriver",
      "name": "csidrivers",
      "namespaced": false,
      "singularName": "csidriver",
      "storageVersionHash": "hL6j/rwBV5w=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",
        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "CSINode",

	for x := 0; x < b.N; x++ {
		user.ID = 0
		DB.Create(&user)
	}
}

func BenchmarkFind(b *testing.B) {
	user := *GetUser("find", Config{})
	DB.Create(&user)

	for x := 0; x < b.N; x++ {
		DB.Find(&User{}, "id = ?", user.ID)
	}
}

func BenchmarkScan(b *testing.B) {
	user := *GetUser("scan", Config{})
	DB.Create(&user)

	var u User
	b.ResetTimer()
	for x := 0; x < b.N; x++ {

class PersonRules extends RuleSource {
// tag::create-rule[]
  @Model void person(Person p) {}
// end::create-rule[]

// tag::plugin-mutate-rule[]
  //Create a rule that modifies a Person and takes no other inputs
  @Mutate void setFirstName(Person p) {
    p.firstName = "John"
  }
// end::plugin-mutate-rule[]

// tag::task-create-rule[]
  //Create a rule that modifies a ModelMap<Task> and takes as input a Person

import org.junit.Test


class PluginDependenciesSpecScopeTest {

    @Test
    fun `given a single id, it should create a single request with no version`() {
        expecting(plugin(id = "plugin-id")) {
            id("plugin-id")
        }
    }

    @Test
    fun `given a single id and apply value, it should create a single request with no version`() {
        listOf(true, false).forEach { applyValue ->