var int32s = []int32{1, 10, 32, 1 << 20, 1<<20 + 1, 1000000000, 1 << 30, 1<<31 - 2, 1<<31 - 1}

var uint32s = []uint32{1, 10, 32, 1 << 20, 1<<20 + 1, 1000000000, 1 << 30, 1<<31 - 2, 1<<31 - 1, 1<<32 - 2, 1<<32 - 1}

var int64s = []int64{1, 10, 32, 1 << 20, 1<<20 + 1, 1000000000, 1 << 30, 1<<31 - 2, 1<<31 - 1, 1000000000000000000, 1 << 60, 1<<63 - 2, 1<<63 - 1}

var uint64s = []uint64{1, 10, 32, 1 << 20, 1<<20 + 1, 1000000000, 1 << 30, 1<<31 - 2, 1<<31 - 1, 1000000000000000000, 1 << 60, 1<<63 - 2, 1<<63 - 1, 1<<64 - 2, 1<<64 - 1}

var permSizes = []int{0, 1, 5, 8, 9, 10, 16}

n := reflect.TypeOf(New(NewPCG(1, 2))).NumMethod()

p := 0

var buf bytes.Buffer

if *update {

fmt.Fprintf(&buf, "var regressGolden = []any{\n")

}

for i := 0; i < n; i++ {

if *update && i > 0 {

fmt.Fprintf(&buf, "\n")

}

r := New(NewPCG(1, 2))

rv := reflect.ValueOf(r)

m := rv.Type().Method(i)

mv := rv.Method(i)

mt := mv.Type()

if mt.NumOut() == 0 {

continue

}

for repeat := 0; repeat < 20; repeat++ {

var args []reflect.Value

var argstr string

if mt.NumIn() == 1 {

var x any

switch mt.In(0).Kind() {

default:

t.Fatalf("unexpected argument type for r.%s", m.Name)

case reflect.Int:

if m.Name == "Perm" {

x = permSizes[repeat%len(permSizes)]

break

}

big := int64s[repeat%len(int64s)]

if int64(int(big)) != big {

// On 32-bit machine.

// Consume an Int64 like on a 64-bit machine,

// to keep the golden data the same on different architectures.

r.Int64N(big)

if *update {

t.Fatalf("must run -update on 64-bit machine")

}

p++

continue

}

x = int(big)

case reflect.Uint:

if m.Name == "Uint" {

continue

}

big := uint64s[repeat%len(uint64s)]

if uint64(uint(big)) != big {

r.Uint64N(big) // what would happen on 64-bit machine, to keep stream in sync

if *update {

t.Fatalf("must run -update on 64-bit machine")

}

p++

continue

}

x = uint(big)

case reflect.Int32:

x = int32s[repeat%len(int32s)]

case reflect.Int64:

x = int64s[repeat%len(int64s)]

case reflect.Uint32:

x = uint32s[repeat%len(uint32s)]

case reflect.Uint64:

x = uint64s[repeat%len(uint64s)]

}

argstr = fmt.Sprint(x)

args = append(args, reflect.ValueOf(x))

}

var out any

out = mv.Call(args)[0].Interface()

if m.Name == "Int" || m.Name == "IntN" {

out = int64(out.(int))

}

if m.Name == "Uint" || m.Name == "UintN" {

out = uint64(out.(uint))

}

if *update {

var val string

big := int64(1 << 60)

if int64(int(big)) != big && (m.Name == "Int" || m.Name == "IntN" || m.Name == "Uint" || m.Name == "UintN") {

// 32-bit machine cannot print 64-bit results

val = "truncated"

} else if reflect.TypeOf(out).Kind() == reflect.Slice {

val = fmt.Sprintf("%#v", out)

} else {

val = fmt.Sprintf("%T(%v)", out, out)

}

fmt.Fprintf(&buf, "\t%s, // %s(%s)\n", val, m.Name, argstr)

} else if p >= len(regressGolden) {

t.Errorf("r.%s(%s) = %v, missing golden value", m.Name, argstr, out)

} else {

want := regressGolden[p]

if m.Name == "Int" {

want = int64(int(uint(want.(int64)) << 1 >> 1))

}

if m.Name == "Uint" {

want = uint64(uint(want.(uint64)))

}

if !reflect.DeepEqual(out, want) {

t.Errorf("r.%s(%s) = %v, want %v", m.Name, argstr, out, want)

}

}

p++

}

}

if *update {

replace(t, "regress_test.go", buf.Bytes())

}

if !*update {

t.Skip("-update not given")

}

oldStdout := os.Stdout

defer func() {

os.Stdout = oldStdout

}()

r, w, err := os.Pipe()

if err != nil {

t.Fatal(err)

}

defer r.Close()

defer w.Close()

go func() {

os.Stdout = w

Example_rand()

os.Stdout = oldStdout

w.Close()

}()

out, err := io.ReadAll(r)

if err != nil {

t.Fatal(err)

}

var buf bytes.Buffer

fmt.Fprintf(&buf, "\t// Output:\n")

for _, line := range strings.Split(string(out), "\n") {

if line != "" {

fmt.Fprintf(&buf, "\t// %s\n", line)

}

}

replace(t, "example_test.go", buf.Bytes())

// Exit so that Example_rand cannot fail.

fmt.Printf("UPDATED; ignore non-zero exit status\n")

os.Exit(1)

first, _, _ := bytes.Cut(new, []byte("\n"))

first = append(append([]byte("\n"), first...), '\n')

data, err := os.ReadFile(file)

if err != nil {

t.Fatal(err)

}

i := bytes.Index(data, first)

if i < 0 {

t.Fatalf("cannot find %q in %s", first, file)

}

j := bytes.Index(data[i+1:], []byte("\n}\n"))

if j < 0 {

t.Fatalf("cannot find end in %s", file)

}

data = append(append(data[:i+1:i+1], new...), data[i+1+j+1:]...)

data, err = format.Source(data)

if err != nil {

t.Fatal(err)

}

if err := os.WriteFile(file, data, 0666); err != nil {

t.Fatal(err)

}