}

        String normalized = heapSize.trim().toLowerCase();
        try {
            if (normalized.endsWith("m")) {
                return Integer.parseInt(normalized.substring(0, normalized.length() - 1));
            }
            if (normalized.endsWith("g")) {
                return Integer.parseInt(normalized.substring(0, normalized.length() - 1)) * 1024;
            }

            return -1;
        }
        String normalized = notation.toLowerCase(Locale.US).trim();
        if (normalized.isEmpty()) {
            return -1;
        }
        try {
            if (normalized.endsWith("k")) {
                return parseWithFactor(normalized, KILO_FACTOR);
            }
            if (normalized.endsWith("m")) {
                return parseWithFactor(normalized, MEGA_FACTOR);
            }

     * Note: Alias will be automatically normalized: '-', '_' and '.' will be replaced with '.'
     * </p>
     * @param alias the alias of the library
     * @since 7.4
     */
    Optional<Provider<MinimalExternalModuleDependency>> findLibrary(String alias);

    /**
     * Returns the provider for the corresponding bundle alias.
     * <p>
     * Note: Bundle will be automatically normalized: '-', '_' and '.' will be replaced with '.'

        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);

        for (Dependency dependency : dependencies) {
            normalized.put(dependency.getManagementKey(), dependency);
        }

        if (dependencies.size() != normalized.size()) {
            builder.dependencies(normalized.values());
        }

        return builder.build();
    }

    private static final ABSOLUTE = AbsolutePathFingerprintCompareStrategy.INSTANCE
    private static final NORMALIZED = NormalizedPathFingerprintCompareStrategy.INSTANCE
    private static final IGNORED_PATH = IgnoredPathCompareStrategy.INSTANCE
    private static final ALL_STRATEGIES = ImmutableList.of(ABSOLUTE, NORMALIZED, IGNORED_PATH)

    def "empty snapshots (#strategy.class.simpleName)"() {
        expect:
        changes(strategy,

     *
     * <p>Error messages are normalized to use new-line char as line separator.
     *
     * @return this
     */
    ExecutionFailure assertHasFailure(String description, Consumer<? super Failure> action);

    /**
     * Asserts that there is a failure present with the given cause (ie the bit after the description).
     *
     * <p>Error messages are normalized to use new-line char as line separator.
     */

        def unnormalized = file('unnormalized.txt') << content.textWithLineEndings(eol)
        def normalized = file('normalized.txt') << content.textWithLineEndings('\n')

        expect:
        hasher.hashContent(unnormalized).get() == hasher.hashContent(normalized).get()

        where:
        eol     | description
        '\r'    | 'CR'
        '\r\n'  | 'CR-LF'
        '\n'    | 'LF'
    }

        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);

        for (Dependency dependency : dependencies) {
            normalized.put(dependency.getManagementKey(), dependency);
        }

        if (dependencies.size() != normalized.size()) {
            builder.dependencies(normalized.values());
        }

        return builder.build();
    }

		name, port, scheme string
		valid              bool
		normalized         bool
	}{
		{
			in:         "aoeu:asdf",
			name:       "aoeu",
			port:       "asdf",
			valid:      true,
			normalized: true,
		}, {
			in:         "http:aoeu:asdf",
			scheme:     "http",
			name:       "aoeu",
			port:       "asdf",
			valid:      true,
			normalized: true,
		}, {
			in:         "https:aoeu:",

// "normalized" form of the embeddings. A structural restriction is normalized
// if it is a single union containing no interface terms, and is minimal in the
// sense that removing any term changes the set of types satisfying the
// constraint. It is left as a proof for the reader that, modulo sorting, there
// is exactly one such normalized form.
//