s.Add(out) // not inlined.
	return out
}

var s T

func main() {
	println("Starting")
	fmt.Sprint(new(int32))
	resp := F(s).(*P)
	println("Before, *resp.V=", *resp.V) // Trashes *resp.V in process of printing.
	println("After,  *resp.V=", *resp.V)
	if got, want := *resp.V, int32(42); got != want {
		fmt.Printf("FAIL, got %v, want %v", got, want)
	}

	// remove trailing blank lines
	b := pr.Bytes()
	for len(b) > 0 && b[len(b)-1] == '\n' && (len(b) == 1 || b[len(b)-2] == '\n') {
		b = b[:len(b)-1]
	}
	return b
}

// A printer collects the state during printing of a file or expression.
type printer struct {
	bytes.Buffer           // output buffer
	comment      []Comment // pending end-of-line comments
	margin       int       // left margin (indent), a number of tabs
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.problems.failure;

/**
 * Listener for steps in the process of printing a failure by {@link FailurePrinter}.
 */
public interface FailurePrinterListener {

    FailurePrinterListener NO_OP = new FailurePrinterListener() {
        @Override
        public void beforeFrames() {}

  # expansions and subshells
  set -o errtrace
}

# Print out the stack trace
#
# Args:
#   $1 The number of stack frames to skip when printing.
kube::log::stack() {
  local stack_skip=${1:-0}
  stack_skip=$((stack_skip + 1))
  if [[ ${#FUNCNAME[@]} -gt ${stack_skip} ]]; then
    echo "Call stack:" >&2
    local i

 *   workingDir '../tomcat/bin'
 *
 *   //on windows:
 *   commandLine 'cmd.exe', '/d', '/c', 'stop.bat'
 *
 *   //on linux
 *   commandLine './stop.sh'
 *
 *   //store the output instead of printing to the console:
 *   standardOutput = new ByteArrayOutputStream()
 *
 *   //extension method stopTomcat.output() can be used to obtain the output:
 *   ext.output = {
 *     return standardOutput.toString()
 *   }

     * messages appear for loading the source files, generating the documentation (one message per source file), and sorting.
     * The verbose option causes the printing of additional messages specifying the number of milliseconds to parse each java source file.
     */
    VERBOSE,
    /**
     * -quiet
     *

 * limitations under the License.
 */

package org.gradle.tooling.events.test;

import org.gradle.tooling.events.ProgressEvent;

/**
 * An event that informs about a test printing text to the standard output or to the standard error.
 * <p>
 * A new test output event instance is created for each line of text printed by the test.
 *
 * @since 6.0
 */

import org.gradle.internal.DeprecatedInGradleScope;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

/**
 * Listens to the output events like printing to standard output or error
 */
@EventScope(Scope.Build.class)
@DeprecatedInGradleScope
public interface TestOutputListener {

    /**

/*
Package fmt implements formatted I/O with functions analogous
to C's printf and scanf.  The format 'verbs' are derived from C's but
are simpler.

# Printing

The verbs:

General:

	%v	the value in a default format
		when printing structs, the plus flag (%+v) adds field names
	%#v	a Go-syntax representation of the value
		(floating-point infinities and NaNs print as ±Inf and NaN)

// TypeString returns the string representation of typ.
// The [Qualifier] controls the printing of
// package-level objects, and may be nil.
func TypeString(typ Type, qf Qualifier) string {
	var buf bytes.Buffer
	WriteType(&buf, typ, qf)
	return buf.String()
}

// WriteType writes the string representation of typ to buf.
// The [Qualifier] controls the printing of
// package-level objects, and may be nil.