fun foo(a: Int): Int {
    val b: Int = 1
    return when (a + b) {
        <expr>0</expr> -> b
        1 -> -b
        else -> a - b
    }

stdout example.com/b
! stdout example.com/c

-- overlay.json --
{"Replace": {"go.work": "overlaywork"}}
-- overlaywork --
use (
    ./a
    ./b
)
-- go.work.non-overlay --
use (
    ./a
    ./b
    ./c
)
-- a/go.mod --
module example.com/a
-- b/go.mod --
module example.com/b
-- c/go.mod --

	type Person struct {
		Name string
		Age  int
	}
	people := []Person{
		{"Alice", 55},
		{"Bob", 24},
		{"Gopher", 13},
	}
	n, found := slices.BinarySearchFunc(people, Person{"Bob", 0}, func(a, b Person) int {
		return strings.Compare(a.Name, b.Name)
	})
	fmt.Println("Bob:", n, found)
	// Output:
	// Bob: 1 true
}

func ExampleCompact() {
	seq := []int{0, 1, 1, 2, 3, 5, 8}
	seq = slices.Compact(seq)

        def model = fetchModel(GradleProject)

        then:
        model.name == "root"
        model.children.name == ["a", "b"]

        and:
        fixture.assertStateStored {
            projectsConfigured(":", ":a", ":b")
            modelsCreated(":", 2)
            modelsCreated(":a", ":b")
        }
    }

    private void addConventionPluginImplementation(String targetBuildName, String className) {

fun foo(a: Int) {
    val b: Int = 1
    for (n in 1..b) {
        <expr>if (a > 0) throw Exception("")
        if (a + b > 0) break
        consume(a - b)
        return</expr>
    }

    consume("after")
}

	for iter.Next() {
		sorted = append(sorted, KeyValue{iter.Key(), iter.Value()})
	}
	slices.SortStableFunc(sorted, func(a, b KeyValue) int {
		return compare(a.Key, b.Key)
	})
	return sorted
}

// compare compares two values of the same type. It returns -1, 0, 1
// according to whether a > b (1), a == b (0), or a < b (-1).
// If the types differ, it returns -1.
// See the comment on Sort for the comparison rules.

fun foo(a: Int) {
    val b: Int = 1
    loop1@ for (p in 1..b) {
        loop2@ for (n in 1..b) {
            <expr>if (a > 0) throw Exception("")
            if (a + b > 0) break@loop2
            if (a - b > 0) continue@loop1</expr>
        }
    }

	"/":           "/",
	"/abc":        "/",
	"/abc/":       "/abc",
	"/abc/xyz":    "/abc",
	"/abc/xyz/":   "/abc/xyz",
	"/a/b/c.html": "/a/b",
	"":            "/",
	"strange":     "/",
	"//":          "/",
	"/a//b":       "/a/",
	"/a/./b":      "/a/.",
	"/a/../b":     "/a/..",
}

func TestDefaultPath(t *testing.T) {
	for path, want := range defaultPathTests {

        rootProject.name = 'root'
        include ':a', ':b'
        """
    }

    def "Included builds are deduplicated"() {
        given:
        settingsFile << """
                includeBuild 'includedBuild1'
                includeBuild 'includedBuild2'
            """
        multiProjectBuildInSubFolder("includedBuild1", ["a", "b", "c"])
        multiProjectBuildInSubFolder("includedBuild2", ["a", "b", "c"])

  defaultExpressionInfo = null
  hasEscapingJumps = false
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return a + b
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return a + b
  ]