const never = "function did"

func unreachable() {
	panic("control flow shouldn't reach here")
}

// Calls f and verifies that f always/never panics depending on signal.
func testPanic(signal string, f func()) {
	defer func() {
		s := never
		if recover() != nil {
			s = always // f panicked
		}
		if s != signal {
			panic(signal + " panic")
		}
	}()
	f()
}

# 'go test -json' should say a test fails if it exits 1 and prints nothing.
! go test -json ./exit1main
stdout '"Action":"fail".*\n\z'
! stdout '"Test":.*\n\z'

# 'go test -json' should say a test fails if it panics.
! go test -json ./panic
stdout '"Action":"fail".*\n\z'
! stdout '"Test":.*\n\z'

-- go.mod --
module example.com/test

go 1.14

-- pass/pass_test.go --
package pass_test

import "testing"

// them from genuine panics which we don't want to return as errors.
type writeError struct {
	err error
}

// printf is a convenience wrapper that takes care of print errors.
func (p *dumper) printf(format string, args ...interface{}) {
	if _, err := fmt.Fprintf(p, format, args...); err != nil {
		panic(writeError{err})
	}
}

// dump prints the contents of x.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that incorrect expressions involving wrong anonymous interface
// do not generate panics in Type Stringer.
// Does not compile.

package main

type I interface {
	int // ERROR "interface contains embedded non-interface|embedding non-interface type int requires"
}

func n() {

			ret = debugCallUnsafePoint
		}
	})
	return ret
}

// debugCallWrap starts a new goroutine to run a debug call and blocks
// the calling goroutine. On the goroutine, it prepares to recover
// panics from the debug call, and then calls the call dispatching
// function at PC dispatch.
//
// This must be deeply nosplit because there are untyped values on the
// stack from debugCallV2.
//
//go:nosplit

// compile

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 19515: compiler panics on spilling int128 constant.

package x

type VScrollPanel struct {
	x, y int
}

type Color struct {
	R, G, B, A float32
}

func maxF(a, b float32) float32 {
	if a > b {
		return 0
	}
	return 1
}

// delivering events to related channel.
type FileWatcher interface {
	// Start watching a path. Calling Add multiple times on the same path panics.
	Add(path string) error

	// Stop watching a path. Removing a path that's not currently being watched panics.
	Remove(path string) error
	Close() error
	Events(path string) chan fsnotify.Event
	Errors(path string) chan error
}

type fileWatcher struct {

// StringByteSlice converts a string to a NUL-terminated []byte,
// If s contains a NUL byte this function panics instead of
// returning an error.
//
// Deprecated: Use ByteSliceFromString instead.
func StringByteSlice(s string) []byte {
	a, err := ByteSliceFromString(s)
	if err != nil {
		panic("syscall: string with NUL passed to StringByteSlice")
	}
	return a
}

			os.Exit(1)
		}
		outC <- buf.String()
	}()

	finished := false
	start := time.Now()

	// Clean up in a deferred call so we can recover if the example panics.
	defer func() {
		timeSpent := time.Since(start)

		// Close pipe, restore stdout, get output.
		w.Close()
		os.Stdout = stdout
		out := <-outC

		err := recover()

			},
			{
				mode:     "goodexit",
				expected: "orange apple",
			},
			{
				mode:     "badexit",
				expected: "blub blix",
			},
			{
				mode: "panics",
				musthave: []string{
					"fatal error: exit hook invoked panic",
					"main.testPanics",
				},
			},
			{
				mode: "callsexit",
				musthave: []string{
					"fatal error: exit hook invoked exit",
				},
			},
			{