/**
         * Specifies that the collection should be verbose.
         *
         * @param verbose whether the collection should be verbose or not
         * @return this request for chaining, never {@code null}
         */
        @Nonnull
        public DependencyResolverRequestBuilder verbose(boolean verbose) {
            this.verbose = verbose;
            return this;
        }

        @Nonnull

    def setup() {
        executer.requireIsolatedDaemons()
        buildFile """
            ant.saveStreams = false
            task antTest {
                doLast {
                    ant.echo(message: "VERBOSE message", level: "verbose")
                    ant.echo(message: "DEBUG message", level: "debug")
                    ant.echo(message: "INFO message", level: "info")
                    ant.echo(message: "WARN message", level: "warn")

	return criclient.NewRemoteImageService(endpoint, connectionTimeout, nil, nil)
}

func (*defaultImpl) Status(ctx context.Context, runtimeService criapi.RuntimeService, verbose bool) (*runtimeapi.StatusResponse, error) {
	return runtimeService.Status(ctx, verbose)
}

func (*defaultImpl) ListPodSandbox(ctx context.Context, runtimeService criapi.RuntimeService, filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) {

// The unusual ancestry means the arguments are not Go-standard.
// These variables hold the decoded operation specified by the first argument.
// op holds the operation we are doing (prtx).
// verbose tells whether the 'v' option was specified.
var (
	op      rune
	verbose bool
)

// setOp parses the operation string (first argument).
func setOp(arg string) {
	// Recognize 'go tool pack grc' because that was the

    private long currentTimePeriod;

    public GroupingProgressLogEventGenerator(OutputEventListener listener, LogHeaderFormatter headerFormatter, boolean verbose) {
        this.listener = listener;
        this.headerFormatter = headerFormatter;
        this.verbose = verbose;
    }

    @Override
    public void onOutput(OutputEvent event) {
        if (event instanceof ProgressStartEvent) {

Otherwise, it will skip execution.

Incremental builds are always enabled, and the best way to see them in action is to turn on _verbose mode_.
With verbose mode, each task state is labeled during a build:

[source,text]
----
$ ./gradlew compileJava --console=verbose

> Task :buildSrc:generateExternalPluginSpecBuilders UP-TO-DATE
> Task :buildSrc:extractPrecompiledScriptPluginPlugins UP-TO-DATE

        } else {
            // Write rich content to both stdout and stderr
            Console stdoutConsole = consoleFor(stdout, consoleMetaData, renderer.getColourMap());
            Console stderrConsole = consoleFor(stderr, consoleMetaData, renderer.getColourMap());
            renderer.addRichConsole(stdoutConsole, stderrConsole, consoleMetaData, verbose);
        }
    }

In the top-level folder of your app (`tutorial`), create a `gradle.properties` file.

[source,properties]
----
$ touch gradle.properties
----

Add `org.gradle.console=verbose` so the contents of the file look like this:

.gradle.properties
[source,properties]
----
org.gradle.console=verbose
----

== Step 3. Analyzing Incremental Builds

    }

    /**
     * Tells whether to produce verbose output. Defaults to {@code false}.
     */
    @Console
    public boolean isVerbose() {
        return verbose;
    }

    /**
     * Sets whether to produce verbose output. Defaults to {@code false}.
     */
    public void setVerbose(boolean verbose) {
        this.verbose = verbose;
    }

    /**

		}
	}
	return
}

func ManifestDiff(a, b string, verbose bool) (string, error) {
	ao, err := object.ParseK8sObjectsFromYAMLManifest(a)
	if err != nil {
		return "", err
	}
	bo, err := object.ParseK8sObjectsFromYAMLManifest(b)
	if err != nil {
		return "", err
	}

	aom, bom := ao.ToMap(), bo.ToMap()
	return manifestDiff(aom, bom, nil, verbose)
}