Result: "create table `users` (`id` int, `name` text)",
	}}

	for idx, result := range results {
		t.Run(fmt.Sprintf("case #%v", idx), func(t *testing.T) {
			user, _ := schema.Parse(&tests.User{}, &sync.Map{}, db.NamingStrategy)
			stmt := &gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}

		},
		Webhooks: []admitv1.MutatingWebhook{
			{
				Name: fmt.Sprintf("namespace.%s", istioInjectionWebhookSuffix),
				ClientConfig: admitv1.WebhookClientConfig{
					Service: &admitv1.ServiceReference{
						Namespace: "default",
						Name:      "istiod",
					},
					CABundle: []byte("ca"),
				},
			},
			{
				Name: fmt.Sprintf("object.%s", istioInjectionWebhookSuffix),

	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()
	if err != nil {
		log.Printf("Error reading request body: %v", err)
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	log.Printf(">>> %s %s\n", r.Method, r.URL.Path)
	var out bytes.Buffer
	json.Indent(&out, body, "", "    ")
	log.Printf("%s\n", out.String())

	w.WriteHeader(http.StatusOK)
}

func main() {
	flag.Parse()

				continue
			}
			healthyEndpoints++
		}
		endpoints := fmt.Sprintf("%d/%d", healthyEndpoints, allEndpoints)

		waypoint := serviceWaypointName(svc, zDump.Services)
		fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n",
			svc.Namespace, svc.Name, strings.Join(ips, ","), waypoint, endpoints)
	}
	return w.Flush()
}

// PrintServiceDump prints the relevant services in the config dump to the ConfigWriter stdout

	etcdStr := ""
	if withEtcdBackend {
		etcdStr = " (with etcd backend)"
	}
	return &TestSuiteIAM{
		TestSuiteCommon:       c,
		ServerTypeDescription: fmt.Sprintf("%s%s", c.serverType, etcdStr),
		withEtcdBackend:       withEtcdBackend,
	}
}

func (s *TestSuiteIAM) iamSetup(c *check) {
	var err error
	// strip url scheme from endpoint

func (e DecoderError) ReaderErr() error { return e.readerErr }

// Error returns a string representation of the error.
func (e DecoderError) Error() string {
	loc := fmt.Sprintf("%s [%d,%d]", quoteChar(e.atChar), e.pos[0], e.pos[1])
	s := fmt.Sprintf("%s %s: %s", e.msg, e.context, loc)
	if e.readerErr != nil {
		s += "\nreader error: " + e.readerErr.Error()
	}
	return s
}

// quoteChar formats c as a quoted character literal

		case errorMessage:
			logf = func(format string, args ...any) {
				fmt.Fprintf(os.Stderr, format+"\n", args...)
			}
		case fatalMessage:
			logf = func(format string, args ...any) {
				fmt.Fprintf(os.Stderr, format+"\n", args...)
			}
			defer os.Exit(1)
		default:
			logf = func(format string, args ...any) {
				fmt.Fprintf(os.Stdout, format+"\n", args...)
			}
		}
	}

			}

			corrupted := false
			if !multipart {
				md5sum := fmt.Sprintf("%x", partsMD5Sum[0])
				if md5sum != object.ETag {
					corrupted = true
				}
			} else {
				var totalMD5SumBytes []byte
				for _, sum := range partsMD5Sum {
					totalMD5SumBytes = append(totalMD5SumBytes, sum...)
				}
				s3MD5 := fmt.Sprintf("%x-%d", getMD5Sum(totalMD5SumBytes), parts)
				if s3MD5 != object.ETag {

		for _, llb := range eds.Endpoints {
			for _, ep := range llb.LbEndpoints {
				addr := strings.Join(retrieveEndpointAddresses(ep), ",")
				if includeConfigType {
					addr = fmt.Sprintf("endpoint/%s", addr)
				}
				fmt.Fprintf(w, "%v\t%v\t%v\t%v\n",
					addr,
					ep.GetHealthStatus().String(),
					util.LocalityToString(llb.Locality),
					eds.ClusterName,
				)
			}
		}
	}

}

// List - Retrieves list of DNS entries for the domain.
func (c *CoreDNS) List() (map[string][]SrvRecord, error) {
	srvRecords := map[string][]SrvRecord{}
	for _, domainName := range c.domainNames {
		key := msgPath(fmt.Sprintf("%s.", domainName), c.prefixPath)
		records, err := c.list(key+etcdPathSeparator, true)
		if err != nil {
			return srvRecords, err
		}
		for _, record := range records {
			if record.Key == "" {
				continue
			}