public class FooServerTest {
                @Test
                public void testFooServer() { }
            }
        """
        file("src/test/java/BarTest.java") << """
            ${testFrameworkImports}
            public class BarTest {
                @Test
                public void testBar() { }
            }
        """
        file("src/test/java/AllFooTests.java") << """

        assert suiteTestTestOps*.details.testDescriptor.name == ["fail", "ok", "anotherOk"]
        assert suiteTestTestOps*.details.testDescriptor.className == ["org.gradle.FooTest", "org.gradle.FooTest", "org.gradle.BarTest"]
        assert suiteTestTestOps*.details.testDescriptor.composite == [false, false, false]

        def testOutput = suiteTestTestOps[1].progress
        assert testOutput.size() == 2

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.tasks.bundling

class TarTest extends AbstractArchiveTaskTest {
    Tar tar

    def setup()  {
        tar = createTask(Tar)
        configure(tar)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        tar
    }

package org.gradle.api.tasks.bundling

import org.gradle.api.Action
import org.gradle.api.file.CopySpec
import org.gradle.api.plugins.JavaBasePlugin
import org.gradle.test.fixtures.archive.JarTestFixture

class WarTest extends AbstractArchiveTaskTest {
    War war

    def setup() {
        war = createTask(War)
        configure(war)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        war
    }

import org.gradle.api.tasks.bundling.AbstractArchiveTask
import org.gradle.api.tasks.bundling.AbstractArchiveTaskTest
import org.gradle.test.fixtures.archive.JarTestFixture

class JarTest extends AbstractArchiveTaskTest {
    Jar jar

    def setup() {
        jar = createTask(Jar)
        configure(jar)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        jar
    }

import org.gradle.plugins.ear.descriptor.EarSecurityRole
import org.gradle.plugins.ear.descriptor.internal.DefaultDeploymentDescriptor
import org.gradle.test.fixtures.archive.JarTestFixture

class EarTest extends AbstractArchiveTaskTest {
    Ear ear

    def setup() {
        ear = createTask(Ear)
        configure(ear)
        // This would normally be set by the EarPlugin
        ear.libDirName = "lib"
    }

func main() {
	i3 := &_List[int]{nil, 1}
	i2 := &_List[int]{i3, 3}
	i1 := &_List[int]{i2, 2}
	if got, want := i1.Largest(), 3; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	b3 := &_List[byte]{nil, byte(1)}
	b2 := &_List[byte]{b3, byte(3)}
	b1 := &_List[byte]{b2, byte(2)}
	if got, want := b1.Largest(), byte(3); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

func main() {
	i3 := &a.List[int]{nil, 1}
	i2 := &a.List[int]{i3, 3}
	i1 := &a.List[int]{i2, 2}
	if got, want := i1.Largest(), 3; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	b3 := &a.List[byte]{nil, byte(1)}
	b2 := &a.List[byte]{b3, byte(3)}
	b1 := &a.List[byte]{b2, byte(2)}
	if got, want := b1.Largest(), byte(3); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	assert("\\x\\u\\U\\", `\x\u\U\`, "backslash 3 (backquote)")

	// test large and surrogate-half runes. perhaps not the most logical place for these tests.
	var r int32
	r = 0x10ffff // largest rune value
	s = string(r)
	assert(s, "\xf4\x8f\xbf\xbf", "largest rune")
	r = 0x10ffff + 1
	s = string(r)
	assert(s, "\xef\xbf\xbd", "too-large rune")
	r = 0xD800
	s = string(r)
	assert(s, "\xef\xbf\xbd", "surrogate rune min")
	r = 0xDFFF

		~float32 | ~float64 |
		~string
}

// List is a linked list of ordered values of type T.
type List[T Ordered] struct {
	Next *List[T]
	Val  T
}

func (l *List[T]) Largest() T {
	var max T
	for p := l; p != nil; p = p.Next {
		if p.Val > max {
			max = p.Val
		}
	}
	return max
}

type OrderedNum interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |