t.Run(c.name, func(t *testing.T) {
			parts := yml.SplitString(c.doc)
			g := NewWithT(t)
			g.Expect(parts).To(Equal(expected))
		})
	}
}

func TestSplitWithNestedDocument(t *testing.T) {
	doc := `
b
    b1
    ---
    b2
`
	expected := []string{
		`b
    b1
    ---
    b2`,
	}

	g := NewWithT(t)
	parts := yml.SplitString(doc)
	g.Expect(parts).To(Equal(expected))
}

	"istio.io/istio/pkg/test/util/tmpl"
)

// ApplyNamespace applies the given namespaces to the resources in the yamlText if not set.
func ApplyNamespace(yamlText, ns string) (string, error) {
	chunks := SplitString(yamlText)

	toJoin := make([]string, 0, len(chunks))
	for _, chunk := range chunks {
		chunk, err := applyNamespace(chunk, ns)
		if err != nil {
			return "", err
		}
		toJoin = append(toJoin, chunk)
	}

			err = multierror.Append(err, e)
		}
		return
	})
}

// When we cleanup, we should not delete CRDs. This will filter out all the crds
func removeCRDs(istioYaml string) string {
	allParts := yml.SplitString(istioYaml)
	nonCrds := make([]string, 0, len(allParts))

	// Make the regular expression multi-line and anchor to the beginning of the line.
	r := regexp.MustCompile(`(?m)^kind: CustomResourceDefinition$`)

	newPolicy := s.PullPolicy
	yamlText = strings.ReplaceAll(yamlText, oldPolicy, newPolicy)

	return yamlText, nil
}

func addPullSecret(resource string, pullSecret string) (string, error) {
	res := yml.SplitString(resource)
	updatedYaml, err := yml.ApplyPullSecret(res[1], pullSecret)
	if err != nil {
		return "", err
	}
	mergedYaml := yml.JoinString(res[0], updatedYaml)
	return mergedYaml, nil
}

			} {
				recognized.Delete(gvk)
			}

			tested := sets.New[string]()
			for _, te := range loadTestData(t) {
				yamlBatch, err := te.load()
				yamlParts := yml.SplitString(yamlBatch)
				for _, yamlPart := range yamlParts {
					if err != nil {
						t.Fatalf("error loading test data: %v", err)
					}

					m := make(map[string]any)

	c.yamlText[ns] = append(c.yamlText[ns], splitYAML(yamlText...)...)
	return c
}

func splitYAML(yamlText ...string) []string {
	var out []string
	for _, doc := range yamlText {
		out = append(out, yml.SplitString(doc)...)
	}
	return out
}

func (c *configPlan) File(ns string, paths ...string) config.Plan {
	yamlText, err := file.AsStringArray(paths...)
	if err != nil {
		panic(err)
	}

			return true
		}
	}
	return false
}

func (v *Validator) ValidateCustomResourceYAML(data string, ignorer *ValidationIgnorer) error {
	var errs *multierror.Error
	for _, item := range yml.SplitString(data) {
		obj := &unstructured.Unstructured{}
		if err := yaml.Unmarshal([]byte(item), obj); err != nil {
			return err
		}
		if ignorer != nil && ignorer.ShouldIgnore(obj.GetNamespace(), obj.GetName()) {

		})
	}
	return g.Wait()
}

func (c *client) ApplyYAMLContents(namespace string, yamls ...string) error {
	g, _ := errgroup.WithContext(context.TODO())
	for _, yaml := range yamls {
		cfgs := yml.SplitString(yaml)
		for _, cfg := range cfgs {
			cfg := cfg
			g.Go(func() error {
				return c.ssapplyYAML(cfg, namespace, false)
			})
		}
	}
	return g.Wait()
}

		ProxyConfig: proxyConfig,
		MeshConfig:  cfg.MeshConfig,
		Values:      cfg.Values.Map(),
	}
	results, err := tmpl.Execute(template, input)
	if err != nil {
		return nil, err
	}

	return yml.SplitString(results), nil
}

func (d *DeploymentController) setGatewayControllerVersion(gws gateway.Gateway) error {

	a, ok := f.CanonicalLocalSlots[slot]
	if !ok {
		a = new(LocalSlot)
		*a = slot // don't escape slot
		f.CanonicalLocalSlots[slot] = a
	}
	return a
}

func (f *Func) SplitString(name *LocalSlot) (*LocalSlot, *LocalSlot) {
	ptrType := types.NewPtr(types.Types[types.TUINT8])
	lenType := types.Types[types.TINT]
	// Split this string up into two separate variables.