{Name: "Name3", DBName: "name3", BindNames: []string{"Name3"}, DataType: schema.String, Tag: `gorm:"<-"`, Creatable: true, Updatable: true, Readable: true},
		{Name: "Name4", DBName: "name4", BindNames: []string{"Name4"}, DataType: schema.String, Tag: `gorm:"<-:create"`, Creatable: true, Updatable: false, Readable: true},

	}

	f.Fuzz(func(t *testing.T, s string) {
		// equalTime is like time.Time.Equal, but also compares the time zone.
		equalTime := func(t1, t2 Time) bool {
			name1, offset1 := t1.Zone()
			name2, offset2 := t2.Zone()
			return t1.Equal(t2) && name1 == name2 && offset1 == offset2
		}

		for _, tz := range []*Location{UTC, Local} {
			// Parsing as RFC3339 or RFC3339Nano should be identical.

    def "recompiles classes with \$ in class name after rename"() {
        def firstSource = source "class Class\$Name {}"
        source "class Main { public static void main(String[] args) { new Class\$Name(); } }"
        outputs.snapshot { run language.compileTaskName }

        when:
        firstSource.delete()
        source "class Class\$Name1 {}",

}

// Name returns the name from the request, and an optional namespace value if this is a namespace
// scoped call. An error is returned if the name is not available.
func (p *testNamer) Name(req *http.Request) (namespace, name string, err error) {
	return p.namespace, p.name, nil
}

// ObjectName returns the namespace and name from an object if they exist, or an error if the object
// does not support names.

            #if 0
            #define HEADER HEADER1_
            #define NAME NAME1
            #else
            #define HEADER HEADER2_
            #define NAME NAME2
            #endif
            #define HEADER2(X, Y) X ## Y
            #define HEADER(X, Y) HEADER2(X, Y)
            #define PREFIX HEADER
            #define SUFFIX NAME
            #include HEADER(PREFIX, SUFFIX)
        """

        expect:

        publication.artifactId = "name2"
        publication.version = "version2"

        then:
        publication.pom.coordinates.groupId.get() == "group2"
        publication.pom.coordinates.artifactId.get() == "name2"
        publication.pom.coordinates.version.get() == "version2"

        and:
        publication.groupId == "group2"
        publication.artifactId == "name2"
        publication.version == "version2"

			return err
		}
		for _, gw := range waypoints.Items {
			names = append(names, gw.Name)
		}
	}

	var wg sync.WaitGroup
	var mu sync.Mutex
	for _, name := range names {
		wg.Add(1)
		go func(name string) {
			defer wg.Done()
			if err := kubeClient.GatewayAPI().GatewayV1().Gateways(namespace).
				Delete(context.Background(), name, metav1.DeleteOptions{}); err != nil {
				if errors.IsNotFound(err) {

				Namespace: echo1NS,
			},
			{
				Name:      "c",
				Namespace: echo1NS,
			},
			{
				Name:      "external",
				Namespace: echo1NS,
			},
			{
				Name:      "headless",
				Namespace: echo1NS,
			},
			{
				Name:      "naked",
				Namespace: echo1NS,
			},
			{
				Name:      "vm",
				Namespace: echo1NS,
			},
		},
	); diff != "" {

	SYS_KQUEUE1              = 455 // { int|sys||kqueue1(int flags); }
	SYS_PACCEPT              = 456 // { int|sys||paccept(int s, struct sockaddr *name, socklen_t *anamelen, const sigset_t *mask, int flags); }
	SYS_LINKAT               = 457 // { int|sys||linkat(int fd1, const char *name1, int fd2, const char *name2, int flags); }
	SYS_RENAMEAT             = 458 // { int|sys||renameat(int fromfd, const char *from, int tofd, const char *to); }

	SYS_KQUEUE1              = 455 // { int|sys||kqueue1(int flags); }
	SYS_PACCEPT              = 456 // { int|sys||paccept(int s, struct sockaddr *name, socklen_t *anamelen, const sigset_t *mask, int flags); }
	SYS_LINKAT               = 457 // { int|sys||linkat(int fd1, const char *name1, int fd2, const char *name2, int flags); }
	SYS_RENAMEAT             = 458 // { int|sys||renameat(int fromfd, const char *from, int tofd, const char *to); }