abstract Matcher<? super String>[] getBrokenBeforeAndAfterMatchers()
    abstract boolean hasStableInitializationErrors()

    def "reports and breaks build when tests fail"() {
        given:
        file('src/test/java/org/gradle/BrokenAfter.java') << """
            package org.gradle;

            ${testFrameworkImports}

            public class BrokenAfter {
                ${afterTestAnnotation}

        source "class A {}", "class B extends A {}"
        file("src/integTest/${languageName}/X.${languageName}") << "class X {}"
        file("src/integTest/${languageName}/Y.${languageName}") << "class Y extends X {}"
        //new separate compile task (integTestCompile)
        file("build.gradle") << """
            sourceSets { integTest.${languageName}.srcDir "src/integTest/${languageName}" }
        """

[.multi-language-sample]
=====
[source, kotlin]
----
.
├── buildSrc
│   ├── src
│   │   └──main
│   │      └──kotlin
│   │         └──MyCustomTask.kt    // <1>
│   ├── shared.gradle.kts   // <2>
│   └── build.gradle.kts
├── api
│   ├── src
│   │   └──...
│   └── build.gradle.kts    // <3>
├── services
│   └── person-service
│       ├── src
│       │   └──...
│       └── build.gradle.kts    // <3>
├── shared

// of src.
func (g *gcmAsm) counterCrypt(dst, src []byte, cnt *gcmCount) {
	// Copying src into a buffer improves performance on some models when
	// src and dst point to the same underlying array. We also need a
	// buffer for counter values.
	var ctrbuf, srcbuf [2048]byte
	for len(src) >= 16 {
		siz := len(src)
		if len(src) > len(ctrbuf) {
			siz = len(ctrbuf)
		}

                }
            """
            file("application/src/main/java/application/Adder.java").java """
                package application;

                public class Adder {
                    int add(int x, int y) {
                        return x+y;
                    }
                }
            """
            file("application/src/test/java/application/AdderTest.java").java """

    }

    def "supports app dir"() {
        given:
        project.file("src/main/application/META-INF").mkdirs()
        project.file("src/main/application/META-INF/test.txt").createNewFile()
        project.file("src/main/application/test2.txt").createNewFile()

        when:
        project.pluginManager.apply(EarPlugin)

        and:

        outputContains(file('application/src/main/java').absolutePath)
        outputContains(file('application/src/main/resources').absolutePath)
        outputContains(file('direct/src/main/java').absolutePath)
        outputContains(file('direct/src/main/resources').absolutePath)
        outputContains(file('transitive/src/main/java').absolutePath)
        outputContains(file('transitive/src/main/resources').absolutePath)
    }

			t.Run(name, func(t *testing.T) {
				// Use overlapping src and dst to force forward/backward copy.
				var s [100]*int
				src := s[n-1 : 2*n-1]
				dst := s[:n]
				if backward {
					src, dst = dst, src
				}
				for i := range src {
					src[i] = &x
				}
				clear(dst)

				var ready atomic.Uint32
				go func() {
					sp := unsafe.Pointer(&src[0])
					dp := unsafe.Pointer(&dst[0])

        createSimpleJupiterTest()
        file('src/test/java/UninstantiableExtension.java') << '''
import org.junit.jupiter.api.extension.*;
public class UninstantiableExtension implements BeforeEachCallback {
  private UninstantiableExtension(){}

  @Override
  public void beforeEach(final ExtensionContext context) throws Exception {
  }
}
'''

	(MOVHstore [2] dst (MOVHload [2] src mem)
		(MOVHstore dst (MOVHload src mem) mem))
(Move [4] dst src mem) =>
	(MOVBstore [3] dst (MOVBload [3] src mem)
		(MOVBstore [2] dst (MOVBload [2] src mem)
			(MOVBstore [1] dst (MOVBload [1] src mem)
				(MOVBstore dst (MOVBload src mem) mem))))
(Move [8] {t} dst src mem) && t.Alignment()%8 == 0 =>
	(MOVVstore dst (MOVVload src mem) mem)
(Move [8] {t} dst src mem) && t.Alignment()%4 == 0 =>