The benefit of raising an exception over `return`ing a value will be more evident in the section about Dependencies and Security.

// If nil, those options are reported as invalid options.
// If DebugSSA returns a non-empty string, that text is reported as a compiler error.
// If phase is "help", it should print usage information and terminate the process.
type DebugSSA func(phase, flag string, val int, valString string) string

// NewDebugFlag constructs a DebugFlag for the fields of debug, which
// must be a pointer to a struct.
//

Contribution incorporated within the Work constitutes direct or contributory 
patent infringement, then any patent licenses granted to You under this 
License for that Work shall terminate as of the date such litigation is 
filed. 

4. Redistribution. You may reproduce and distribute copies of the Work or 
Derivative Works thereof in any medium, with or without modifications, and 

# When a process terminates another process, it provides an exit code.
[GOOS:windows] skip
[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# FuzzNonCrash sends itself a signal that does not appear to be a crash.
# We should not save a crasher.
! go test -fuzz=FuzzNonCrash
! exists testdata
! stdout unreachable
! stderr unreachable

		sendGarbageToCoordinator(f)
		time.Sleep(3600 * time.Second) // pause until coordinator terminates the process
	}
	f.Fuzz(func(*testing.T, []byte) {})
}

func FuzzClosePipeAfter(f *testing.F) {
	f.Fuzz(func(t *testing.T, _ []byte) {
		if isWorker() {
			sendGarbageToCoordinator(t)
			time.Sleep(3600 * time.Second) // pause until coordinator terminates the process
		}
	})
}
-- io_error_windows_test.go --
package io_error

	e.eventRecorder.Eventf(object, eventtype, reason, messageFmt, args...)
}

// Shutdown terminates the event recorder. This must be called upon completion of writing events, and events should not be
// written once terminated.
func (e *EventRecorder) Shutdown() {
	e.eventBroadcaster.Shutdown()

# TODO(jayconrod): support shared memory on more platforms.
[!GOOS:darwin] [!GOOS:linux] [!GOOS:windows] skip

# Verify that the fuzzing engine records the actual crashing input, even when
# a worker process terminates without communicating the crashing input back
# to the coordinator.

[short] skip
env GOCACHE=$WORK/cache

# Start fuzzing. The worker crashes after 100 iterations.
# The fuzz function writes the crashing input to "want" before exiting.

			// expires) and the process being forcibly terminated (via the WaitDelay
			// field), and a second one for the delay between the process being
			// terminated and the test logging its output for debugging.
			//
			// (We want to ensure that the test process itself has enough time to
			// log the output before it is also terminated.)
			cmdTimeout := testTimeout - 2*gracePeriod

			err = etcdCmd.Process.Kill()
			if err != nil {
				return fmt.Errorf("error killing etcd: %v", err)
			}
			return fmt.Errorf("timed out waiting for etcd on port %d", r.cfg.port)
		}
	}
}

// Stop terminates the etcd server process. If the etcd server process has not been started
// or is not still running, this returns an error.
func (r *EtcdMigrateServer) Stop() error {
	if r.cmd == nil {

	log.Infof("ControlZ available at %s", s.httpServer.Addr)
	if listeningTestProbe != nil {
		go listeningTestProbe()
	}
	err := s.httpServer.Serve(s.listener)
	log.Infof("ControlZ terminated: %v", err)
	s.shutdown.Done()
}

// Close terminates ControlZ.
//
// Close is not normally used by programs that expose ControlZ, it is primarily intended to be
// used by tests.
func (s *Server) Close() {
	log.Info("Closing ControlZ")