KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = consume(a + b)
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null
  valuedReturnExpressions = []

}


private
fun <T> Collection<T>.matchesPairwise(other: Collection<T>, pairMatches: (T, T) -> Boolean): Boolean =

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = consume(a - b)
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return 0
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return 0
  ]

                includeBuild 'includedBuild1'
                includeBuild 'includedBuild2'
            """
        def inc1 = multiProjectBuildInSubFolder("includedBuild1", ["a", "b", "c"])
        def inc2 = multiProjectBuildInSubFolder("includedBuild2", ["a", "b", "c"])
        def workspace = eclipseWorkspace([
            project("root", projectDir), gradleProject("a"), project("explicitName", file("b")),
            externalProject("root-a"),

	}{
		{
			name: "no transition",
			in: map[string][]string{
				"a": {"b"},
				"c": {"d"},
			},
			expected: map[string][]string{
				"a": {"b"},
				"c": {"d"},
			},
		},
		{
			name: "simple",
			in: map[string][]string{
				"a": {"b"},
				"b": {"c"},
				"c": {"d"},
			},
			expected: map[string][]string{
				"a": {"b", "c", "d"},
				"b": {"c", "d"},
				"c": {"d"},
			},
		},
	}

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = if (a - b > 0) continue@loop1
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = true
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break@loop2,
    continue@loop1
  ]
  returnValueType = null
  valuedReturnExpressions = []

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

        model.findThing("child").is(model.thing)
    }

    def "retains underlying object identity in model returned to client via build action"() {
        settingsFile << "include 'a', 'b'"

        when:
        CustomModel model = withConnection { connection ->
            connection.action(new CustomModelBuildingAction()).run()
        }

        then:
        model.thing.is(model.thing)

		for mname, method := range svc.method {
			ds.Method = append(ds.Method, debugMethod{method, mname})
		}
		slices.SortFunc(ds.Method, func(a, b debugMethod) int {
			return strings.Compare(a.Name, b.Name)
		})
		services = append(services, ds)
		return true
	})
	slices.SortFunc(services, func(a, b debugService) int {
		return strings.Compare(a.Name, b.Name)
	})
	err := debug.Execute(w, services)
	if err != nil {

        models[":"][0].message == "fetch1 It works from project :"
    }

    def "parameterized models are reused for other projects when one project is reconfigured"() {
        ["a", "b"].forEach {
            settingsFile << """
                include("$it")
            """
            file("$it/build.gradle") << """
                plugins.apply(my.MyPlugin)