KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = when {
                a + b > 0 -> break
                a - b > 0 -> break
                else -> consume(0)
            }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null

		{name: "no object", schema: &schema.Structural{}},
		{name: "list without schema",
			obj: map[string]interface{}{
				"array": []interface{}{"a", "b", "a"},
			},
		},
		{name: "list without items",
			obj: map[string]interface{}{
				"array": []interface{}{"a", "b", "a"},
			},
			schema: &schema.Structural{
				Generic: schema.Generic{
					Type: "object",
				},
				Properties: map[string]schema.Structural{

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 --

        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) {

	"/":           "/",
	"/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 {

	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.

        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
  ]

  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return b,
    return -b,
    return a - b
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return b,
    return -b,
    return a - b
  ]

	b := new(Int).SetBytes(bBytes)

	d := new(Int).GCD(x, y, a, b)
	x.Mul(x, a)
	y.Mul(y, b)
	x.Add(x, y)

	return x.Cmp(d) == 0
}

// euclidExtGCD is a reference implementation of Euclid's
// extended GCD algorithm for testing against optimized algorithms.
// Requirements: a, b > 0
func euclidExtGCD(a, b *Int) (g, x, y *Int) {
	A := new(Int).Set(a)
	B := new(Int).Set(b)

	// A = Ua*a + Va*b