"image_ops",
        "io_ops",
        "linalg_ops",
        "list_ops",
        "map_ops",
        "logging_ops",
        "lookup_ops",
        "manip_ops",
        "nn_ops",
        "no_op",
        "parsing_ops",
        "random_ops",
        "sparse_ops",
        "state_ops",
        "string_ops",
        "training_ops",
        "user_ops",
    ],
    other_hdrs = [

     */
    default WorkValidationContext.TypeOriginInspector getTypeOriginInspector() {
        return WorkValidationContext.TypeOriginInspector.NO_OP;
    }

                private ZincCompilerServices(File gradleUserHome) {
                    super(NativeServices.getInstance())

                    add(OutputEventListener.class, OutputEventListener.NO_OP)
                    addProvider(new GlobalScopeServices(true, AgentStatus.disabled()))
                }

                 static def getInstance(File gradleUserHome) {
                    if (instance == null) {

        } else {
            // We don't know the type of element in the provider, so we assume it's the type of the collection
            DefaultListProperty<T> defaultListProperty = new DefaultListProperty<T>(PropertyHost.NO_OP, Cast.uncheckedCast(getType()));
            defaultListProperty.convention(provider);
            providerInternal = defaultListProperty;
        }
        store.addPendingCollection(providerInternal);
    }

        !copy.get().is(originalValue)
    }

    def "creates isolated map property"() {
        def originalMap = [a: 1, b: 2]
        def original = new DefaultMapProperty(PropertyHost.NO_OP, String, Number)
        original.set(originalMap)

        given:
        1 * managedFactoryRegistry.lookup(_) >> new ManagedFactories.MapPropertyManagedFactory(TestUtil.propertyFactory())

        expect:

        getOutputFilesProducedByWork() >> ImmutableSortedMap.of()
    }
    def validationContext = new DefaultWorkValidationContext(WorkValidationContext.TypeOriginInspector.NO_OP)
    def executionContext = Mock(TaskExecutionContext)
    def scriptSource = Mock(ScriptSource)
    def standardOutputCapture = Mock(StandardOutputCapture)

            final Type fieldType,
            final BytecodeFragment initializer
        ) {
            addLazyGetter(methodName, returnType, methodDescriptor, null, fieldName, fieldType, initializer, BytecodeFragment.NO_OP);
        }

        private void addLazyGetter(
            String methodName,
            Type returnType,
            String methodDescriptor,
            @Nullable String signature,

      return no_op();

    int64_t input_rank = input_type.getRank();
    int64_t first_dim_size = input_type.getDimSize(0);
    if (ShapedType::isDynamic(first_dim_size)) return failure();

    if (first_dim_size <= 1)
      // No shuffling is required, so copy input directly to output.
      return no_op();

            context.details.addVariant("noAop${base.capitalize()}", base) {
                withCapabilities {
                    addCapability("com.google.inject", "guice-no_aop", context.details.id.version)
                }
                withFiles {
                    removeAllFiles()
                    addFile("guice-${context.details.id.version}-no_aop.jar")
                }
                withDependencies {

            context.details.addVariant("noAop${base.capitalize()}", base) {
                withCapabilities {
                    addCapability("com.google.inject", "guice-no_aop", context.details.id.version)
                }
                withFiles {
                    removeAllFiles()
                    addFile("guice-${context.details.id.version}-no_aop.jar")
                }
                withDependencies {