v.version  == '1.0'
    }

    def "reports unsupported provider type"() {
        given:
        def provider = Stub(Provider.class)
        def dependency = new DefaultPluginDependency("pluginId", new DefaultMutableVersionConstraint("1.0"))
        provider.get() >> dependency

        when:
        parser("force()").parseNotation(provider)

        then:
        def ex = thrown(InvalidUserDataException)

 */

package org.gradle.api.internal.provider;

import org.gradle.api.Transformer;
import org.gradle.api.internal.tasks.TaskDependencyContainer;
import org.gradle.api.provider.Provider;
import org.gradle.internal.DisplayName;

import javax.annotation.Nullable;
import java.util.function.BiFunction;

/**
 * <p>The internal view of a {@link Provider}.</p>
 *

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.provider.sources.process;

import org.gradle.api.internal.provider.sources.process.ProcessOutputValueSource.ExecOutputData;
import org.gradle.api.provider.Provider;
import org.gradle.process.ExecOutput;
import org.gradle.process.ExecResult;

import java.nio.charset.Charset;

            import org.gradle.api.provider.Provider

            class MyPlugin : Plugin<Project> {
                override fun apply(project: Project) {
                    project.run {
                        val providerA: Provider<String> = provider { "thing" }.flatMap { provider { null } }
                        val providerB: Provider<String> = provider { "thing" }.flatMap { null }
                    }

        expect:
        provider1.get() == ["a"]
        provider2.get() == ["a", "b"]
    }

    def "isPresent is true if all sources are present"() {
        given:
        def provider1 = new MergeProvider([providers.provider { new Object() }])
        def provider2 = new MergeProvider([providers.provider { new Object() }, providers.provider { new Object() }])

        expect:

	}

	fieldPath := field.NewPath("providers")
	for _, provider := range config.Providers {
		if strings.Contains(provider.Name, "/") {
			allErrs = append(allErrs, field.Invalid(fieldPath.Child("name"), provider.Name, "provider name cannot contain '/'"))
		}

		if strings.Contains(provider.Name, " ") {
			allErrs = append(allErrs, field.Invalid(fieldPath.Child("name"), provider.Name, "provider name cannot contain spaces"))
		}

}

func ValidateExtensionProviderEnvoyOtelAls(provider *meshconfig.MeshConfig_ExtensionProvider_EnvoyOpenTelemetryLogProvider) (errs error) {
	if provider == nil {
		return fmt.Errorf("nil EnvoyOpenTelemetryLogProvider")
	}
	if err := ValidatePort(int(provider.Port)); err != nil {
		errs = AppendErrors(errs, err)
	}
	if err := validateExtensionProviderService(provider.Service); err != nil {
		errs = AppendErrors(errs, err)
	}

import org.gradle.api.internal.provider.DefaultListProperty
import org.gradle.api.internal.provider.DefaultMapProperty
import org.gradle.api.internal.provider.DefaultProperty
import org.gradle.api.internal.provider.DefaultSetProperty
import org.gradle.api.internal.provider.DefaultValueSourceProviderFactory.ValueSourceProvider
import org.gradle.api.internal.provider.PropertyFactory

        provider = container.register("b", Mock(Action))

        then:
        provider.type == DefaultTask
        provider.name == "b"
        0 * action.execute(_)

        when:
        provider = container.register("c", CustomTask)

        then:
        provider.type == CustomTask
        provider.name == "c"
        0 * action.execute(_)

        when:

    private final SideEffect<? super T> sideEffect;

    private WithSideEffectProvider(ProviderInternal<T> provider, SideEffect<? super T> sideEffect) {
        this.provider = provider;
        this.sideEffect = sideEffect;
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return provider.getType();
    }

    @Override
    public ValueProducer getProducer() {