//go:build ignore

package main

import (
	big "."
	"fmt"
	"runtime"
)

var (
	tmp1  = big.NewInt(0)
	tmp2  = big.NewInt(0)
	numer = big.NewInt(1)
	accum = big.NewInt(0)
	denom = big.NewInt(1)
	ten   = big.NewInt(10)
)

func extractDigit() int64 {
	if big.CmpInt(numer, accum) > 0 {
		return -1
	}
	tmp1.Lsh(numer, 1).Add(tmp1, numer).Add(tmp1, accum)

	// bigN is an integer that occupies more than one big.Word.
	bigN, ok := big.NewInt(0).SetString("10000000000000000000000000000000000000000000000000000000000000000", 16)
	if !ok {
		t.Fatal("Failed to set bigN")
	}
	tests := []struct {
		n        *big.Int
		expected int
	}{
		{n: big.NewInt(int64(0)), expected: 0},
		{n: big.NewInt(int64(0xffffffffff)), expected: 40},
		{n: bigN, expected: 1},
	}

	}

	writeIfNotEqual := func(fileName string, newData []byte) error {
		if newData == nil {
			return nil
		}
		oldData, _ := os.ReadFile(path.Join(dir, fileName))
		if !bytes.Equal(oldData, newData) {
			if err := file.AtomicWrite(path.Join(dir, fileName), newData, certFileMode); err != nil {
				return fmt.Errorf("failed to write data to file %v: %v", fileName, err)
			}
		}

    private static final Set<String> VERSIONS = [
        '5.12.1', // Newest version without TestNG#setConfigFailurePolicy method (Added in 5.13)
        FIXED_ILLEGAL_ACCESS,
        BEFORE_BROKEN_PRESERVE_ORDER,
        FIXED_BROKEN_PRESERVE_ORDER,
        BROKEN_ICLASS_LISTENER,
        FIXED_ICLASS_LISTENER,
        NEWEST
    ]

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"math/big"
)

//go:noinline
func f(x uint32) *big.Int {
	return big.NewInt(int64(x))
}
func main() {
	b := f(0xffffffff)
	c := big.NewInt(0xffffffff)
	if b.Cmp(c) != 0 {
		panic(fmt.Sprintf("b:%x c:%x", b, c))
	}

			t.Errorf("1st unmarshal error: %v", err)
		}
		newData, err := json.Marshal(new1)
		if err != nil {
			t.Errorf("2st marshal error: %v", err)
		}
		if err = json.Unmarshal(newData, &new2); err != nil {
			t.Errorf("2nd unmarshal error: %v", err)
		}
		if !bytes.Equal(data, newData) {
			t.Errorf("%s: re-marshaled data differs from original: %v %v", k, data, newData)
		}
		if !reflect.DeepEqual(tc.orig, new1) {

	Z *int
}

type TI [3]uintptr

//go:noinline
func G() (t TI) {
	t[0] = 1
	t[1] = 2
	t[2] = 3
	return
}

//go:noinline
func F() (t T) {
	t.X = newint()
	t.Y = t.X
	t.Z = t.Y
	return
}

func newint() *int {
	runtime.GC()
	return nil
}

func main() {
	G() // leave non-pointers where F's return values go
	F()

        buildScript """
            apply plugin: "java"
            ${mavenCentralRepository()}
            testing {
                suites {
                    test {
                        useTestNG('${TestNGCoverage.NEWEST}')
                        targets {
                            all {
                                testTask.configure {
                                    options {

	val int
}

func (foo Foo[T]) Get() *T {
	if foo.val != 1 {
		panic("bad val field in Foo receiver")
	}
	return new(T)
}

var (
	newInt    = Foo[int]{val: 1}.Get
	newString = Foo[string]{val: 1}.Get
)

func main() {
	i := newInt()
	s := newString()

	if t := reflect.TypeOf(i).String(); t != "*int" {
		panic(t)
	}
	if t := reflect.TypeOf(s).String(); t != "*string" {
		panic(t)
	}

/**
 * Resolves conflicting artifacts by always selecting the newest declaration. Newest is defined as the
 * declaration whose version is greater according to <code>ArtifactVersion.compareTo</code>.
 *
 * @see ArtifactVersion#compareTo
 * @since 3.0
 */
@Named("newest")
@Singleton
@Deprecated
public class NewestConflictResolver implements ConflictResolver {