How to use unrollInterfaceSlice method of internal Package

...133		if err != nil {134			errors = append(errors, err)135		}136	}137	args = unrollInterfaceSlice(args)138	remainingArgs := []interface{}{}139	//First get the CodeLocation up-to-date140	for _, arg := range args {141		switch v := arg.(type) {142		case Offset:143			node.CodeLocation = types.NewCodeLocation(baseOffset + int(v))144		case types.CodeLocation:145			node.CodeLocation = v146		default:147			remainingArgs = append(remainingArgs, arg)148		}149	}150	labelsSeen := map[string]bool{}151	trackedFunctionError := false152	args = remainingArgs153	remainingArgs = []interface{}{}154	//now process the rest of the args155	for _, arg := range args {156		switch t := reflect.TypeOf(arg); {157		case t == reflect.TypeOf(float64(0)):158			break //ignore deprecated timeouts159		case t == reflect.TypeOf(Focus):160			node.MarkedFocus = bool(arg.(focusType))161			if !nodeType.Is(types.NodeTypesForContainerAndIt) {162				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Focus"))163			}164		case t == reflect.TypeOf(Pending):165			node.MarkedPending = bool(arg.(pendingType))166			if !nodeType.Is(types.NodeTypesForContainerAndIt) {167				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Pending"))168			}169		case t == reflect.TypeOf(Serial):170			node.MarkedSerial = bool(arg.(serialType))171			if !nodeType.Is(types.NodeTypesForContainerAndIt) {172				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Serial"))173			}174		case t == reflect.TypeOf(Ordered):175			node.MarkedOrdered = bool(arg.(orderedType))176			if !nodeType.Is(types.NodeTypeContainer) {177				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Ordered"))178			}179		case t == reflect.TypeOf(OncePerOrdered):180			node.MarkedOncePerOrdered = bool(arg.(honorsOrderedType))181			if !nodeType.Is(types.NodeTypeBeforeEach | types.NodeTypeJustBeforeEach | types.NodeTypeAfterEach | types.NodeTypeJustAfterEach) {182				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "OncePerOrdered"))183			}184		case t == reflect.TypeOf(FlakeAttempts(0)):185			node.FlakeAttempts = int(arg.(FlakeAttempts))186			if !nodeType.Is(types.NodeTypesForContainerAndIt) {187				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "FlakeAttempts"))188			}189		case t == reflect.TypeOf(Labels{}):190			if !nodeType.Is(types.NodeTypesForContainerAndIt) {191				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Label"))192			}193			for _, label := range arg.(Labels) {194				if !labelsSeen[label] {195					labelsSeen[label] = true196					label, err := types.ValidateAndCleanupLabel(label, node.CodeLocation)197					node.Labels = append(node.Labels, label)198					appendError(err)199				}200			}201		case t.Kind() == reflect.Func:202			if node.Body != nil {203				appendError(types.GinkgoErrors.MultipleBodyFunctions(node.CodeLocation, nodeType))204				trackedFunctionError = true205				break206			}207			isValid := (t.NumOut() == 0) && (t.NumIn() <= 1) && (t.NumIn() == 0 || t.In(0) == reflect.TypeOf(make(Done)))208			if !isValid {209				appendError(types.GinkgoErrors.InvalidBodyType(t, node.CodeLocation, nodeType))210				trackedFunctionError = true211				break212			}213			if t.NumIn() == 0 {214				node.Body = arg.(func())215			} else {216				deprecationTracker.TrackDeprecation(types.Deprecations.Async(), node.CodeLocation)217				deprecatedAsyncBody := arg.(func(Done))218				node.Body = func() { deprecatedAsyncBody(make(Done)) }219			}220		default:221			remainingArgs = append(remainingArgs, arg)222		}223	}224	//validations225	if node.MarkedPending && node.MarkedFocus {226		appendError(types.GinkgoErrors.InvalidDeclarationOfFocusedAndPending(node.CodeLocation, nodeType))227	}228	if node.Body == nil && !node.MarkedPending && !trackedFunctionError {229		appendError(types.GinkgoErrors.MissingBodyFunction(node.CodeLocation, nodeType))230	}231	for _, arg := range remainingArgs {232		appendError(types.GinkgoErrors.UnknownDecorator(node.CodeLocation, nodeType, arg))233	}234	if len(errors) > 0 {235		return Node{}, errors236	}237	return node, errors238}239func NewSynchronizedBeforeSuiteNode(proc1Body func() []byte, allProcsBody func([]byte), codeLocation types.CodeLocation) (Node, []error) {240	return Node{241		ID:                                  UniqueNodeID(),242		NodeType:                            types.NodeTypeSynchronizedBeforeSuite,243		SynchronizedBeforeSuiteProc1Body:    proc1Body,244		SynchronizedBeforeSuiteAllProcsBody: allProcsBody,245		CodeLocation:                        codeLocation,246	}, nil247}248func NewSynchronizedAfterSuiteNode(allProcsBody func(), proc1Body func(), codeLocation types.CodeLocation) (Node, []error) {249	return Node{250		ID:                                 UniqueNodeID(),251		NodeType:                           types.NodeTypeSynchronizedAfterSuite,252		SynchronizedAfterSuiteAllProcsBody: allProcsBody,253		SynchronizedAfterSuiteProc1Body:    proc1Body,254		CodeLocation:                       codeLocation,255	}, nil256}257func NewReportBeforeEachNode(body func(types.SpecReport), codeLocation types.CodeLocation) (Node, []error) {258	return Node{259		ID:             UniqueNodeID(),260		NodeType:       types.NodeTypeReportBeforeEach,261		ReportEachBody: body,262		CodeLocation:   codeLocation,263		NestingLevel:   -1,264	}, nil265}266func NewReportAfterEachNode(body func(types.SpecReport), codeLocation types.CodeLocation) (Node, []error) {267	return Node{268		ID:             UniqueNodeID(),269		NodeType:       types.NodeTypeReportAfterEach,270		ReportEachBody: body,271		CodeLocation:   codeLocation,272		NestingLevel:   -1,273	}, nil274}275func NewReportAfterSuiteNode(text string, body func(types.Report), codeLocation types.CodeLocation) (Node, []error) {276	return Node{277		ID:                   UniqueNodeID(),278		Text:                 text,279		NodeType:             types.NodeTypeReportAfterSuite,280		ReportAfterSuiteBody: body,281		CodeLocation:         codeLocation,282	}, nil283}284func NewCleanupNode(fail func(string, types.CodeLocation), args ...interface{}) (Node, []error) {285	baseOffset := 2286	node := Node{287		ID:           UniqueNodeID(),288		NodeType:     types.NodeTypeCleanupInvalid,289		CodeLocation: types.NewCodeLocation(baseOffset),290		NestingLevel: -1,291	}292	remainingArgs := []interface{}{}293	for _, arg := range args {294		switch t := reflect.TypeOf(arg); {295		case t == reflect.TypeOf(Offset(0)):296			node.CodeLocation = types.NewCodeLocation(baseOffset + int(arg.(Offset)))297		case t == reflect.TypeOf(types.CodeLocation{}):298			node.CodeLocation = arg.(types.CodeLocation)299		default:300			remainingArgs = append(remainingArgs, arg)301		}302	}303	if len(remainingArgs) == 0 {304		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(node.CodeLocation)}305	}306	callback := reflect.ValueOf(remainingArgs[0])307	if !(callback.Kind() == reflect.Func && callback.Type().NumOut() <= 1) {308		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(node.CodeLocation)}309	}310	callArgs := []reflect.Value{}311	for _, arg := range remainingArgs[1:] {312		callArgs = append(callArgs, reflect.ValueOf(arg))313	}314	cl := node.CodeLocation315	node.Body = func() {316		out := callback.Call(callArgs)317		if len(out) == 1 && !out[0].IsNil() {318			fail(fmt.Sprintf("DeferCleanup callback returned error: %v", out[0]), cl)319		}320	}321	return node, nil322}323func (n Node) IsZero() bool {324	return n.ID == 0325}326/* Nodes */327type Nodes []Node328func (n Nodes) CopyAppend(nodes ...Node) Nodes {329	numN := len(n)330	out := make(Nodes, numN+len(nodes))331	for i, node := range n {332		out[i] = node333	}334	for j, node := range nodes {335		out[numN+j] = node336	}337	return out338}339func (n Nodes) SplitAround(pivot Node) (Nodes, Nodes) {340	pivotIdx := len(n)341	for i := range n {342		if n[i].ID == pivot.ID {343			pivotIdx = i344			break345		}346	}347	left := n[:pivotIdx]348	right := Nodes{}349	if pivotIdx+1 < len(n) {350		right = n[pivotIdx+1:]351	}352	return left, right353}354func (n Nodes) FirstNodeWithType(nodeTypes types.NodeType) Node {355	for i := range n {356		if n[i].NodeType.Is(nodeTypes) {357			return n[i]358		}359	}360	return Node{}361}362func (n Nodes) WithType(nodeTypes types.NodeType) Nodes {363	count := 0364	for i := range n {365		if n[i].NodeType.Is(nodeTypes) {366			count++367		}368	}369	out, j := make(Nodes, count), 0370	for i := range n {371		if n[i].NodeType.Is(nodeTypes) {372			out[j] = n[i]373			j++374		}375	}376	return out377}378func (n Nodes) WithoutType(nodeTypes types.NodeType) Nodes {379	count := 0380	for i := range n {381		if !n[i].NodeType.Is(nodeTypes) {382			count++383		}384	}385	out, j := make(Nodes, count), 0386	for i := range n {387		if !n[i].NodeType.Is(nodeTypes) {388			out[j] = n[i]389			j++390		}391	}392	return out393}394func (n Nodes) WithoutNode(nodeToExclude Node) Nodes {395	idxToExclude := len(n)396	for i := range n {397		if n[i].ID == nodeToExclude.ID {398			idxToExclude = i399			break400		}401	}402	if idxToExclude == len(n) {403		return n404	}405	out, j := make(Nodes, len(n)-1), 0406	for i := range n {407		if i == idxToExclude {408			continue409		}410		out[j] = n[i]411		j++412	}413	return out414}415func (n Nodes) Filter(filter func(Node) bool) Nodes {416	trufa, count := make([]bool, len(n)), 0417	for i := range n {418		if filter(n[i]) {419			trufa[i] = true420			count += 1421		}422	}423	out, j := make(Nodes, count), 0424	for i := range n {425		if trufa[i] {426			out[j] = n[i]427			j++428		}429	}430	return out431}432func (n Nodes) FirstSatisfying(filter func(Node) bool) Node {433	for i := range n {434		if filter(n[i]) {435			return n[i]436		}437	}438	return Node{}439}440func (n Nodes) WithinNestingLevel(deepestNestingLevel int) Nodes {441	count := 0442	for i := range n {443		if n[i].NestingLevel <= deepestNestingLevel {444			count++445		}446	}447	out, j := make(Nodes, count), 0448	for i := range n {449		if n[i].NestingLevel <= deepestNestingLevel {450			out[j] = n[i]451			j++452		}453	}454	return out455}456func (n Nodes) SortedByDescendingNestingLevel() Nodes {457	out := make(Nodes, len(n))458	copy(out, n)459	sort.SliceStable(out, func(i int, j int) bool {460		return out[i].NestingLevel > out[j].NestingLevel461	})462	return out463}464func (n Nodes) SortedByAscendingNestingLevel() Nodes {465	out := make(Nodes, len(n))466	copy(out, n)467	sort.SliceStable(out, func(i int, j int) bool {468		return out[i].NestingLevel < out[j].NestingLevel469	})470	return out471}472func (n Nodes) FirstWithNestingLevel(level int) Node {473	for i := range n {474		if n[i].NestingLevel == level {475			return n[i]476		}477	}478	return Node{}479}480func (n Nodes) Reverse() Nodes {481	out := make(Nodes, len(n))482	for i := range n {483		out[len(n)-1-i] = n[i]484	}485	return out486}487func (n Nodes) Texts() []string {488	out := make([]string, len(n))489	for i := range n {490		out[i] = n[i].Text491	}492	return out493}494func (n Nodes) Labels() [][]string {495	out := make([][]string, len(n))496	for i := range n {497		if n[i].Labels == nil {498			out[i] = []string{}499		} else {500			out[i] = []string(n[i].Labels)501		}502	}503	return out504}505func (n Nodes) UnionOfLabels() []string {506	out := []string{}507	seen := map[string]bool{}508	for i := range n {509		for _, label := range n[i].Labels {510			if !seen[label] {511				seen[label] = true512				out = append(out, label)513			}514		}515	}516	return out517}518func (n Nodes) CodeLocations() []types.CodeLocation {519	out := make([]types.CodeLocation, len(n))520	for i := range n {521		out[i] = n[i].CodeLocation522	}523	return out524}525func (n Nodes) BestTextFor(node Node) string {526	if node.Text != "" {527		return node.Text528	}529	parentNestingLevel := node.NestingLevel - 1530	for i := range n {531		if n[i].Text != "" && n[i].NestingLevel == parentNestingLevel {532			return n[i].Text533		}534	}535	return ""536}537func (n Nodes) ContainsNodeID(id uint) bool {538	for i := range n {539		if n[i].ID == id {540			return true541		}542	}543	return false544}545func (n Nodes) HasNodeMarkedPending() bool {546	for i := range n {547		if n[i].MarkedPending {548			return true549		}550	}551	return false552}553func (n Nodes) HasNodeMarkedFocus() bool {554	for i := range n {555		if n[i].MarkedFocus {556			return true557		}558	}559	return false560}561func (n Nodes) HasNodeMarkedSerial() bool {562	for i := range n {563		if n[i].MarkedSerial {564			return true565		}566	}567	return false568}569func (n Nodes) FirstNodeMarkedOrdered() Node {570	for i := range n {571		if n[i].MarkedOrdered {572			return n[i]573		}574	}575	return Node{}576}577func unrollInterfaceSlice(args interface{}) []interface{} {578	v := reflect.ValueOf(args)579	if v.Kind() != reflect.Slice {580		return []interface{}{args}581	}582	out := []interface{}{}583	for i := 0; i < v.Len(); i++ {584		el := reflect.ValueOf(v.Index(i).Interface())585		if el.Kind() == reflect.Slice && el.Type() != reflect.TypeOf(Labels{}) {586			out = append(out, unrollInterfaceSlice(el.Interface())...)587		} else {588			out = append(out, v.Index(i).Interface())589		}590	}591	return out592}...

1func main() {2    var i interface{} = []int{1, 2, 3}3    fmt.Println(unrollInterfaceSlice(i))4}5func main() {6    var i interface{} = []int{1, 2, 3}7    fmt.Println(internal.UnrollInterfaceSlice(i))8}9func main() {10    var i interface{} = []int{1, 2, 3}11    fmt.Println(internal.UnrollInterfaceSlice(i))12}13func main() {14    var i interface{} = []int{1, 2, 3}15    fmt.Println(internal.UnrollInterfaceSlice(i))16}17func main() {18    var i interface{} = []int{1, 2, 3}19    fmt.Println(internal.UnrollInterfaceSlice(i))20}21func main() {22    var i interface{} = []int{1, 2, 3}23    fmt.Println(internal.UnrollInterfaceSlice(i))24}25func main() {26    var i interface{} = []int{1, 2, 3}27    fmt.Println(internal.UnrollInterfaceSlice(i))28}29func main() {30    var i interface{} = []int{1, 2, 3}31    fmt.Println(internal.UnrollInterfaceSlice(i))32}33func main() {34    var i interface{} = []int{1, 2, 3}35    fmt.Println(internal.UnrollInterfaceSlice(i))36}37func main() {38    var i interface{} = []int{1, 2, 3}39    fmt.Println(internal.UnrollInterfaceSlice(i))

1func main() {2    var s []interface{}3    s = append(s, 1)4    s = append(s, 2)5    s = append(s, 3)6    s = append(s, 4)7    s = append(s, 5)8    s = append(s, 6)9    s = append(s, 7)10    s = append(s, 8)11    s = append(s, 9)12    s = append(s, 10)13    s = append(s, 11)14    s = append(s, 12)15    s = append(s, 13)16    s = append(s, 14)17    s = append(s, 15)18    s = append(s, 16)19    s = append(s, 17)20    s = append(s, 18)21    s = append(s, 19)22    s = append(s, 20)23    s = append(s, 21)24    s = append(s, 22)25    s = append(s, 23)26    s = append(s, 24)27    s = append(s, 25)28    s = append(s, 26)29    s = append(s, 27)30    s = append(s, 28)31    s = append(s, 29)32    s = append(s, 30)33    s = append(s, 31)34    s = append(s, 32)35    s = append(s, 33)36    s = append(s, 34)37    s = append(s, 35)38    s = append(s, 36)39    s = append(s, 37)40    s = append(s, 38)41    s = append(s, 39)42    s = append(s, 40)43    s = append(s, 41)44    s = append(s, 42)45    s = append(s, 43)46    s = append(s, 44)47    s = append(s, 45)48    s = append(s, 46)49    s = append(s, 47)50    s = append(s, 48)51    s = append(s, 49)52    s = append(s, 50)53    s = append(s, 51)54    s = append(s, 52)55    s = append(s,

1import (2func main() {3	var a interface{}4	a = []int{1, 2, 3}5	fmt.Println(a)6	fmt.Println(reflect.TypeOf(a))7	fmt.Println(reflect.ValueOf(a))8	fmt.Println(reflect.ValueOf(a).Interface())9	fmt.Println(reflect.ValueOf(a).Interface().([]int))10	fmt.Println(reflect.ValueOf(a).Interface().([]int)[0])11}12import (13func main() {14	var a interface{}15	a = []interface{}{1, 2, "3"}16	fmt.Println(a)17	fmt.Println(reflect.TypeOf(a))18	fmt.Println(reflect.ValueOf(a))19	fmt.Println(reflect.ValueOf(a).Interface())20	fmt.Println(reflect.ValueOf(a).Interface().([]interface{}))21	fmt.Println(reflect.ValueOf(a).Interface().([]interface{})[0])22	fmt.Println(reflect.ValueOf(a).Interface().([]interface{})[2])23}24[]interface {}25import (26func main() {27	var a interface{}28	a = []interface{}{1, 2, []int{3, 4}}29	fmt.Println(a)30	fmt.Println(reflect.TypeOf(a))31	fmt.Println(reflect.ValueOf(a))32	fmt.Println(reflect.ValueOf(a).Interface())33	fmt.Println(reflect.ValueOf(a).Interface().([]interface{}))34	fmt.Println(reflect.ValueOf(a).Interface().([]interface{})[0])35	fmt.Println(reflect.ValueOf(a).Interface().([]interface{})[2])36	fmt.Println(reflect.ValueOf(a).Interface().([]interface{})[2].([]int))37	fmt.Println(reflect.ValueOf(a).Interface().([]interface{})[2].([]int)[1])38}39[]interface {}

1func main() {2    unrollInterfaceSlice([]interface{}{1, 2, 3, 4, 5})3}4func UnrollInterfaceSlice(slice []interface{}) {5    for _, val := range slice {6        println(val)7    }8}9func UnrollInterfaceSlice(slice []interface{}) {10    for _, val := range slice {11        println(val)12    }13}14func main() {15    unrollInterfaceSlice([]interface{}{1, 2, 3, 4, 5})16}

1func main() {2    var a []interface{}3    a = append(a, 1, "two", 3.0)4    b := unrollInterfaceSlice(a)5    fmt.Println(b)6}7func main() {8    var a []interface{}9    a = append(a, 1, "two", 3.0)10    b := unrollInterfaceSlice(a)11    fmt.Println(b)12}13func main() {14    var a []interface{}15    a = append(a, 1, "two", 3.0)16    b := unrollInterfaceSlice(a)17    fmt.Println(b)18}19func UnrollInterfaceSlice(a []interface{}) []interface{} {20    return unrollInterfaceSlice(a)21}22func main() {23    var a []interface{}24    a = append(a, 1, "two", 3.0)25    b := internal.UnrollInterfaceSlice(a)26    fmt.Println(b)27}28func main() {29    var a []interface{}30    a = append(a, 1, "two", 3.0)

1import (2func main() {3    slice := []interface{}{"a", "b", "c"}4    fmt.Println(internal.UnrollInterfaceSlice(slice))5}6func UnrollInterfaceSlice(slice []interface{}) string {7    for _, v := range slice {8        result += v.(string)9    }10}11import (12type User struct {13}14func main() {15    users = append(users, User{ID: 1, Name: "John Doe", Email: "

1import (2func main() {3    var i interface{} = []interface{}{"a", "b", "c"}4    unrolledSlice := internal.UnrollInterfaceSlice(i)5    fmt.Println(unrolledSlice)6}7import (8func main() {9    var i interface{} = []interface{}{"a", "b", "c"}10    unrolledSlice := unroll.UnrollInterfaceSlice(i)11    fmt.Println(unrolledSlice)12}13import (14func main() {15    var i interface{} = []interface{}{"a", "b", "c"}16    unrolledSlice := unroll.UnrollInterfaceSlice(i)17    fmt.Println(unrolledSlice)18}19import (20func main() {21    var i interface{} = []interface{}{"a", "b", "c"}22    unrolledSlice := unroll.UnrollInterfaceSlice(i)23    fmt.Println(unrolledSlice)24}25import (26func main() {27    var i interface{} = []interface{}{"a", "b", "c"}28    unrolledSlice := unroll.UnrollInterfaceSlice(i)29    fmt.Println(unrolledSlice)30}31import (

1import (2func main() {3	var i interface{} = []interface{}{"a", "b", "c"}4	fmt.Println(i)5	s := reflect.ValueOf(i).Interface().([]interface{})6	fmt.Println(s)7	for _, v := range s {8		fmt.Println(v)9	}10}11var i interface{} = []interface{}{1, 2, 3}12fmt.Println(i)13s := reflect.ValueOf(i).Interface().([]interface{})14fmt.Println(s)15for _, v := range s {16	fmt.Println(v.(int))17}