this(reference.getType().toString(), reference.getDescription(), ImmutableList.of(
                new Provider(String.valueOf(path1), String.valueOf(creator1)),
                new Provider(String.valueOf(path2), String.valueOf(creator2))
        ));
    }

        then:
        assertCreatedBy 'creator1'
        assertStateStored()

        when:
        configurationCacheRun ":jar", "-Dcreator=creator2"

        then:
        assertCreatedBy 'creator2'
        assertStateLoaded()

        when:
        manifestFile.delete()
        configurationCacheRun ":jar", "-Dcreator=creator3"

        then:
        assertCreatedBy 'creator3'

        Optional<ModelRuleDescriptor> creator = creators.get(type);
        if (creator != null) {
            StringBuilder builder = new StringBuilder("Cannot register a factory for type ")
                .append(type.getSimpleName())
                .append(" because a factory for this type was already registered");

            if (creator.isPresent()) {
                builder.append(" by ");

import spock.lang.Specification


class ModelNodeRendererTest extends Specification {

    def "should filter rules removing duplicates and excluding creators"() {
        ModelRuleDescriptor creator = Mock()
        creator.describeTo(_) >> { Appendable a ->
            a.append("creator")
        }

        ModelRuleDescriptor mutator = Mock()
        mutator.describeTo(_) >> { Appendable a ->
            a.append("mutator")

	type User struct {
		ID        int32 `gorm:"primaryKey"`
		Name      string
		CreatorID *int32
		Creator   *User
	}

	checkStructRelation(t, &User{}, Relation{
		Name: "Creator", Type: schema.BelongsTo, Schema: "User", FieldSchema: "User",
		References: []Reference{{"ID", "User", "CreatorID", "User", "", false}},
	})
}

func TestSelfReferentialBelongsToOverrideReferences(t *testing.T) {

    setUp(parameters.first, parameters.second)
    var creator = cache.edit("k1")!!
    creator.setString(0, "ABC")
    creator.setString(1, "DE")
    creator.commit()
    cache.flush()
    filesystem.copy(journalFile, journalBkpFile)
    creator = cache.edit("k2")!!
    creator.setString(0, "F")
    creator.setString(1, "GH")
    creator.commit()
    cache.close()

			creater: &mockCreater{obj: &unstructured.Unstructured{}},

			expectedGVK:    &schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Foo"},
			expectedObject: &unstructured.Unstructured{Object: map[string]interface{}{"apiVersion": "/v1", "kind": "Foo"}},
			strict:         true,
		},

		// creator errors
		{
			data:       []byte("{}"),

                    attributes('Created-By': providers.systemProperty("creator"))
                }
            }
        """

        when:
        withWatchFs().run "jar", "-Dcreator=first"
        then:
        file("build/tmp/jar/MANIFEST.MF").text.contains("first")
        executedAndNotSkipped(":jar")

        when:
        withWatchFs().run "jar", "-Dcreator=second"
        then:

              | Value:  	Some PUBLIC data
              | Creator: 	components { ... } @ build.gradle line 37, column 5 > create(my)
+ tasks
      | Type:   	org.gradle.model.ModelMap<org.gradle.api.Task>
      | Creator: 	Project.<init>.tasks()
    + assemble
          | Type:   	org.gradle.api.DefaultTask
          | Value:  	task ':assemble'
          | Creator: 	Project.<init>.tasks.assemble()
          | Rules:

          | Value:  	null
          | Creator: 	PersonRules#person(Person)
    + lastName
          | Type:   	java.lang.String
          | Value:  	Smith
          | Creator: 	PersonRules#person(Person)
    + maritalStatus
          | Type:   	MaritalStatus
          | Creator: 	PersonRules#person(Person)
    + mother
          | Type:   	Person
          | Value:  	null
          | Creator: 	PersonRules#person(Person)