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 |

//	significant-byte first (network) order.
package adler32

import (
	"errors"
	"hash"
	"internal/byteorder"
)

const (
	// mod is the largest prime that is less than 65536.
	mod = 65521
	// nmax is the largest n such that
	// 255 * n * (n+1) / 2 + (n+1) * (mod-1) <= 2^32-1.
	// It is mentioned in RFC 1950 (search for "5552").
	nmax = 5552
)

// The size of an Adler-32 checksum in bytes.

type query struct {
	toURL string // the URL in the Cookies call
	want  string // the expected list of cookies (order matters)
}

// run runs the jarTest.
func (test jarTest) run(t *testing.T, jar *Jar) {
	now := tNow

	// Populate jar with cookies.
	setCookies := make([]*http.Cookie, len(test.setCookies))
	for i, cs := range test.setCookies {

			}
			m := umagic(n, int64(c)).m
			s := umagic(n, int64(c)).s

			C := new(big.Int).SetUint64(c)
			M := new(big.Int).SetUint64(m)
			M.Add(M, TwoN)

			// Find largest multiple of c.
			Mul := new(big.Int).Div(Max, C)
			Mul.Mul(Mul, C)
			mul := Mul.Uint64()

			// Try some input values, mostly around multiples of c.
			for _, x := range [...]uint64{0, 1,