key: "varargs"
            value {
              none_value {
              }
            }
          }
          values {
            key: "varkw"
            value {
              none_value {
              }
            }
          }
          values {
            key: "defaults"
            value {
              none_value {
              }
            }
          }

    Provider<Integer> providerWithValue(Integer value) {
        return Providers.of(value)
    }

    @Override
    Class<Integer> type() {
        return Integer
    }

    @Override
    Integer someValue() {
        return 12
    }

    @Override
    Integer someOtherValue() {
        return 123
    }

    @Override
    Integer someOtherValue2() {
        return 1234
    }

    @Override

        when:
        ant.otherProp = 'true'
        ant.condition(property: 'prop', value: 'someValue') {
            or {
                and {
                    isSet(property: 'otherProp')
                    not { isSet(property: 'missing') }
                }
            }
        }

        then:
        ant.prop == 'someValue'
    }

    def "sets context classloader during execution"() {
        setup:

Gradle can also set project properties when it sees specially-named system properties or environment variables.
If the environment variable name looks like `ORG_GRADLE_PROJECT___prop__=somevalue`, then Gradle will set a `prop` property on your project object, with the value of `somevalue`.
Gradle also supports this for system properties, but with a different naming pattern, which looks like `org.gradle.project.__prop__`.

class FilePropertyTest extends FileSystemPropertySpec<RegularFile> {
    @Override
    Class<RegularFile> type() {
        return RegularFile.class
    }

    @Override
    RegularFile someValue() {
        return baseDirectory.file("dir1").get()
    }

    @Override
    RegularFile someOtherValue() {
        return baseDirectory.file("other1").get()
    }

    @Override

				*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{&example.Pod{}}
				t := types[c.Rand.Intn(len(types))]
				c.Fuzz(t)
				*j = t
			}
		},

				*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{&testapigroup.Carp{}}
				t := types[c.Rand.Intn(len(types))]
				c.Fuzz(t)
				*j = t
			}
		},

        parser.parseNotation(WrapUtil.toMap(ExcludeRule.MODULE_KEY, "aModule"));

        when:
        parser.parseNotation(WrapUtil.toMap("unknownKey", "someValue"))

        then:
        thrown(InvalidUserDataException)
    }

    assertThrows(IllegalArgumentException.class, () -> Stats.meanOf());
    assertThrows(IllegalArgumentException.class, () -> Stats.meanOf(ImmutableList.<Number>of()));
    assertThat(Stats.meanOf(ONE_VALUE)).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
    assertThat(Stats.meanOf(POSITIVE_INFINITY)).isPositiveInfinity();
    assertThat(Stats.meanOf(NEGATIVE_INFINITY)).isNegativeInfinity();
    assertThat(Stats.meanOf(NaN)).isNaN();

      '@type': type.googleapis.com/envoy.extensions.filters.http.wasm.v3.Wasm
      config:
        configuration:
          '@type': type.googleapis.com/google.protobuf.StringValue
          value: '{"header_1":"some_value_1","header_2":"another_value"}'
        name: default.display-metadata
        vmConfig:
          code:
            local: