How to use runOncePairFor method of internal Package

...13}14func (pair runOncePair) isZero() bool {15	return pair.nodeID == 016}17func runOncePairForNode(node Node, containerID uint) runOncePair {18	return runOncePair{19		nodeID:      node.ID,20		nodeType:    node.NodeType,21		containerID: containerID,22	}23}24type runOncePairs []runOncePair25func runOncePairsForSpec(spec Spec) runOncePairs {26	pairs := runOncePairs{}27	containers := spec.Nodes.WithType(types.NodeTypeContainer)28	for _, node := range spec.Nodes {29		if node.NodeType.Is(types.NodeTypeBeforeAll | types.NodeTypeAfterAll) {30			pairs = append(pairs, runOncePairForNode(node, containers.FirstWithNestingLevel(node.NestingLevel-1).ID))31		} else if node.NodeType.Is(types.NodeTypeBeforeEach|types.NodeTypeJustBeforeEach|types.NodeTypeAfterEach|types.NodeTypeJustAfterEach) && node.MarkedOncePerOrdered {32			passedIntoAnOrderedContainer := false33			firstOrderedContainerDeeperThanNode := containers.FirstSatisfying(func(container Node) bool {34				passedIntoAnOrderedContainer = passedIntoAnOrderedContainer || container.MarkedOrdered35				return container.NestingLevel >= node.NestingLevel && passedIntoAnOrderedContainer36			})37			if firstOrderedContainerDeeperThanNode.IsZero() {38				continue39			}40			pairs = append(pairs, runOncePairForNode(node, firstOrderedContainerDeeperThanNode.ID))41		}42	}43	return pairs44}45func (pairs runOncePairs) runOncePairFor(nodeID uint) runOncePair {46	for i := range pairs {47		if pairs[i].nodeID == nodeID {48			return pairs[i]49		}50	}51	return runOncePair{}52}53func (pairs runOncePairs) hasRunOncePair(pair runOncePair) bool {54	for i := range pairs {55		if pairs[i] == pair {56			return true57		}58	}59	return false60}61func (pairs runOncePairs) withType(nodeTypes types.NodeType) runOncePairs {62	count := 063	for i := range pairs {64		if pairs[i].nodeType.Is(nodeTypes) {65			count++66		}67	}68	out, j := make(runOncePairs, count), 069	for i := range pairs {70		if pairs[i].nodeType.Is(nodeTypes) {71			out[j] = pairs[i]72			j++73		}74	}75	return out76}77type group struct {78	suite          *Suite79	specs          Specs80	runOncePairs   map[uint]runOncePairs81	runOnceTracker map[runOncePair]types.SpecState82	succeeded bool83}84func newGroup(suite *Suite) *group {85	return &group{86		suite:          suite,87		runOncePairs:   map[uint]runOncePairs{},88		runOnceTracker: map[runOncePair]types.SpecState{},89		succeeded:      true,90	}91}92func (g *group) initialReportForSpec(spec Spec) types.SpecReport {93	return types.SpecReport{94		ContainerHierarchyTexts:     spec.Nodes.WithType(types.NodeTypeContainer).Texts(),95		ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),96		ContainerHierarchyLabels:    spec.Nodes.WithType(types.NodeTypeContainer).Labels(),97		LeafNodeLocation:            spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,98		LeafNodeType:                types.NodeTypeIt,99		LeafNodeText:                spec.FirstNodeWithType(types.NodeTypeIt).Text,100		LeafNodeLabels:              []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),101		ParallelProcess:             g.suite.config.ParallelProcess,102		IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),103		IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),104	}105}106func (g *group) evaluateSkipStatus(spec Spec) (types.SpecState, types.Failure) {107	if spec.Nodes.HasNodeMarkedPending() {108		return types.SpecStatePending, types.Failure{}109	}110	if spec.Skip {111		return types.SpecStateSkipped, types.Failure{}112	}113	if g.suite.interruptHandler.Status().Interrupted || g.suite.skipAll {114		return types.SpecStateSkipped, types.Failure{}115	}116	if !g.succeeded {117		return types.SpecStateSkipped, g.suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),118			"Spec skipped because an earlier spec in an ordered container failed")119	}120	beforeOncePairs := g.runOncePairs[spec.SubjectID()].withType(types.NodeTypeBeforeAll | types.NodeTypeBeforeEach | types.NodeTypeJustBeforeEach)121	for _, pair := range beforeOncePairs {122		if g.runOnceTracker[pair].Is(types.SpecStateSkipped) {123			return types.SpecStateSkipped, g.suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),124				fmt.Sprintf("Spec skipped because Skip() was called in %s", pair.nodeType))125		}126	}127	if g.suite.config.DryRun {128		return types.SpecStatePassed, types.Failure{}129	}130	return g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure131}132func (g *group) isLastSpecWithPair(specID uint, pair runOncePair) bool {133	lastSpecID := uint(0)134	for idx := range g.specs {135		if g.specs[idx].Skip {136			continue137		}138		sID := g.specs[idx].SubjectID()139		if g.runOncePairs[sID].hasRunOncePair(pair) {140			lastSpecID = sID141		}142	}143	return lastSpecID == specID144}145func (g *group) attemptSpec(isFinalAttempt bool, spec Spec) {146	interruptStatus := g.suite.interruptHandler.Status()147	pairs := g.runOncePairs[spec.SubjectID()]148	nodes := spec.Nodes.WithType(types.NodeTypeBeforeAll)149	nodes = append(nodes, spec.Nodes.WithType(types.NodeTypeBeforeEach)...).SortedByAscendingNestingLevel()150	nodes = append(nodes, spec.Nodes.WithType(types.NodeTypeJustBeforeEach).SortedByAscendingNestingLevel()...)151	nodes = append(nodes, spec.Nodes.FirstNodeWithType(types.NodeTypeIt))152	terminatingNode, terminatingPair := Node{}, runOncePair{}153	for _, node := range nodes {154		oncePair := pairs.runOncePairFor(node.ID)155		if !oncePair.isZero() && g.runOnceTracker[oncePair].Is(types.SpecStatePassed) {156			continue157		}158		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.suite.runNode(node, interruptStatus.Channel, spec.Nodes.BestTextFor(node))159		g.suite.currentSpecReport.RunTime = time.Since(g.suite.currentSpecReport.StartTime)160		if !oncePair.isZero() {161			g.runOnceTracker[oncePair] = g.suite.currentSpecReport.State162		}163		if g.suite.currentSpecReport.State != types.SpecStatePassed {164			terminatingNode, terminatingPair = node, oncePair165			break166		}167	}168	afterNodeWasRun := map[uint]bool{}169	includeDeferCleanups := false170	for {171		nodes := spec.Nodes.WithType(types.NodeTypeAfterEach)172		nodes = append(nodes, spec.Nodes.WithType(types.NodeTypeAfterAll)...).SortedByDescendingNestingLevel()173		nodes = append(spec.Nodes.WithType(types.NodeTypeJustAfterEach).SortedByDescendingNestingLevel(), nodes...)174		if !terminatingNode.IsZero() {175			nodes = nodes.WithinNestingLevel(terminatingNode.NestingLevel)176		}177		if includeDeferCleanups {178			nodes = append(nodes, g.suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterEach).Reverse()...)179			nodes = append(nodes, g.suite.cleanupNodes.WithType(types.NodeTypeCleanupAfterAll).Reverse()...)180		}181		nodes = nodes.Filter(func(node Node) bool {182			if afterNodeWasRun[node.ID] {183				//this node has already been run on this attempt, don't rerun it184				return false185			}186			pair := runOncePair{}187			switch node.NodeType {188			case types.NodeTypeCleanupAfterEach, types.NodeTypeCleanupAfterAll:189				// check if we were generated in an AfterNode that has already run190				if afterNodeWasRun[node.NodeIDWhereCleanupWasGenerated] {191					return true // we were, so we should definitely run this cleanup now192				}193				// looks like this cleanup nodes was generated by a before node or it.194				// the run-once status of a cleanup node is governed by the run-once status of its generator195				pair = pairs.runOncePairFor(node.NodeIDWhereCleanupWasGenerated)196			default:197				pair = pairs.runOncePairFor(node.ID)198			}199			if pair.isZero() {200				// this node is not governed by any run-once policy, we should run it201				return true202			}203			// it's our last chance to run if we're the last spec for our oncePair204			isLastSpecWithPair := g.isLastSpecWithPair(spec.SubjectID(), pair)205			switch g.suite.currentSpecReport.State {206			case types.SpecStatePassed: //this attempt is passing...207				return isLastSpecWithPair //...we should run-once if we'this is our last chance208			case types.SpecStateSkipped: //the spec was skipped by the user...209				if isLastSpecWithPair {210					return true //...we're the last spec, so we should run the AfterNode211				}...

1import (2func main() {3    fmt.Println("Hello, playground")4    xlsxFile, err := xlsx.OpenFile("test.xlsx")5    if err != nil {6        fmt.Println("Error opening file:", err)7    }8    for _, sheet := range xlsxFile.Sheets {9        for _, row := range sheet.Rows {10            for _, cell := range row.Cells {11                text := cell.String()12                fmt.Printf("%s13            }14        }15    }16}17import (18func main() {19    fmt.Println("Hello, playground")20    xlsxFile, err := xlsx.OpenFile("test.xlsx")21    if err != nil {22        fmt.Println("Error opening file:", err)23    }24    for _, sheet := range xlsxFile.Sheets {25        for _, row := range sheet.Rows {26            for _, cell := range row.Cells {27                text := cell.String()28                fmt.Printf("%s29            }30        }31    }32}33import (34func main() {35    fmt.Println("Hello, playground")36    xlsxFile, err := xlsx.OpenFile("test.xlsx")37    if err != nil {38        fmt.Println("Error opening file:", err)39    }40    for _, sheet := range xlsxFile.Sheets {41        for _, row := range sheet.Rows {42            for _, cell := range row.Cells {43                text := cell.String()44                fmt.Printf("%s45            }46        }47    }48}49import (50func main() {51    fmt.Println("Hello, playground")52    xlsxFile, err := xlsx.OpenFile("test.xlsx")53    if err != nil {54        fmt.Println("Error opening file:", err)55    }

1import (2type A struct {3}4func (a *A) runOncePairFor() {5    fmt.Printf("Path: %d.go6}7func main() {8    a := A{1}9    a.runOncePairFor()10    a.runOncePairFor()11    a.runOncePairFor()12}13import (14type A struct {15}16func (a A) runOncePairFor() {17    fmt.Printf("Path: %d.go18}19func main() {20    a := A{1}21    a.runOncePairFor()22    a.runOncePairFor()23    a.runOncePairFor()24}25import (26type A struct {27}28func (a A) runOncePairFor() A {29    fmt.Printf("Path: %d.go30}31func main() {32    a := A{1}33    a = a.runOncePairFor()34    a = a.runOncePairFor()35    a = a.runOncePairFor()36}

1func main() {2    var p1 = new(pair)3    p1.runOncePairFor(1, 2)4}5func main() {6    var p1 = new(pair)7    p1.runOncePairFor(1, 2)8}9func main() {10    var p1 = new(pair)11    p1.runOncePairFor(1, 2)12}13func main() {14    var p1 = new(pair)15    p1.runOncePairFor(1, 2)16}17func main() {18    var p1 = new(pair)19    p1.runOncePairFor(1, 2)20}21func main() {22    var p1 = new(pair)23    p1.runOncePairFor(1, 2)24}25func main() {26    var p1 = new(pair)27    p1.runOncePairFor(1, 2)28}29func main() {30    var p1 = new(pair)31    p1.runOncePairFor(1, 2)32}33func main() {34    var p1 = new(pair)35    p1.runOncePairFor(1, 2)36}37func main() {38    var p1 = new(pair)39    p1.runOncePairFor(1, 2)40}41func main() {42    var p1 = new(pair)43    p1.runOncePairFor(1, 2)44}

1import (2func main() {3	fmt.Println(arrays.RunOncePairFor([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 9))4}5import (6func TestRunOncePairFor(t *testing.T) {7}8import (9func main() {10	fmt.Println(arrays.RunOncePairWhile([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 9))11}12import (13func TestRunOncePairWhile(t *testing