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

            projectsConfigured(":", ":a", ":b")
            problem("Build file 'a/build.gradle.kts': Project ':a' cannot access 'Project.buildDir' functionality on subprojects of project ':'", 2)
        }
    }

    def "build script can query basic details of projects in a function called from allprojects block"() {
        createDirs("a", "b")
        settingsFile << """
            rootProject.name = "root"

def IsNull : Constraint<CPred<"!$0">>;

// This pattern optimizes:
//   conv/dot_general + a + b -> conv/dot_general + (a + b)
//   conv/dot_general - a - b -> conv/dot_general - (a + b)
//   conv/dot_general + a - b -> conv/dot_general + (a - b)
//   conv/dot_general - a + b -> conv/dot_general - (a - b)
foreach OpsTuple = [
    [CHLO_BroadcastAddOp, CHLO_BroadcastAddOp, CHLO_BroadcastAddOp],

func TestSplitWithEmptyPart(t *testing.T) {
	expected := []string{
		"a",
		"b",
	}

	cases := []struct {
		name string
		doc  string
	}{
		{
			name: "beginningNoCR",
			doc: `---
a
---
b
`,
		},
		{
			name: "beginningWithCR",
			doc: `
---
a
---
b
`,
		},
		{
			name: "middle",
			doc: `a
---
---
b
`,
		},
		{
			name: "end",
			doc: `
a
---

        where:
        expectedLines           | actualLines                               | matchBegins    || contextBody

        // Single Mismatches
        ["a", "b", "c"]         | ["a", "b", "d"]                           | 0              || [" [     1: a",
                                                                                                 "       2: b",

import spock.lang.Issue

class EclipseTestConfigurationsWithProjectDependenciesIntegrationTest extends AbstractEclipseTestSourcesIntegrationTest {

    def setup() {
        settingsFile << "include 'a', 'b'"
        file('a/build.gradle') << """
            plugins {
                id 'eclipse'
                id 'java-library'
            }
        """
        file('b/build.gradle') << """
            plugins {

type B[P any] struct{}
type _[P interface{}] struct{}
type _[P B] struct{}
type _[P B[P]] struct{}

type _[A, B, C any] struct{}
type _[A, B, C B] struct{}
type _[A, B, C B[A, B, C]] struct{}
type _[A1, A2 B1, A3 B2, A4, A5, A6 B3] struct{}

type _[A interface{}] struct{}
type _[A, B interface{ m() }] struct{}

type _[A, B, C any] struct{}

// in functions
func _[P any]()
func _[P interface{}]()
func _[P B]()

	}

	b = NewString("1", "2", "")
	if a.Equal(b) {
		t.Errorf("Expected to be not-equal: %v vs %v", a, b)
	}

	// Check for equality after mutation
	a = NewString()
	a.Insert("1")
	if a.Equal(b) {
		t.Errorf("Expected to be not-equal: %v vs %v", a, b)
	}

	a.Insert("2")
	if a.Equal(b) {
		t.Errorf("Expected to be not-equal: %v vs %v", a, b)
	}

	a.Insert("")

-- input --
✦

Almost a+heading

✦

Don't be a heading

✦

A.b is a heading

✦

A. b is not a heading

✦
-- gofmt --
✦

Almost a+heading

✦

Don't be a heading

✦

# A.b is a heading

✦

A. b is not a heading

    }

    public static void assertCanCallMethods (ExtensibleDynamicObjectTest.Bean bean) {
        assertEquals(bean.javaMethod('a', 'b'), 'java:a.b')
        assertTrue(bean.hasMethod('conventionMethod', 'a', 'b'))
        assertEquals(bean.conventionMethod('a', 'b'), 'convention:a.b')
    }

    public static void decorateGroovyBean(bean) {
        Map values = [:]