var int32s = []int32{1, 10, 32, 1 << 20, 1<<20 + 1, 1000000000, 1 << 30, 1<<31 - 2, 1<<31 - 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 permSizes = []int{0, 1, 5, 8, 9, 10, 16}

var readBufferSizes = []int{1, 7, 8, 9, 10}

r := New(NewSource(0))

rv := reflect.ValueOf(r)

n := rv.NumMethod()

p := 0

if *printgolden {

fmt.Printf("var regressGolden = []interface{}{\n")

}

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

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

mv := rv.Method(i)

mt := mv.Type()

if mt.NumOut() == 0 {

continue

}

r.Seed(0)

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 {

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

if *printgolden {

fmt.Printf("\tskipped, // must run printgolden on 64-bit machine\n")

}

p++

continue

}

x = int(big)

case reflect.Int32:

x = int32s[repeat%len(int32s)]

case reflect.Int64:

x = int64s[repeat%len(int64s)]

case reflect.Slice:

if m.Name == "Read" {

n := readBufferSizes[repeat%len(readBufferSizes)]

x = make([]byte, n)

}

}

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 == "Read" {

out = args[0].Interface().([]byte)

}

if *printgolden {

var val string

big := int64(1 << 60)

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

// 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.Printf("\t%s, // %s(%s)\n", val, m.Name, argstr)

} else {

want := regressGolden[p]

if m.Name == "Int" {

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

}

if !reflect.DeepEqual(out, want) {

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

}

}

p++

}

}

if *printgolden {

fmt.Printf("}\n")

}