services.get(Number) >> 12

        expect:
        // Use a Java class to verify GroovyObject is not mixed in
        def bean = create(BeanWithServiceGetters, services)
        bean.someValue == 12
        bean.calculated == "[12]"

        bean instanceof GeneratedSubclass
        bean.publicType() == BeanWithServiceGetters

        bean instanceof ModelObject

                        },
                        "configuration": {
                            "@type": "type.googleapis.com/google.protobuf.StringValue",
                            "value": "{\"header_1\":\"some_value_1\",\"header_2\":\"another_value\"}"
                        }
                    }
                }
            },
            "lastUpdated": "2022-12-08T11:03:53.225Z"
        },
        {

                                "configuration": {
                                    "@type": "type.googleapis.com/google.protobuf.StringValue",
                                    "value": "{\"header_1\":\"some_value_1\",\"header_2\":\"another_value\"}"
                                }
                            }
                        }
                    },
                    "last_updated": "2022-12-08T11:03:53.225Z"

        var x: Int

        @get: Restricted
        var y: Int

        @Configuring
        fun configuring(configure: NestedReceiver.() -> Unit)

        @Adding
        fun adding(someValue: Int, configure: NestedReceiver.() -> Unit): NestedReceiver

        @Restricted
        fun myInt(): Int
    }

    interface NestedReceiver {
        @get:Restricted
        var a: Int

				*j = &runtime.Unknown{
					// We do not set TypeMeta here because it is not carried through a round trip
					Raw:         []byte(`{"apiVersion":"unknown.group/unknown","kind":"Something","someKey":"someValue"}`),
					ContentType: runtime.ContentTypeJSON,
				}
			} else {
				types := []runtime.Object{&api.Pod{}, &api.ReplicationController{}}
				t := types[c.Rand.Intn(len(types))]
				c.Fuzz(t)
				*j = t
			}

        where:
        key        | requestedValue  | reportedValue   | expectedResult
        'existing' | 'existingValue' | 'existingValue' | true
        'existing' | 'someValue'     | 'existingValue' | false
        'missing'  | 'someValue'     | null            | false
    }

    def "aggregating method #methodName reports all properties as inputs"() {
        when:
        operation.accept(getMapUnderTestToRead())

    def componentIdentifier = DefaultModuleComponentIdentifier.newId(versionIdentifier)
    def testAttribute = Attribute.of("someAttribute", String)
    def attributes = AttributeTestUtil.attributesFactory().of(testAttribute, "someValue")
    def schema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), SnapshotTestUtil.isolatableFactory())
    def ivyMetadataFactory = DependencyManagementTestUtil.ivyMetadataFactory()

        buildKotlinFile << """
            tasks.register("printer") {
                val someValue = objects.property<String>().convention("some value")
                doLast {
                    val filtered = someValue.filter { it.contains("value") }
                    someValue.set("trash")
                    println("filter: ${'$'}{filtered.getOrNull()}")
                }
            }

static Status ValidateNode(const NodeDef& node) {
  const auto node_iterator = node.attr().find("value");
  if (node_iterator != node.attr().end()) {
    AttrValue node_value = node_iterator->second;
    if (node_value.has_tensor()) {
      const PartialTensorShape node_shape(node_value.tensor().tensor_shape());
      if (node_shape.num_elements() < 0) {
        return absl::FailedPreconditionError(absl::StrCat(

        key        | requestedValue  | reportedValue   | expectedResult
        'existing' | 'existingValue' | 'existingValue' | true
        'existing' | 'otherValue'    | 'existingValue' | false
        'missing'  | 'someValue'     | null            | false
    }

    def "entrySet() containsAll(entry(#key1, #requestedValue1), entry(#key2, #requestedValue2)) are tracked"() {
        when: