"testing"

	. "github.com/onsi/gomega"
)

var joinCases = []struct {
	merged string
	split  []string
}{
	{
		merged: "",
		split:  nil,
	},
	{
		merged: `yaml: foo`,
		split: []string{
			`yaml: foo`,
		},
	},
	{
		merged: `
yaml: foo
---
bar: boo
`,
		split: []string{
			`
yaml: foo
`,
			`bar: boo
`,
		},
	},
	{
		merged: `
yaml: foo
---

package model

import java.util.LinkedList
import kotlin.math.min

/**
 * Split a list of elements into nearly even sublist. If an element is too large, largeElementSplitFunction will be used to split the large element into several smaller pieces;
 * if some elements are too small, they will be aggregated by smallElementAggregateFunction.
 *
 * @param list the list to split, must be ordered by size desc

func RemoveBrackets(pe string) (string, bool) {
	if !strings.HasPrefix(pe, "[") || !strings.HasSuffix(pe, "]") {
		return "", false
	}
	return pe[1 : len(pe)-1], true
}

// splitEscaped splits a string using the rune r as a separator. It does not split on r if it's prefixed by \.
func splitEscaped(s string, r rune) []string {
	var prev rune
	if len(s) == 0 {
		return []string{}
	}
	prevIdx := 0
	var out []string

	YAMLOrFail(t test.Failer) string

	// MustYAML calls GetYAML and panics if an error occurs.
	MustYAML() string

	// Split this source into individual CRDs.
	Split() ([]Source, error)

	// SplitOrFail calls Split and fails if an error occurs.
	SplitOrFail(t test.Failer) []Source

	// MustSplit calls Split and panics if an error occurs.
	MustSplit() []Source

	// Params returns a copy of the parameters for this Source.

			}
			return nil, fmt.Errorf("preprocessed profile entry missing weight")
		}
		readStr = scanner.Text()

		split := strings.Split(readStr, " ")

		if len(split) != 2 {
			return nil, fmt.Errorf("preprocessed profile entry got %v want 2 fields", split)
		}

		co, err := strconv.Atoi(split[0])
		if err != nil {
			return nil, fmt.Errorf("preprocessed profile error processing call line: %w", err)
		}

	for _, tt := range splittests {
		a := SplitN(tt.s, tt.sep, tt.n)
		if !eq(a, tt.a) {
			t.Errorf("Split(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, a, tt.a)
			continue
		}
		if tt.n == 0 {
			continue
		}
		s := Join(a, tt.sep)
		if s != tt.s {
			t.Errorf("Join(Split(%q, %q, %d), %q) = %q", tt.s, tt.sep, tt.n, tt.sep, s)
		}
		if tt.n < 0 {
			b := Split(tt.s, tt.sep)
			if !reflect.DeepEqual(a, b) {

        assert notation != null;
        String[] split = notation.split(":");

        if (split.length < 2 || split.length > 3) {
            throw new UnsupportedNotationException(notation);
        }
        String group = validate(split[0].trim(), notation);
        String name = validate(split[1].trim(), notation);

        if (split.length == 2) {

        assert notation != null;
        String[] split = notation.split(":");
        if (split.length != 2) {
            throw new UnsupportedNotationException(notation);
        }
        String group = validate(split[0].trim(), notation);
        String name = validate(split[1].trim(), notation);
        result.converted(moduleIdentifierFactory.module(group, name));
    }

			WantException:  true,
		},
		{ // case 1
			Args:           strings.Split("-f missing.yaml", " "),
			ExpectedRegexp: regexp.MustCompile(`open missing.yaml: no such file or directory`),
			WantException:  true,
		},
		{ // case 2
			Args: strings.Split(
				"--meshConfigFile testdata/mesh-config.yaml"+

		}
		return tags
	}
	// fall back to tags if tagsList is not available
	if at, ok := e.computeMetadata["tags"]; ok && len(at.(string)) > 0 {
		for _, tag := range strings.Split(at.(string), ";") {
			kv := strings.SplitN(tag, ":", 2)
			switch len(kv) {
			case 2:
				tags[e.prefixName(kv[0])] = kv[1]
			case 1:
				tags[e.prefixName(kv[0])] = ""
			}
		}
	}
	return tags
}