}
	for i := 0; i < 3; i++ {
		if checkVal(LINE, 3, i) <= 2 {
			check(LINE, 3)
		}
		if checkVal(LINE, 3, i) <= 1 {
			check(LINE, 2)
		}
		if checkVal(LINE, 3, i) <= 0 {
			check(LINE, 1)
		}
	}
	for i := 0; i < 3; i++ {
		if checkVal(LINE, 3, i) <= 1 {
			check(LINE, 2)
		} else {
			check(LINE, 1)
		}
	}
	for i := 0; i < 3; i++ {
		if checkVal(LINE, 3, i) <= 0 {
			check(LINE, 1)

				if err != nil {
					t.Fatalf("failed to write text value: %v", err)
				}

				checkVal, err := server.client.Get(start.version, key)
				if err != nil {
					t.Errorf("Error getting %s for validation: %v", key, err)
				}
				if checkVal != value {
					t.Errorf("Expected %s from %s but got %s", value, key, checkVal)
				}
			})

			// Migrate the servers in series.

func check(line, count uint32) {
	b := block{
		count,
		line,
	}
	counters[b] = true
}

// checkVal is a version of check that returns its extra argument,
// so it can be used in conditionals.
func checkVal(line, count uint32, val int) int {
	b := block{
		count,
		line,
	}
	counters[b] = true
	return val
}

var PASS = true

// TODO(matloob): Allow values and predecessors to be in different
// orders if the CFG are otherwise equivalent.
func Equiv(f, g *Func) bool {
	valcor := make(map[*Value]*Value)
	var checkVal func(fv, gv *Value) bool
	checkVal = func(fv, gv *Value) bool {
		if fv == nil && gv == nil {
			return true
		}
		if valcor[fv] == nil && valcor[gv] == nil {
			valcor[fv] = gv
			valcor[gv] = fv

			// Put the new element at the beginning,
			// since it is the most likely to be newly used.
			if debugCheckCache && checkPC != 0 {
				if checkVal != val || checkPC != prevpc {
					print("runtime: table value ", val, "@", prevpc, " != cache value ", checkVal, "@", checkPC, " at PC ", targetpc, " off ", off, "\n")
					throw("bad pcvalue cache")
				}
			} else {
				mp := acquirem()

My CI build tasks
-----------------
checkAll - Runs checks for all projects (CI)

My global build tasks
---------------------
qualityCheckApp - Runs checks on app (globally)
----

If we run the `:checkAll` task, we see that it compiles all the code and runs the code quality checks (including `spotbug`):

[source,text]
----
$ ./gradlew :checkAll

                checkModel(actualItem, expectedItem, specs)
            }
            return
        }

        if (expected instanceof Map) {
            assert actual instanceof Map
            checkMap(actual, expected) { actualItem, expectedItem ->
                checkModel(actualItem, expectedItem, specs)
            }
            return
        }

        for (def spec in specs) {

defaultTasks 'run'

// tag::run[]
tasks.register('run') {
    dependsOn gradle.includedBuild('my-app').task(':app:run')
}
// end::run[]

task checkAll {
    dependsOn gradle.includedBuild('my-app').task(':app:check')
    dependsOn gradle.includedBuild('my-utils').task(':number-utils:check')
    dependsOn gradle.includedBuild('my-utils').task(':string-utils:check')

// compile

// Copyright 2014 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 7346 : internal error "doasm" error due to checknil
// of a nil literal.

package main

func main() {
	_ = *(*int)(nil)

defaultTasks("run")

// tag::run[]
tasks.register("run") {
    dependsOn(gradle.includedBuild("my-app").task(":app:run"))
}
// end::run[]

tasks.register("checkAll") {
    dependsOn(gradle.includedBuild("my-app").task(":app:check"))
    dependsOn(gradle.includedBuild("my-utils").task(":number-utils:check"))
    dependsOn(gradle.includedBuild("my-utils").task(":string-utils:check"))