delve/_fixtures/testvariables2.go

package main

import (
	"fmt"
	"go/constant"
	"math"
	"os"
	"reflect"
	"runtime"
	"time"
	"unsafe"
)

type (
	Byte    byte
	String  string
	Uint32  uint32
	Int64   int64
	Bool    bool
	Float64 float64
)

const (
	ByteConst   Byte    = 255
	StringConst String  = "hi"
	UintConst   Uint32  = 42
	IntConst    Int64   = 9001
	BoolConst   Bool    = true
	FloatConst  Float64 = 3.14
)

type astruct struct {
	A int
	B int
}

type largestruct struct {
	name string
	v    [256]byte
}

type astructName1 astruct
type astructName2 astruct

type bstruct struct {
	a astruct
}

type cstruct struct {
	pb *bstruct
	sa []*astruct
}

type a struct {
	aas []a
}

type A struct {
	val int
}

type C struct {
	s string
}

type B struct {
	A
	*C
	a   A
	ptr *A
}

type D struct {
	u1, u2, u3, u4, u5, u6 uint32
}

func afunc(x int) int {
	return x + 2
}

func afunc1(x int) {
}

func afunc2() int {
	return 0
}

type functype func(int) int

func (a *astruct) Error() string {
	return "not an error"
}

func (a astruct) NonPointerReceiverMethod() {
	return
}

func (b *bstruct) Error() string {
	return "not an error"
}

type dstruct struct {
	x interface{}
}

type maptype map[string]interface{}

type benchstruct struct {
	a [64]byte
	b [64]byte
}

type Item struct {
	Name   string
	Route  string
	Active int
}

type Menu []Item

type truncatedMap struct {
	v []map[string]astruct
}

type Cache struct {
	blocks [2000]Block
}

type Block struct {
	cache *Cache
}

type List struct {
	N    int
	Next *List
}

type T struct {
	F string
}

type W1 struct {
	T
}

func (*W1) M() {}

type I interface{ M() }

type W2 struct {
	W1
	T
}

type W3 struct {
	I
	T
}

type W4 struct {
	I
}

type W5 struct {
	*W5
}

type ThreeInts struct {
	a, b, c int
}

var _ I = (*W2)(nil)

type pptr *pptr

func main() {
	i1 := 1
	i2 := 2
	f1 := 3.0
	i3 := 3
	p1 := &i1
	pp1 := &p1
	s1 := []string{"one", "two", "three", "four", "five"}
	s3 := make([]int, 0, 6)
	a0 := [0]int{}
	a1 := [5]string{"one", "two", "three", "four", "five"}
	c1 := cstruct{&bstruct{astruct{1, 2}}, []*astruct{&astruct{1, 2}, &astruct{2, 3}, &astruct{4, 5}}}
	s2 := []astruct{{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, 12}, {13, 14}, {15, 16}}
	p2 := &(c1.sa[2].B)
	as1 := astruct{1, 1}
	var p3 *int
	str1 := "01234567890"
	var fn1 functype = afunc
	var fn2 functype = nil
	var nilslice []int = nil
	var nilptr *int = nil
	ch1 := make(chan int, 11)
	ch1 <- 1
	ch1 <- 4
	ch1 <- 3
	ch1 <- 2
	var chnil chan int = nil
	m1 := map[string]astruct{
		"Malone":          astruct{2, 3},
		"Adenauer":        astruct{},
		"squadrons":       astruct{},
		"quintuplets":     astruct{},
		"parasite":        astruct{},
		"wristwatches":    astruct{},
		"flashgun":        astruct{},
		"equivocally":     astruct{},
		"sweetbrier":      astruct{},
		"idealism":        astruct{},
		"tangos":          astruct{},
		"alterable":       astruct{},
		"quaffing":        astruct{},
		"arsenic":         astruct{},
		"coincidentally":  astruct{},
		"hindrances":      astruct{},
		"zoning":          astruct{},
		"egging":          astruct{},
		"inserts":         astruct{},
		"adaptive":        astruct{},
		"orientations":    astruct{},
		"periling":        astruct{},
		"lip":             astruct{},
		"chant":           astruct{},
		"availing":        astruct{},
		"fern":            astruct{},
		"flummoxes":       astruct{},
		"meanders":        astruct{},
		"ravenously":      astruct{},
		"reminisce":       astruct{},
		"snorkel":         astruct{},
		"gutters":         astruct{},
		"jibbed":          astruct{},
		"tiara":           astruct{},
		"takers":          astruct{},
		"animates":        astruct{},
		"Zubenelgenubi":   astruct{},
		"bantering":       astruct{},
		"tumblers":        astruct{},
		"horticulturists": astruct{},
		"thallium":        astruct{},
		"capital":         astruct{},
		"paramese":        astruct{},
		"vaccinationist":  astruct{},
		"shadrach":        astruct{},
		"unsincereness":   astruct{},
		"undazzled":       astruct{},
		"heautomorphism":  astruct{},
		"undermeasure":    astruct{},
		"intentionally":   astruct{},
		"glycine":         astruct{},
		"basiliscine":     astruct{},
		"preinvolvement":  astruct{},
		"adversaria":      astruct{},
		"capocchia":       astruct{},
		"annunciable":     astruct{},
		"unguidableness":  astruct{},
		"prankster":       astruct{},
		"jagless":         astruct{},
		"hormonal":        astruct{},
		"crenature":       astruct{},
		"unfluttering":    astruct{},
		"councilmanic":    astruct{},
		"Micraster":       astruct{},
		"raphidiferous":   astruct{},
		"groomer":         astruct{},
	}
	var mnil map[string]astruct = nil
	m2 := map[int]*astruct{1: &astruct{10, 11}}
	m3 := map[astruct]int{{1, 1}: 42, {2, 2}: 43}
	m4 := map[astruct]astruct{{1, 1}: {11, 11}, {2, 2}: {22, 22}}
	mlarge := map[largestruct]largestruct{largestruct{name: "one"}: largestruct{name: "oneval"}}
	upnil := unsafe.Pointer(nil)
	up1 := unsafe.Pointer(&i1)
	i4 := 800
	i5 := -3
	i6 := -500
	var err1 error = c1.sa[0]
	var err2 error = c1.pb
	var errnil error = nil
	var psa *astruct = nil
	var errtypednil error = psa
	var iface1 interface{} = c1.sa[0]
	var iface2 interface{} = "test"
	var iface3 interface{} = map[string]constant.Value{}
	var iface4 interface{} = []constant.Value{constant.MakeInt64(4)}
	var ifacenil interface{} = nil
	arr1 := [4]int{0, 1, 2, 3}
	parr := &arr1
	cpx1 := complex(1, 2)
	const1 := constant.MakeInt64(3)
	recursive1 := dstruct{}
	recursive1.x = &recursive1
	var iface5 interface{} = &recursive1
	var iface2fn1 interface{} = afunc1
	var iface2fn2 interface{} = afunc2
	var mapinf maptype = map[string]interface{}{}
	mapinf["inf"] = mapinf
	var bencharr [64]benchstruct
	var benchparr [64]*benchstruct
	var issue1578 Block
	mainMenu := Menu{
		{Name: "home", Route: "/", Active: 1},
		{Name: "About", Route: "/about", Active: 1},
		{Name: "Login", Route: "/login", Active: 1},
	}
	var aas = []a{{nil}}
	aas[0].aas = aas
	b := B{A: A{-314}, C: &C{"hello"}, a: A{42}, ptr: &A{1337}}
	b2 := B{A: A{42}, a: A{47}}
	var sd D

	ifacearr := []error{&astruct{}, nil}
	efacearr := []interface{}{&astruct{}, "test", nil}

	var mapanonstruct1 map[string]struct{}
	var anonstruct1 struct{ val constant.Value }
	var anonstruct2 struct{ i, j int }
	var anoniface1 interface {
		SomeFunction(struct{ val constant.Value })
		OtherFunction(i, j int)
	}
	var anonfunc func(a struct{ i int }, b interface{}, c struct{ val constant.Value })

	for i := range benchparr {
		benchparr[i] = &benchstruct{}
	}

	ni8 := int8(-5)
	ni16 := int16(-5)
	ni32 := int32(-5)
	ni64 := int64(-5)

	pinf := math.Inf(+1)
	ninf := math.Inf(-1)
	nan := math.NaN()

	var iface6 interface{}
	var ptrinf *interface{}
	iface6 = &ptrinf
	ptrinf = &iface6

	sliceinf := make([]interface{}, 1)
	sliceinf[0] = sliceinf

	zsvar := struct{}{}
	zsslice := make([]struct{}, 3)
	zsvmap := map[string]struct{}{"testkey": struct{}{}}
	var tm truncatedMap
	tm.v = []map[string]astruct{m1}
	var rettm = func() truncatedMap { return tm }

	emptyslice := []string{}
	emptymap := make(map[string]string)

	byteslice := []byte{116, 195, 168, 115, 116}
	bytestypeslice := []Byte{116, 195, 168, 115, 116}
	runeslice := []rune{116, 232, 115, 116}

	bytearray := [5]byte{116, 195, 168, 115, 116}
	bytetypearray := [5]Byte{116, 195, 168, 115, 116}
	runearray := [4]rune{116, 232, 115, 116}

	longstr := "very long string 0123456789a0123456789b0123456789c0123456789d0123456789e0123456789f0123456789g012345678h90123456789i0123456789j0123456789"
	longbyteslice := []byte(longstr)
	m5 := map[C]int{{longstr}: 1}
	m6 := map[string]int{longstr: 123}
	m7 := map[C]C{{longstr}: {"hello"}}
	cl := C{s: longstr}
	var nilstruct *astruct = nil

	val := A{val: 1} // val vs val.val
	var as2 astruct
	s4 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

	var iface2map interface{} = map[string]interface{}{
		"a": map[string]interface{}{
			"1": map[string]interface{}{
				"x": 1,
				"y": 2,
			},
		},
	}

	ll := &List{0, &List{1, &List{2, &List{3, &List{4, nil}}}}}
	unread := (*int)(unsafe.Pointer(uintptr(12345)))

	w2 := &W2{W1{T{"T-inside-W1"}}, T{"T-inside-W2"}}
	w3 := &W3{&W1{T{"T-inside-W1"}}, T{"T-inside-W3"}}
	w4 := &W4{&W1{T{"T-inside-W1"}}}
	w5 := &W5{nil}
	w5.W5 = w5

	os.Setenv("TZ", "UTC")
	tim1 := time.Unix(233431200, 0).UTC()
	loc, _ := time.LoadLocation("America/Mazatlan")
	tim2, _ := time.ParseInLocation("2006-01-02 15:04:05", "2022-06-07 02:03:04", loc)
	typedstringvar := String("blah")
	namedA1 := astructName1{12, 45}
	namedA2 := astructName2{13, 46}

	badslice := []int{1, 2, 3}
	h := (*reflect.SliceHeader)(unsafe.Pointer(&badslice))
	h.Data = 0
	tim3 := time.Date(300000, 1, 1, 0, 0, 0, 0, time.Local)

	int3chan := make(chan ThreeInts, 5)
	int3chan <- ThreeInts{a: 1}
	int3chan <- ThreeInts{a: 2}
	int3chan <- ThreeInts{a: 3}

	var ptrinf2 pptr
	ptrinf2 = &ptrinf2

	enum1 := ByteConst
	enum2 := StringConst
	enum3 := UintConst
	enum4 := IntConst
	enum5 := BoolConst
	enum6 := FloatConst
	var zeropoint4 float64 = 0.4

	var amb1 = 1
	runtime.Breakpoint()
	for amb1 := 0; amb1 < 10; amb1++ {
		fmt.Println(amb1)
	}

	longarr := [100]int{}
	longslice := make([]int, 100, 100)

	runtime.Breakpoint()
	fmt.Println(i1, i2, i3, p1, pp1, amb1, s1, s3, a0, a1, p2, p3, s2, as1, str1, f1, fn1, fn2, nilslice, nilptr, ch1, chnil, m1, mnil, m2, m3, m4, m5, upnil, up1, i4, i5, i6, err1, err2, errnil, iface1, iface2, ifacenil, arr1, parr, cpx1, const1, iface3, iface4, recursive1, recursive1.x, iface5, iface2fn1, iface2fn2, bencharr, benchparr, mapinf, mainMenu, b, b2, sd, anonstruct1, anonstruct2, anoniface1, anonfunc, mapanonstruct1, ifacearr, efacearr, ni8, ni16, ni32, ni64, pinf, ninf, nan, zsvmap, zsslice, zsvar, tm, rettm, errtypednil, emptyslice, emptymap, byteslice, bytestypeslice, runeslice, bytearray, bytetypearray, runearray, longstr, nilstruct, as2, as2.NonPointerReceiverMethod, s4, iface2map, issue1578, ll, unread, w2, w3, w4, w5, longarr, longslice, val, m6, m7, cl, tim1, tim2, typedstringvar, namedA1, namedA2, astructName1(namedA2), badslice, tim3, int3chan, longbyteslice, enum1, enum2, enum3, enum4, enum5, enum6, zeropoint4, mlarge)
}