model {
                binaries {
                    bin1(BinarySpec)
                    bin2(BinarySpec)
                }
            }
        }

        then:
        def binaries = realizeBinaries()
        binaries.size() == 2
        binaries.bin1.buildTask instanceof DefaultTask
        binaries.bin1.buildTask.name == 'bin1'
        binaries.bin2.buildTask instanceof DefaultTask

                            bin1(BinarySpec)
                            bin2(BinarySpec)
                        }
                    }
                    comp2(ComponentSpec)
                }
            }
        }

        then:
        def tasks = realizeTasks()
        def components = realizeComponents()
        tasks.comp1Bin1 == components.comp1.binaries.bin1.tasks.build

    }

    def "windows searches for executable in path"() {
        def exe = tmpDir.createFile("bin/a.exe")
        tmpDir.createFile("bin2/a.exe")
        def os = new OperatingSystem.Windows() {
            @Override
            List<File> getPath() {
                return [tmpDir.file("bin"), tmpDir.file("bin2")]
            }
        }

        expect:
        os.findInPath("a.exe") == exe

            model {
                testSuites {
                    comp1(TestSuiteSpec) {
                        binaries {
                            bin1(BinarySpec)
                            bin2(BinarySpec)
                        }
                    }
                    comp2(TestSuiteSpec)
                }
            }
        }

        then:

import spock.lang.Specification

class SourceFolderTest extends Specification {
    final static String XML_TEXT = '''
                <classpathentry including="**/Test1*|**/Test2*" excluding="**/Test3*|**/Test4*" kind="src" output="bin2" path="src">
                    <attributes>
                        <attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="mynative"/>
                    </attributes>

	<classpathentry kind="lib" path="/apache-ant-1.7.1/lib/ant-antlr.jar"/>
	<classpathentry kind="src" output="bin2" path="src"/>
	<classpathentry kind="var" path="GRADLE_CACHE/ant-1.6.5.jar"/>
	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/gradle"/>
	<classpathentry kind="output" path="bin"/>

        new Library(fileReferenceFactory.fromPath("/apache-ant-1.7.1/lib/ant-antlr.jar")),
        new SourceFolder("src", "bin2"),
        new Variable(fileReferenceFactory.fromVariablePath("GRADLE_CACHE/ant-1.6.5.jar")),
        new Container("org.eclipse.jdt.USER_LIBRARY/gradle"),
        new Output("bin")]
    final projectDependency = [customEntries[0]]
    final jreContainer = [customEntries[1]]

	frameworkruntime "k8s.io/kubernetes/pkg/scheduler/framework/runtime"
)

var fakeRegistry = frameworkruntime.Registry{
	"QueueSort": newFakePlugin("QueueSort"),
	"Bind1":     newFakePlugin("Bind1"),
	"Bind2":     newFakePlugin("Bind2"),
	"Another":   newFakePlugin("Another"),
}

func TestNewMap(t *testing.T) {
	cases := []struct {
		name    string
		cfgs    []config.KubeSchedulerProfile
		wantErr string
	}{
		{

        def lib = new LibraryIdentifier("project", "lib")
        def bins = Stub(DomainObjectSet)

        when:
        def bins1 = locator.getBinaries(lib)
        def bins2 = locator.getBinaries(lib)

        then:
        bins1.is(bins)
        bins2.is(bins)

        and:
        1 * target.getBinaries(lib) >> bins
        0 * target._
    }

    def "caches null result"() {

#include "tensorflow/compiler/mlir/quantization/stablehlo/quantization_config.pb.h"

namespace stablehlo::quantization {

// Calculates the bin width from the range and expected number of bins. The
// bin width is formalized to the form of 2^n. As a consequence, the actual
// number of bins might be smaller than the given `num_bins`.
inline float CalculateBinWidth(const float min_value, const float max_value,