return new DefaultBuildIdentifier(absoluteBuildPath);
    }

    private Path assignPath(BuildState owner, String name, File dir) {
        // Get the closest ancestor build of the build directory which we are currently adding
        Optional<Map.Entry<File, NestedBuildState>> parentBuild = nestedBuildsByRootDir.entrySet().stream()
            .filter(entry -> isPrefix(entry.getKey(), dir))

        then:
        def e2 = thrown(IllegalStateException)
        e2.message == "Unknown detail level for node types: [TRANSFORM_STEP]"
    }

    def "plan node dependencies include transitively closest identifiable nodes"() {
        def taskConverter = new ToTestPlannedNodeConverter(TestTaskNode, NodeType.TASK)
        def collector = new PlannedNodeGraph.Collector(new ToPlannedNodeConverterRegistry([taskConverter]))

   * value returned by this method is the {@code i} in that range such that {@code allRequired[i]}
   * is as close as possible to the center of the range [{@code from}, {@code to}]. Choosing the
   * value closest to the center of the range first is the most efficient strategy because it
   * minimizes the size of the subranges from which the remaining selections must be done.
   */
  private static int chooseNextSelection(

	}
}

func TestFloat32Distribution(t *testing.T) {
	// Generate a distribution of (sign, mantissa, exp) values
	// broader than the float32 range, and check Rat.Float32()
	// always picks the closest float32 approximation.
	var add = []int64{
		0,
		1,
		3,
		5,
		7,
		9,
		11,
	}
	var winc, einc = uint64(5), 15 // quick test (~60ms on x86-64)
	if *long {

            get() = ******@****.***
    }

    private
    fun executionEngineFor(scriptHost: KotlinScriptHost<*>): ExecutionEngine {
        // get the ExecutionEngine from the closest available service scope
        // for the global one has no support for the build cache
        return (scriptHost.target as? Project)?.serviceOf()
            ?: executionEngine
    }

    private

   * value returned by this method is the {@code i} in that range such that {@code allRequired[i]}
   * is as close as possible to the center of the range [{@code from}, {@code to}]. Choosing the
   * value closest to the center of the range first is the most efficient strategy because it
   * minimizes the size of the subranges from which the remaining selections must be done.
   */
  private static int chooseNextSelection(

		}

		if float64(float32(out)) == out {
			out, err := ParseFloat(test.in, 32)
			out32 := float32(out)
			if float64(out32) != out {
				t.Errorf("ParseFloat(%v, 32) = %v, not a float32 (closest is %v)", test.in, out, float64(out32))
				continue
			}
			outs := FormatFloat(float64(out32), 'g', -1, 32)
			if outs != test.out || !reflect.DeepEqual(err, test.err) {

     *   - a BOM import to the junit BOM which manages the dep to 0.2
     * This <i>currently</i> results in 0.1 (first wins, unexpected as this is not the closest) and a warning
     */
    @Test
    void testManagedDependencyDistance() throws Exception {
        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        IllegalArgumentException e = thrown()
        e.message == "No factory registered to create an instance of implementation class '${fullyQualifiedNameOf(DefaultThingSpec)}'."
    }

    def "factory for closest superclass to create implementation for a public type"() {
        def thingMock = Mock(ThingSpec)
        def nodeMock = Mock(MutableModelNode)
        instanceFactory.registerFactory(BaseThingSpec, factoryMock)

    public val implicitReceivers: List<KaImplicitReceiver> by validityAsserted(implicitReceivers)

    /**
     * Scopes for position, sorted according to their indexes in scope tower, i.e. the first scope is the closest one to position.
     */
    public val scopes: List<KaScopeWithKind> by validityAsserted(scopes)
}

public typealias KtScopeContext = KaScopeContext

public class KaImplicitReceiver(