attr {
    key: "_class"
    value {
      list {
        s: "loc:@G4SM2HGMB5/Read/ReadVariableOp"
      }
    }
  }
  attr {
    key: "container"
    value {
      s: ""
    }
  }
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
        dim {
          size: 117
        }

    def "creates value for null value"() {
        expect:
        def value = StaticValue.of(null)
        value.call() == null
        value.taskDependencies == TaskDependencyContainer.EMPTY
        value.attachProducer(Stub(Task))
        value.maybeFinalizeValue()
    }

    def "creates value for other value"() {
        expect:
        def value = StaticValue.of("abc")
        value.call() == "abc"

// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Schema field is set to the value of the last call.
func (b *JSONSchemaPropsApplyConfiguration) WithSchema(value v1.JSONSchemaURL) *JSONSchemaPropsApplyConfiguration {
	b.Schema = &value
	return b
}

// WithRef sets the Ref field in the declarative configuration to the given value

        @Override
        public Isolatable<?> longValue(Long value) {
            return new LongValueSnapshot(value);
        }

        @Override
        public Isolatable<?> shortValue(Short value) {
            return new ShortValueSnapshot(value);
        }

        @Override
        public Isolatable<?> hashCode(HashCode value) {
            return new HashCodeSnapshot(value);
        }

        @Override

node {
  name: "args_0"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_RESOURCE
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "args_1"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_RESOURCE
    }
  }
  attr {
    key: "_handle_dtypes"
    value {
      list {
        type: DT_FLOAT
      }
    }
  }

                }
            }

            task ok(type: SomeTask) {
                value = providers.provider {
                    println("calculating value")
                    'value'
                }
            }
        """

        when:
        configurationCacheRun "ok"

        then:
        outputContains("calculating value")

     * @param <VALUE>
     *            <code>Map</code>の値ーの型
     * @param key
     *            <code>Map</code>に追加されるキー
     * @param value
     *            <code>Map</code>に追加される値
     * @return 指定されたキーと値を持つ{@link IdentityHashMap}を構築するための{@literal Maps}
     */
    public static <KEY, VALUE> Maps<KEY, VALUE> identityHashMap(final KEY key, final VALUE value) {
        return new Maps<>(new IdentityHashMap<KEY, VALUE>()).$(key, value);
    }

        then:
        1 * action4.execute("value")

        then:
        1 * action5.execute("value")
        0 * _

        when:
        set = set.add(action6)
        set.execute("value")

        then:
        !set.empty
        1 * action1.execute("value")

        then:
        1 * action2.execute("value")

        then:
        1 * action3.execute("value")

  name: "Const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 1
      }
    }
  }
}
node {
  name: "Const_1"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {

		<antcall target="install.module">
			<param name="repo.url" value="${maven.release.repo.url}" />
			<param name="module.groupId" value="org/codelibs/opensearch/module" />
			<param name="module.name.prefix" value="" />
			<param name="module.name" value="analysis-common" />
			<param name="module.version" value="${opensearch.version}" />
			<param name="module.zip.version" value="${opensearch.version}" />
		</antcall>
		<!-- geo -->