* limitations under the License.
 */

// tag::verification-failure[]
val process = tasks.register("process") {
    val outputFile = layout.buildDirectory.file("processed.log")
    outputs.files(outputFile) // <1>

    doLast {
        val logFile = outputFile.get().asFile
        logFile.appendText("Step 1 Complete.") // <2>
        throw VerificationException("Process failed!") // <3>

 */
public interface ModelBuildingListener {

    /**
     * Notifies the listener that the model has been constructed to the extent where build extensions can be processed.
     *
     * @param event The details about the event.
     */
    default void buildExtensionsAssembled(ModelBuildingEvent event) {}

// when we have processed all items added to the queue prior to Run().
type syncSignal struct{}

// defaultSyncSignal is a singleton instanceof syncSignal.
var defaultSyncSignal = syncSignal{}

// HasSynced returns true if the queue has 'synced'. A synced queue has started running and has
// processed all events that were added prior to Run() being called Warning: these items will be

	// +optional
	ObservedGeneration int64

	// DisruptedPods contains information about pods whose eviction was
	// processed by the API server eviction subresource handler but has not
	// yet been observed by the PodDisruptionBudget controller.
	// A pod will be in this map from the time when the API server processed the
	// eviction request to the time when the pod is seen by PDB controller

	ngo     = flag.Int("n", runtime.NumCPU(), "number of goroutines used")
	verbose = flag.Bool("verbose", false, "verbose mode")
	nfiles  int // number of files processed
)

func gofmt(fset *token.FileSet, filename string, src *bytes.Buffer) error {
	f, _, _, err := parse(fset, filename, src.Bytes(), false)
	if err != nil {
		return err
	}
	ast.SortImports(fset, f)

import org.gradle.api.logging.Logging;
import org.gradle.launcher.daemon.server.api.DaemonCommandAction;
import org.gradle.launcher.daemon.server.api.DaemonCommandExecution;

/**
 * Install a handler for cancel request processed asynchronously while the daemon proceeds to build execution.
 */
public class HandleCancel implements DaemonCommandAction {
    private static final Logger LOGGER = Logging.getLogger(HandleCancel.class);

    @Override

    /**
     * Processes "shallow" metadata, only for selecting a version. This metadata is typically
     * provided by a custom metadata processor.
     * @param metadata the metadata to be processed
     * @return updated metadata, if any component metadata rule applies.
     */
    ComponentMetadata processMetadata(ComponentMetadata metadata);

    int getRulesHash();

func IndexString(a, b string) int {
	panic("unimplemented")
}

// Cutover reports the number of failures of IndexByte we should tolerate
// before switching over to Index.
// n is the number of bytes processed so far.
// See the bytes.Index implementation for details.
func Cutover(n int) int {
	panic("unimplemented")

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

// tag::verification-failure[]
tasks.register("process") {
    def outputFile = layout.buildDirectory.file("processed.log")
    outputs.files(outputFile) // <1>

    doLast {
        def logFile = outputFile.get().asFile
        logFile << "Step 1 Complete." // <2>
        throw new VerificationException("Process failed!") // <3>

(in-package) _test.go files. Use -x to type check only external
test files.

Otherwise, each path must be the filename of a Go file belonging
to the same package.

Imports are processed by importing directly from the source of
imported packages (default), or by importing from compiled and
installed packages (by setting -c to the respective compiler).