return super.hashCode();
        }
        StringBuilder hashString = new StringBuilder(128);
        hashString.append(md.groupId).append('|');
        hashString.append(md.artifactId).append('|');

        if (compareVersion) {
            hashString.append(md.version).append('|');
        }

        if (compareScope) {
            hashString.append(md.getArtifactScope()).append('|');
        }

package org.gradle.nativeplatform.internal;

import org.apache.commons.io.FilenameUtils;
import org.gradle.internal.file.RelativeFilePathResolver;

import java.io.File;

import static org.gradle.internal.hash.Hashing.hashString;

public class CompilerOutputFileNamingScheme {
    private String objectFileNameSuffix;
    private File outputBaseFolder;
    private final RelativeFilePathResolver fileResolver;

    }

    def 'hasher can be used from multiple threads'() {
        given:
        def threadRange = 1..100

        when:
        def hashes = threadRange.collect {
            supplyAsync({ Hashing.hashString(currentThread().name) }, newFixedThreadPool(threadRange.size()))
        }*.join().toSet()

        then:
        hashes.size() == threadRange.size()
    }

    def 'null does not collide with other values'() {

	for k, v := range m {
		// Separate key and value with an individual xor with a random number.
		// Add values of each, so they cannot be trivially collided.
		crc ^= (xxh3.HashString(k) ^ 0x4ee3bbaf7ab2506b) + (xxh3.HashString(v) ^ 0x8da4c8da66194257)
	}
	return crc
}

// hashDeterministicBytes will return a deterministic (weak) hash for the map values.

import org.gradle.test.fixtures.file.TestFile

import static org.gradle.internal.hash.Hashing.hashString

@SelfType(AbstractIntegrationSpec)
trait SourceDependencies {
    TestFile checkoutDir(String repoName, String versionId, String repoId, TestFile baseDir=testDirectory) {
        def prefix = repoName.take(9)
        def hashedCommit = hashString("${repoId}-${versionId}").toCompactString()

        thrown Exception
    }

    def "can create compact string representation"() {
        expect:
        Hashing.md5().hashString("").toCompactString() == "ck2u8j60r58fu0sgyxrigm3cu"
        Hashing.md5().hashString("a").toCompactString() == "r6p51cluyxfm1x21kf967yw1"
        Hashing.md5().hashString("i").toCompactString() == "7ycx034q3zbhupl01mv32dx6p"
    }

    def "can create zero-padded hex representation"() {
        expect:

			Source:    trace,
			Variables: tags,
		}
	} else {
		entry.Message = message
	}

	if anonFlag {
		entry.API.Args.Bucket = HashString(entry.API.Args.Bucket)
		entry.API.Args.Object = HashString(entry.API.Args.Object)
		entry.RemoteHost = HashString(entry.RemoteHost)
		if entry.Trace != nil {
			entry.Trace.Variables = make(map[string]interface{})
		}
	}

	return entry
}

        return DEFAULT.hashBytes(bytes);
    }

    /**
     * Hash the given string with the default hash function.
     */
    public static HashCode hashString(CharSequence string) {
        return DEFAULT.hashString(string);
    }

    /**
     * Hash the contents of the given {@link java.io.InputStream} with the default hash function.
     */

import java.util.Set;
import java.util.function.Supplier;

import static org.gradle.api.internal.cache.CacheConfigurationsInternal.DEFAULT_MAX_AGE_IN_DAYS_FOR_CREATED_CACHE_ENTRIES;
import static org.gradle.internal.hash.Hashing.hashString;
import static org.gradle.internal.time.TimestampSuppliers.daysAgo;

public class DefaultVersionControlRepositoryFactory implements VersionControlRepositoryConnectionFactory, Stoppable {

        def isNone = candidates.isNone()

        then:
        !isNone
        1 * factory.create() >> [file("abc"), file("def")]

        when:
        def candidate = candidates.findByHashValue(Hashing.sha1().hashString("def"))

        then:
        candidate.file.name == "def"
        0 * factory.create()
    }

    File file(path) {
        tmp.createFile(path) << path
    }