T wrapper = wrapperFunction.apply(proxy);
      boolean isPossibleChainingCall = interfaceType.isAssignableFrom(method.getReturnType());
      try {
        Object actualReturnValue = method.invoke(wrapper, passedArgs);
        // If we think this might be a 'chaining' call then we allow the return value to either
        // be the wrapper or the returnValue.

					"samples",
					"signing",
					"snapshots",
					"testing-base",
					"toolchains-jvm",
					"tooling-api",
					"version-control",
					"war",
					"workers",
					"wrapper-main",
					"wrapper-shared"
				]
			}
		],
		"testCoverageUuid":33
	},
	{
		"buckets":[
			{
				"parallelizationMethod":{
					"name":"TeamCityParallelTests",
					"numberOfBatches":4

    private static final Set<Equivalence.Wrapper<Method>> OBJECT_METHODS = ImmutableSet.copyOf(
        Iterables.transform(
            Iterables.concat(
                Arrays.asList(Object.class.getMethods()),
                Arrays.asList(GroovyObject.class.getMethods())
            ), new Function<Method, Equivalence.Wrapper<Method>>() {
                @Override
                public Equivalence.Wrapper<Method> apply(@Nullable Method input) {

## Creator

Hey! 👋

This is me:

{% if people %}
<div class="user-list user-list-center">
{% for user in people.maintainers %}

<div class="user"><a href="{{ user.url }}" target="_blank"><div class="avatar-wrapper"><img src="{{ user.avatarUrl }}"/></div><div class="title">@{{ user.login }}</div></a> <div class="count">Answers: {{ user.answers }}</div><div class="count">Pull Requests: {{ user.prs }}</div></div>
{% endfor %}

</div>

# tag::cli[]
# gradle wrapper --gradle-version=4.0 --distribution-type=all
# end::cli[]
executable: gradle
args: "wrapper --gradle-version=4.0 --distribution-type=all"

        public String id() {
            return WRAPPER;
        }

        @Override
        public Collection<Phase> phases() {
            return singleton(phase(
                    "wrapper",
                    plugin(
                            "org.apache.maven.plugins:maven-wrapper-plugin:" + MAVEN_WRAPPER_PLUGIN_VERSION
                                    + ":wrapper",
                            "wrapper")));

        }
    }

    @Nullable
    private static <T> IntermediateResultHandler<? super T> getHandler(@Nullable PhasedBuildAction.BuildActionWrapper<T> wrapper) {
        return wrapper == null ? null : wrapper.getHandler();
    }

    private static InternalPhasedAction getPhasedAction(PhasedBuildAction phasedBuildAction, File rootDir, VersionDetails versionDetails) {

          | Creator: 	Project.<init>.tasks.updateDaemonJvm()
          | Rules:
             ⤷ copyToTaskContainer
    + wrapper
          | Type:   	org.gradle.api.tasks.wrapper.Wrapper
          | Value:  	task ':wrapper'
          | Creator: 	Project.<init>.tasks.wrapper()
          | Rules:

type Comparator struct {
	envoy, istiod *configdump.Wrapper
	w             io.Writer
	context       int
	location      string
}

// NewComparator is a comparator constructor
func NewComparator(w io.Writer, istiodResponses map[string][]byte, envoyResponse []byte) (*Comparator, error) {
	c := &Comparator{}
	for _, resp := range istiodResponses {
		istiodDump := &configdump.Wrapper{}
		err := json.Unmarshal(resp, istiodDump)

=====

== Step 2. Understanding the Gradle Wrapper
The Gradle Wrapper is the preferred way of starting a Gradle build.
The Wrapper downloads (if needed) and then invokes a specific version of Gradle declared in the build.

In your newly created project, take a look at the files used by the Gradle Wrapper first.