state[3] = 0x6b206574

	state[4] = binary.LittleEndian.Uint32(key[0:4])
	state[5] = binary.LittleEndian.Uint32(key[4:8])
	state[6] = binary.LittleEndian.Uint32(key[8:12])
	state[7] = binary.LittleEndian.Uint32(key[12:16])
	state[8] = binary.LittleEndian.Uint32(key[16:20])
	state[9] = binary.LittleEndian.Uint32(key[20:24])
	state[10] = binary.LittleEndian.Uint32(key[24:28])
	state[11] = binary.LittleEndian.Uint32(key[28:32])

import java.util.List;

/**
 * Represents the linkage details for a binary.
 *
 * @since 4.10
 */
public interface LinkageDetails {
    /**
     * Returns details of the link task for the binary. This is the task that should be run to produce the binary output, but may not necessarily be the task that links the binary. For example, the task may do some post processing of the binary.
     */
    Task getLinkTask();

    /**

        given:
        compile.incoming >> incoming

        when:
        binary.compileModules.files

        then:
        1 * incoming.artifacts >> Stub(ArtifactCollection)
    }

    def "creates configurations for the binary" () {
        expect:
        binary.linkLibraries == link
        binary.runtimeLibraries == runtime
    }

 * limitations under the License.
 */

package org.gradle.tooling.model.cpp;

/**
 * Represents a C++ binary.
 *
 * @since 4.10
 */
public interface CppBinary {
    /**
     * Returns the name of this binary. This is used to disambiguate the binaries of a project. Each binary has a unique name within its project. However, these names are not unique across multiple projects.
     */
    String getName();

        binary.runtimeFiles.toString() == "runtime files for prebuilt static library 'lib:name'"
    }

    def "can set static library file"() {
        given:
        def file = createFile()

        when:
        binary.staticLibraryFile = file

        then:
        binary.staticLibraryFile == file
        binary.linkFiles.files == [file] as Set

        and:
        binary.runtimeFiles.empty
    }

This wrapper solves for that by fixing the wrapper lib to have binary detection logic that will work in *all* contexts where we use it, rely fully on binary autodetection in all spots, properly handling `iptables/ip6tables` variants..

        task.getToolChain().set(binary.getToolChain());
        task.getTargetPlatform().set(binary.getTargetPlatform());
        task.setPositionIndependentCode(binary instanceof SharedLibraryBinarySpec);

        task.includes(((HeaderExportingSourceSet) sourceSet).getExportedHeaders().getSourceDirectories());

                for (BinarySpecInternal binary : component.getBinaries().withType(BinarySpecInternal.class)) {
                    if (binary.isBuildable()) {
                        assemble.dependsOn(binary);
                        hasBuildableBinaries = true;
                    } else {
                        notBuildable.add(binary);
                    }
                }
            }

    def "adds compile task for binary"() {
        def binary = Stub(DefaultSwiftBinary)
        binary.name >> name
        binary.names >> Names.of(name)
        binary.module >> project.objects.property(String)
        binary.targetMachine >> Stub(TargetMachine)
        binary.targetPlatform >> Stub(SwiftPlatform)
        binary.sourceCompatibility >> project.objects.property(SwiftVersion)

			if strings.Contains(string(out), denylist) {
				t.Fatalf("binary contains unexpected flags: %v", string(out))
			}
		}
	})
}

// Test that binary sizes do not bloat
func TestBinarySizes(t *testing.T) {
	cases := map[string]struct {
		minMb int64
		maxMb int64
	}{
		// TODO: shrink the ranges here once the active work to reduce binary size is complete