if !ok {
		return "", fmt.Errorf("failed to get instances from cloud provider")
	}

	nodeName, err := instances.CurrentNodeName(context.TODO(), hostname)
	if err != nil {
		return "", fmt.Errorf("error fetching current node name from cloud provider: %w", err)
	}

	klog.V(2).InfoS("Cloud provider determined current node", "nodeName", klog.KRef("", string(nodeName)))

	return nodeName, nil

class DefaultClassPathRegistryTest extends Specification {
    final ClassPathProvider provider1 = Mock()
    final ClassPathProvider provider2 = Mock()
    final DefaultClassPathRegistry registry = new DefaultClassPathRegistry(provider1, provider2)

    def "fails for unknown classpath"() {
        given:
        provider1.findClassPath(_) >> null
        provider2.findClassPath(_) >> null

        when:
        registry.getClassPath("name")

				}
			}
		}
	}

	// Allow controller manager updating provider ID when not set
	if len(oldNode.Spec.ProviderID) > 0 && oldNode.Spec.ProviderID != node.Spec.ProviderID {
		allErrs = append(allErrs, field.Forbidden(field.NewPath("spec", "providerID"), "node updates may not change providerID except from \"\" to valid"))
	}

	if node.Spec.ConfigSource != nil {

Method <org.gradle.api.tasks.Sync.getPreserve()> does not have raw return type assignable to org.gradle.api.provider.Provider in (Sync.java:0)
Method <org.gradle.api.tasks.Sync.getRootSpec()> does not have raw return type assignable to org.gradle.api.provider.Provider in (Sync.java:0)
Method <org.gradle.api.tasks.Sync.getRootSpec()> does not have raw return type assignable to org.gradle.api.provider.Provider in (Sync.java:0)

	// WARNING: in.PodCIDR requires manual conversion: does not exist in peer-type
	out.PodCIDRs = *(*[]string)(unsafe.Pointer(&in.PodCIDRs))
	out.ProviderID = in.ProviderID
	out.Unschedulable = in.Unschedulable
	out.Taints = *(*[]core.Taint)(unsafe.Pointer(&in.Taints))
	out.ConfigSource = (*core.NodeConfigSource)(unsafe.Pointer(in.ConfigSource))

     * compared to the naive sequential composite provider. Not all providers might be mergeable, or there might be multiple separate sets
     * of providers that can be merged individually, so the resulting provider may be a composite provider.
     */
    public fun merge(providers: List<P>): P

    public fun createFlattened(providers: List<P>): P =
        create(if (providers.size > 1) flatten(providers) else providers)

    public fun flatten(providers: List<P>): List<P> =
        providers.flatMap { provider ->
            // `KotlinCompositeProvider<P>` should always be a provider of type `P` itself, so the cast is legal. Still, suppressing the

    }

    public DefaultProperty<T> provider(Provider<? extends T> provider) {
        set(provider);
        return this;
    }

    @Override
    public void set(Provider<? extends T> provider) {
        Preconditions.checkArgument(provider != null, "Cannot set the value of a property using a null provider.");
        ProviderInternal<? extends T> p = Providers.internal(provider);

** If it's a new property, expose it as a link:{javadocPath}/org/gradle/api/provider/Property.html[Property] or link:{javadocPath}/org/gradle/api/provider/Provider.html[Provider] using a single getter.
** If it's incubating, change it to use a link:{javadocPath}/org/gradle/api/provider/Property.html[Property] or link:{javadocPath}/org/gradle/api/provider/Provider.html[Provider] using a single getter.

    }

    def "queries underlying provider for every call to get()"() {
        def provider = Stub(ProviderInternal)
        provider.type >> List
        provider.calculateValue(_) >>> [["123"], ["abc"]].collect { ValueSupplier.Value.of(it) }
        provider.calculatePresence(_) >> true

        expect:
        property.set(provider)
        assertValueIs(["123"])
        assertValueIs(["abc"])