},
		// Test case 5 object has many trailing separators.
		{
			path:   "/bucket/object/1///",
			bucket: "bucket",
			object: "object/1///",
		},
		// Test case 6 object has only trailing separators.
		{
			path:   "/bucket/object///////",
			bucket: "bucket",
			object: "object///////",
		},
		// Test case 7 object has preceding separators.
		{
			path:   "/bucket////object////",

  // it is called in CreateDirectoriesRecursively() assuming that it will change
  // a pathname from directory syntax (trailing separator) to filename syntax.
  //
  // On Windows this method also replaces the alternate path separator '/' with
  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
  // "bar\\foo".

  void Normalize();

  // it is called in CreateDirectoriesRecursively() assuming that it will change
  // a pathname from directory syntax (trailing separator) to filename syntax.
  //
  // On Windows this method also replaces the alternate path separator '/' with
  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
  // "bar\\foo".

  void Normalize();

        verify(ex.message, undefinedAliasRef {
            inCatalog('libs')
            aliasRef('foo')
            bundle('toto')
        })
    }

    def "normalizes alias separators to dot"() {
        builder.library("guava", "com.google.guava:guava:17.0")
        builder.library("groovy", "org.codehaus.groovy", "groovy").version {
            it.strictly("3.0.5")
        }

import java.util.StringTokenizer;

public class FilePathUtil {
    private static final String[] EMPTY_STRING_ARRAY = {};
    // On Windows, / and \ are separators, on Unix only / is a separator.
    private static final String FILE_PATH_SEPARATORS = File.separatorChar != '/' ? ("/" + File.separator) : File.separator;

    private FilePathUtil() {
    }

    public static String[] getPathSegments(String path) {

        "hey joe" | "hey joe"
    }

    def "versions that differ only in separators are equal"() {
        expect:
        compare("1.0", "1_0") == 0
        compare("1_0", "1-0") == 0
        compare("1-0", "1+0") == 0
        compare("1.a.2", "1a2") == 0 // number-word and word-number boundaries are considered separators
    }

    def "leading zeros in numeric parts are ignored"() {
        expect:

        result = ID_PATTERN.matcher(result).replaceAll("");

        // normalize separators
        result = SEPARATOR_PATTERN.matcher(result).replaceAll(PART_SEPARATOR);

        // strip separator from the end
        if (result.endsWith(PART_SEPARATOR)) {
            result = result.substring(0, result.length() - 1);
        }

        // string separator from the start
        if (result.startsWith(PART_SEPARATOR)) {

	base2ok bool   // true if 'p'/'P' exponents are accepted
	sepOk   bool   // true if '_' separators are accepted
	x       int64  // expected exponent
	b       int    // expected exponent base
	err     error  // expected error
	next    rune   // next character (or 0, if at EOF)
}{
	// valid, without separators
	{"", false, false, 0, 10, nil, 0},
	{"1", false, false, 0, 10, nil, '1'},
	{"e0", false, false, 0, 10, nil, 0},

		}
	}
}

func TestCVE202230630(t *testing.T) {
	// Prior to CVE-2022-30630, a stack exhaustion would occur given a large
	// number of separators. There is now a limit of 10,000.
	_, err := Glob(os.DirFS("."), "/*"+strings.Repeat("/", 10001))
	if err != path.ErrBadPattern {
		t.Fatalf("Glob returned err=%v, want %v", err, path.ErrBadPattern)
	}
}

        fun hashOfNormalisedString(charSequence: CharSequence) =
            Hashing.hashString(charSequence).toString()

        /**
         * **Optimisation note**: assumes [scriptText] contains only `\n` line separators as any script text
         * coming from the Kotlin compiler already should.
         */
        fun implicitImportsForScript(scriptText: CharSequence, environment: Environment?) =