return
        }
        // TODO remove debug log
        if (lastRegistryState == State.Stopped && lastLogState == State.Idle) {
            println("The daemon probably disappeared before it could've printed the stop message. Daemon log content:")
            println(logFile.text)
        }

        throw new AssertionError("""Timeout waiting for daemon with pid ${context.pid} to reach state ${state}.

		}
	}
	return true
}

// valueDoc prints the docs for a constant or variable. The printed map records
// which values have been printed already to avoid duplication. Otherwise, a
// declaration like:
//
//	const ( c = 1; C = 2 )
//
// … could be printed twice if the -u flag is set, as it matches twice.
func (pkg *Package) valueDoc(value *doc.Value, printed map[*ast.GenDecl]bool) {
	if printed[value.Decl] {
		return

		Uses:  make(map[*syntax.Name]types2.Object),
	}
	pkg := mustTypecheck(input, nil, &info)

	// Print package-level variables in initialization order.
	fmt.Printf("InitOrder: %v\n\n", info.InitOrder)

	// For each named object, print the line and
	// column of its definition and each of its uses.
	fmt.Println("Defs and Uses of each named object:")
	usesByObj := make(map[types2.Object][]string)
	for id, obj := range info.Uses {

	   c3c
	*/
	/* foo
	   c3d
	*/
	/*
	   c3e
	   foo */
	/*
	   c3f
	   foo */
}

// Test case taken literally from issue 1835.
func main() {
	/*
	   prints test 5 times
	*/
	for i := 0; i < 5; i++ {
		println("test")
	}
}

func issue5623() {
L:
	_ = yyyyyyyyyyyyyyyy			// comment - should be aligned
	_ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx	/* comment */

*/
/* foo
c3c
*/
/* foo
   c3d
*/
/*
c3e
foo */
/*
   c3f
   foo */
}

// Test case taken literally from issue 1835.
func main() {
/*
prints test 5 times
*/
   for i := 0; i < 5; i++ {
      println("test")
   }
}

func issue5623() {
L:
   _ = yyyyyyyyyyyyyyyy // comment - should be aligned
   _ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx /* comment */

  {{.Name}} - {{.Usage}}

USAGE:
  {{.Name}} {{if .VisibleFlags}}[FLAGS]{{end}} [HEALINGBINFILE|INSPECTZIPFILE]

files ending in '.zip' will be searched for '.healing.bin files recursively and
printed together as a single JSON.

FLAGS:
  {{range .VisibleFlags}}{{.}}
  {{end}}
`
	app.Flags = []cli.Flag{}
	app.Action = func(c *cli.Context) error {
		if !c.Args().Present() {

	printer, err := NewGoTemplatePrinter([]byte(tmpl))
	if err != nil {
		t.Fatalf("tmpl fail: %v", err)
	}
	buffer := &bytes.Buffer{}
	err = printer.PrintObj(&v1.Pod{}, buffer)
	if err == nil {
		t.Fatalf("expected that template to crash")
	}
	if buffer.String() == "" {
		t.Errorf("no debugging info was printed")
	}
}

func TestTemplateSuccess(t *testing.T) {

    def setup() {
        blockingHttpServer.start()
        if (OperatingSystem.current().windows) {
            // The killed worker on Windows will cause a broken pipe error to be printed to the console,
            // so we disable stack trace checks to avoid the test failing.
            executer.withStackTraceChecksDisabled()
        }

        settingsFile << """

	// src.go:4:9:	f
	// src.go:4:11:	3.14
	// src.go:4:17:	2
	// src.go:4:21:	c
}

// This example shows what an AST looks like when printed for debugging.
func ExamplePrint() {
	// src is the input for which we want to print the AST.
	src := `
package main
func main() {
	println("Hello, World!")
}
`

	// Create the AST by parsing src.
	fset := token.NewFileSet() // positions are relative to fset

	if mode&export != 0 {
		ast.FileExports(f) // ignore result
		f.Comments = nil   // don't print comments that are not in AST
	}

	// determine printer configuration
	cfg := Config{Tabwidth: tabwidth}
	if mode&rawFormat != 0 {
		cfg.Mode |= RawFormat
	}
	if mode&normNumber != 0 {
		cfg.Mode |= normalizeNumbers
	}

	// print AST
	var buf bytes.Buffer
	if err := cfg.Fprint(&buf, fset, f); err != nil {