// are a multiple of the block size.
	BlockSize() int
}

// Hash32 is the common interface implemented by all 32-bit hash functions.
type Hash32 interface {
	Hash
	Sum32() uint32
}

// Hash64 is the common interface implemented by all 64-bit hash functions.
type Hash64 interface {
	Hash
	Sum64() uint64

        setup:
        settingsFile << '''
            rootProject.name = 'root'
            include 'sub1'
            include 'sub1:sub2'
        '''
        buildFile << '''
            allprojects {
                tasks.register('foo')
            }
        '''
        file('sub1/sub2').mkdirs()

        when:
        launchTestWithTestFilter(toolingApi.connector().forProjectDirectory(projectDir.file('sub1'))) {

                jvmArgs = ['-version']
            }
            """

        multiProjectBuild("invalidJvmInstallationReporting", ["sub1", "sub2"]) {
            project("sub1").buildFile << configureJavaExecToUseToolchains
            project("sub2").buildFile << configureJavaExecToUseToolchains
        }

        when: "running two consecutive builds in a daemon"
        def results = (0..1).collect {

            }
        """
        file("sub2/build.gradle") << """
            dependencies {
                implementation group: 'junit', name: 'junit', version: '4.10'
            }
        """
        settingsFile << """
            include "sub1", "sub2"
        """

        when:
        def runner = runner('dependencyUpdates', '-DoutputFormatter=txt')

	object = strings.Replace(object, "ClaimInfoStateListWithoutResourceHandles", "ClaimInfoStateList", 1)
	hash := fnv.New32a()
	fmt.Fprintf(hash, "%v", object)
	if checkSum != checksum.Checksum(hash.Sum32()) {
		return errors.ErrCorruptCheckpoint
	}
	return nil

	// initialization in this case.
	d.crc = update(d.crc, d.tab, p, false)
	return len(p), nil
}

func (d *digest) Sum32() uint32 { return d.crc }

func (d *digest) Sum(in []byte) []byte {
	s := d.Sum32()
	return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
}

// Checksum returns the CRC-32 checksum of data
// using the polynomial represented by the [Table].

        and:
        hasIncubatingLegend()
    }

    def "Test suites in different projects can use same test type"() {
        def subADir = createDir("subA")
        subADir.file("build.gradle") << """
            plugins {
                id 'java'
            }

            ${mavenCentralRepository()}

            testing {
                suites {

		s1 %= mod
		s2 %= mod
		p = q
	}
	return digest(s2<<16 | s1)
}

func (d *digest) Write(p []byte) (nn int, err error) {
	*d = update(*d, p)
	return len(p), nil
}

func (d *digest) Sum32() uint32 { return uint32(*d) }

func (d *digest) Sum(in []byte) []byte {
	s := uint32(*d)
	return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
}

// Checksum returns the Adler-32 checksum of data.

    }

    def "attribute and capability combinations can be repeated across projects without a warning"() {
        given:
        def subADir = createDir("subA")
        subADir.file("build.gradle") << """
            plugins {
                id 'java'
            }

            configurations {
                sampleA {
                    canBeResolved = false

        }

        project("sub2") {
            evaluationDependsOn ':sub1'

            task customTask  {
                dependsOn project(":sub1").tasks.withType(ClimbTask)
            }
        }
        """

        when:
        succeeds('sub2:customTask')

        then:
        result.assertTasksExecutedInOrder(':sub1:climbTask', ':sub2:customTask')
    }