import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import org.gradle.api.GradleException;
import org.gradle.model.ModelMap;
import org.gradle.model.ModelSet;
import org.gradle.model.internal.manage.schema.CollectionSchema;
import org.gradle.model.internal.manage.schema.ModelSchemaStore;
import org.gradle.model.internal.type.ModelType;

echo "Will download ${SERVER_TAR} from ${DOWNLOAD_URL_PREFIX}"
echo "Will download and extract ${CLIENT_TAR} from ${DOWNLOAD_URL_PREFIX}"

DOWNLOAD_NODE_TAR=false
if [[ -n "${NODE_TAR:-}" ]]; then
  DOWNLOAD_NODE_TAR=true
  echo "Will download and extract ${NODE_TAR} from ${DOWNLOAD_URL_PREFIX}"
fi

DOWNLOAD_TESTS_TAR=false
if [[ -n "${KUBERNETES_DOWNLOAD_TESTS-}" ]]; then
  DOWNLOAD_TESTS_TAR=true

                }

                @Model
                String third(@Path("first") String first) {
                    "fizz"
                }

                @Mutate
                void connectTasksToFirst(ModelMap<Task> tasks, @Path("first") String first) {
                }
            }

            apply type: Rules

            model {
                second {
                    $.third
                }

import org.gradle.api.DomainObjectSet;
import org.gradle.api.Incubating;
import org.gradle.internal.HasInternalProtocol;
import org.gradle.language.base.LanguageSourceSet;
import org.gradle.model.ModelMap;

/**
 * Represents a binary that is the result of building a component.
 */
@Incubating @HasInternalProtocol
public interface BinarySpec extends BuildableComponentSpec, CheckableComponentSpec, Binary {

    /**

import org.gradle.util.TestUtil
import org.gradle.util.UsesNativeServices
import org.junit.Rule
import spock.lang.Specification

import static org.gradle.model.internal.type.ModelTypes.modelMap

@UsesNativeServices
class CUnitTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())

    void registerMyComponent(TypeBuilder<MyComponent> builder) {
        builder.internalView(MyComponentInternal)
    }
// end::type-registration[]
// tag::internal-view-mutation[]
    @Mutate
    void mutateMyComponents(ModelMap<MyComponentInternal> components) {
        components.all { component ->
            component.publicData = "Some PUBLIC data"
            component.internalData = "Some INTERNAL data"
        }
    }

                    assert platform.operatingSystem.family.is(platform.operatingSystem.family)
                }

                @Mutate
                void addPersonTask(ModelMap<Task> tasks, Platform platform) {
                    tasks.create("echo") {
                        it.doLast {
                            println "platform: $platform"

  std::vector<std::optional<double>> node_mins;
  std::vector<std::optional<double>> node_maxs;

  // Populate quantization specs.
  TF_RETURN_IF_ERROR(internal::PopulateQuantizationSpecs(
      model_flags, toco_flags, &quant_specs, &node_names, &node_dtypes,
      &node_shapes, &node_mins, &node_maxs));

  TF_RETURN_IF_ERROR(
      ParseInputArrayInfo(node_names, node_dtypes, node_shapes, &specs.inputs));

        exe.sources instanceof ModelMap
        sourceSetClass.isInstance(exe.sources."$pluginName")
        exe.sources."$pluginName".source.srcDirs == [project.file("src/exe/$pluginName")] as Set
        exe.sources."$pluginName".exportedHeaders.srcDirs == [project.file("src/exe/headers")] as Set

        and:
        def lib = components.lib
        lib.sources instanceof ModelMap

import org.gradle.api.plugins.ExtensionContainer;
import org.gradle.api.publish.PublishingExtension;
import org.gradle.internal.service.ServiceRegistry;
import org.gradle.model.Model;
import org.gradle.model.ModelMap;
import org.gradle.model.Mutate;
import org.gradle.model.RuleSource;

/**
 * These bindings are only here for backwards compatibility, as some users might depend on the extensions being available in the model.
 */