def char1 = left as char
        def char2 = right as char

        expect:
        compareCharsIgnoringCase(char1, char2) == result
        compareCharsIgnoringCase(char2, char1) == -result
        compareChars(char1, char2) == result
        compareChars(char2, char1) == -result
        equalChars(char1, char2, caseSensitivity) == (result == 0)

    static int compareCharsIgnoringCase(char char1, char char2) {
        if (char1 == char2) {
            return 0;
        }
        return isFileSeparator(char1)
            ? isFileSeparator(char2)
                ? 0
                : -1
            : isFileSeparator(char2)
                ? 1
                : compareDifferentCharsIgnoringCase(char1, char2);
    }

            return b;
        }

        public void addWord(String word) {
            Trie.Builder cur = this;
            char[] chars = word.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                char c = chars[i];
                cur = cur.addTransition(c, i == chars.length - 1);
            }
        }

        public Trie build() {

    private static List<String> primitiveTypes() {
        ['byte', 'short', 'int', 'long', 'float', 'double', 'char', 'boolean']
    }

    private static String expectedOutputFor(String type) {
        switch (type) {
            case 'boolean':
                return 'booleanArrayOf(true)'
            case 'char':
                return 'charArrayOf(*)' // 42.toChar() == '*'
            case 'float':

        )
    }

    @Test
    fun `#kotlinTypeStringFor primitive type`() {
        assertPrimitiveTypeName<Boolean>(java.lang.Boolean.TYPE)
        assertPrimitiveTypeName<Char>(java.lang.Character.TYPE)
        assertPrimitiveTypeName<Byte>(java.lang.Byte.TYPE)
        assertPrimitiveTypeName<Short>(java.lang.Short.TYPE)
        assertPrimitiveTypeName<Int>(java.lang.Integer.TYPE)

    }

    def "won't parse string with odd length"() {
        when:
        HashCode.fromString("a" * 9)

        then:
        thrown Exception
    }

    def "won't parse string with non-hex chars: #illegal"() {
        when:
        HashCode.fromString(illegal)

        then:
        thrown Exception

        where:
        illegal << ["abcdefgh", "-1235689", "0x123456"]
    }

 */
public abstract class HashCode implements Serializable, Comparable<HashCode> {
    private static final int MIN_NUMBER_OF_BYTES = 4;
    private static final int MAX_NUMBER_OF_BYTES = 255;
    private static final char[] HEX_DIGITS = "0123456789abcdef".toCharArray();

    private HashCode() {
    }

    enum Usage {
        CLONE_BYTES_IF_NECESSARY,
        SAFE_TO_REUSE_BYTES
    }

        boolean.name                         | "true"                                    | "true"
        Character.name                       | "'a'"                                     | "a"
        char.name                            | "'a'"                                     | "a"
        Byte.name                            | "12"                                      | "12"

Logger implements Appendable { public final boolean quiet; public void Logger(boolean); public final void log(String); public final Appendable append(CharSequence); public final Appendable append(CharSequence, int, int); public final Appendable append(char); } org/gradle/wrapper/PathAssembler.class package org.gradle.wrapper; public final synchronized class PathAssembler { public void PathAssembler(java.io.File, java.io.File); } org/gradle/wrapper/SystemPropertiesHand.class package org.gradle.wrapper;...

        if (depth == 0) {
            prefixes.add((File.separator == '/' ? '/' : "") + path)
        } else {
            prefixes.add(depth + ":" + path.replace(File.separatorChar, (char) '/'))
        }
        def unpackedNode = (node.getSnapshot()
            .filter { it instanceof FileSystemLocationSnapshot }
            .orElse(node))
        if (unpackedNode instanceof DirectorySnapshot) {