normalize(".//a/b//file.txt", baseDir) == child
        normalize("sub/../a/b/file.txt", baseDir) == child
        normalize("../sub", baseDir) == sibling
        normalize("..", baseDir) == ancestor
        normalize(".", baseDir) == baseDir
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "normalizes relative path when base dir is a link"() {

        expect:
        write([:], "Line comment") == normalize("""
            #Line comment
            """)
    }

    def "simple properties are written sorted alphabetically"() {
        expect:
        write([one: "1", two: "2", three: "three"], "Line comment") == normalize("""
            #Line comment
            one=1
            three=three
            two=2

                    .url(normalize(scm.getUrl()))
                    .connection(normalize(scm.getConnection()))
                    .developerConnection(normalize(scm.getDeveloperConnection()))
                    .build());
        }

        DistributionManagement dist = model.getDistributionManagement();
        if (dist != null) {
            Site site = dist.getSite();
            if (site != null) {

        return bundles.get(normalize(name));
    }

    public VersionModel getVersion(String name) {
        return versions.get(normalize(name));
    }

    public PluginModel getPlugin(String name) {
        return plugins.get(normalize(name));
    }

    public boolean hasDependency(String alias) {
        return libraries.containsKey(normalize(alias));
    }

     * @throws Exception
     */
    public void testNormalize() throws Exception {
        assertEquals("1", "1000.00", DecimalFormatUtil.normalize("1,000.00", Locale.JAPAN));
        assertEquals("2", "1000", DecimalFormatUtil.normalize("1,000", Locale.JAPAN));
        assertEquals("3", "1000.00", DecimalFormatUtil.normalize("1.000,00", Locale.GERMAN));
    }

class LineEndingNormalizingInputStreamHasherTest extends Specification {
    @TempDir
    File tempDir

    def hasher = new LineEndingNormalizingInputStreamHasher()

    def "can normalize line endings in files (eol = '#description')"() {
        def unnormalized = file('unnormalized.txt') << content.textWithLineEndings(eol)
        def normalized = file('normalized.txt') << content.textWithLineEndings('\n')

                comment = "Line comment"
                outputFile = file("output.properties")
            }
        """

        when:
        runProps()
        then:
        file("output.properties").text == normalize("""
            #Line comment
            """)
    }

    private runProps() {
        result = expectOutputDeprecation(executer.withTasks("props")).run()
    }

                seenWarning = true
            } else {
                result << line
            }
        }
        return result.join("\n")
    }

    String normalize(String output) {
        return normalize(output, null)
    }

    /**
     * 数値の文字列での表記を正規化します。
     *
     * @param s
     *            数値を表す文字列
     * @return 正規化された文字列
     * @see #normalize(String, Locale)
     */
    public static String normalize(final String s) {
        return normalize(s, LocaleUtil.getDefault());
    }

    /**
     * 数値の文字列での表記をグルーピングセパレータを削除し、小数点を.であらわした標準形に正規化します。
     *
     * @param s
     *            数値を表す文字列

        String normalizedAlias = normalize(alias);
        if (config.hasDependency(normalizedAlias)) {
            return Optional.of(dependencyFactory.create(normalizedAlias));
        }
        return Optional.empty();
    }

    @Override
    public final Optional<Provider<ExternalModuleDependencyBundle>> findBundle(String alias) {
        String normalizedBundle = normalize(alias);