How to use failureForLeafNodeWithMessage method of internal Package

...445			}446		}447	}448	if err != nil && !suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {449		suite.currentSpecReport.State, suite.currentSpecReport.Failure = types.SpecStateFailed, suite.failureForLeafNodeWithMessage(node, err.Error())450	}451	suite.currentSpecReport.EndTime = time.Now()452	suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)453	suite.currentSpecReport.CapturedGinkgoWriterOutput = string(suite.writer.Bytes())454	suite.currentSpecReport.CapturedStdOutErr += suite.outputInterceptor.StopInterceptingAndReturnOutput()455	return456}457func (suite *Suite) runReportAfterSuiteNode(node Node, report types.Report) {458	suite.writer.Truncate()459	suite.outputInterceptor.StartInterceptingOutput()460	suite.currentSpecReport.StartTime = time.Now()461	if suite.config.ParallelTotal > 1 {462		aggregatedReport, err := suite.client.BlockUntilAggregatedNonprimaryProcsReport()463		if err != nil {464			suite.currentSpecReport.State, suite.currentSpecReport.Failure = types.SpecStateFailed, suite.failureForLeafNodeWithMessage(node, err.Error())465			return466		}467		report = report.Add(aggregatedReport)468	}469	node.Body = func() { node.ReportAfterSuiteBody(report) }470	suite.interruptHandler.SetInterruptPlaceholderMessage(formatter.Fiw(0, formatter.COLS,471		"{{yellow}}Ginkgo received an interrupt signal but is currently running a ReportAfterSuite node.  To avoid an invalid report the ReportAfterSuite node will not be interrupted.{{/}}\n\n{{bold}}The running ReportAfterSuite node is at:\n%s.{{/}}",472		node.CodeLocation,473	))474	suite.currentSpecReport.State, suite.currentSpecReport.Failure = suite.runNode(node, nil, "")475	suite.interruptHandler.ClearInterruptPlaceholderMessage()476	suite.currentSpecReport.EndTime = time.Now()477	suite.currentSpecReport.RunTime = suite.currentSpecReport.EndTime.Sub(suite.currentSpecReport.StartTime)478	suite.currentSpecReport.CapturedGinkgoWriterOutput = string(suite.writer.Bytes())479	suite.currentSpecReport.CapturedStdOutErr = suite.outputInterceptor.StopInterceptingAndReturnOutput()480	return481}482func (suite *Suite) runNode(node Node, interruptChannel chan interface{}, text string) (types.SpecState, types.Failure) {483	if node.NodeType.Is(types.NodeTypeCleanupAfterEach | types.NodeTypeCleanupAfterAll | types.NodeTypeCleanupAfterSuite) {484		suite.cleanupNodes = suite.cleanupNodes.WithoutNode(node)485	}486	suite.currentNode = node487	defer func() {488		suite.currentNode = Node{}489	}()490	if suite.config.EmitSpecProgress {491		if text == "" {492			text = "TOP-LEVEL"493		}494		s := fmt.Sprintf("[%s] %s\n  %s\n", node.NodeType.String(), text, node.CodeLocation.String())495		suite.writer.Write([]byte(s))496	}497	var failure types.Failure498	failure.FailureNodeType, failure.FailureNodeLocation = node.NodeType, node.CodeLocation499	if node.NodeType.Is(types.NodeTypeIt) || node.NodeType.Is(types.NodeTypesForSuiteLevelNodes) {500		failure.FailureNodeContext = types.FailureNodeIsLeafNode501	} else if node.NestingLevel <= 0 {502		failure.FailureNodeContext = types.FailureNodeAtTopLevel503	} else {504		failure.FailureNodeContext, failure.FailureNodeContainerIndex = types.FailureNodeInContainer, node.NestingLevel-1505	}506	outcomeC := make(chan types.SpecState)507	failureC := make(chan types.Failure)508	go func() {509		finished := false510		defer func() {511			if e := recover(); e != nil || !finished {512				suite.failer.Panic(types.NewCodeLocationWithStackTrace(2), e)513			}514			outcome, failureFromRun := suite.failer.Drain()515			outcomeC <- outcome516			failureC <- failureFromRun517		}()518		node.Body()519		finished = true520	}()521	select {522	case outcome := <-outcomeC:523		failureFromRun := <-failureC524		if outcome == types.SpecStatePassed {525			return outcome, types.Failure{}526		}527		failure.Message, failure.Location, failure.ForwardedPanic = failureFromRun.Message, failureFromRun.Location, failureFromRun.ForwardedPanic528		return outcome, failure529	case <-interruptChannel:530		failure.Message, failure.Location = suite.interruptHandler.InterruptMessageWithStackTraces(), node.CodeLocation531		return types.SpecStateInterrupted, failure532	}533}534func (suite *Suite) failureForLeafNodeWithMessage(node Node, message string) types.Failure {535	return types.Failure{536		Message:             message,537		Location:            node.CodeLocation,538		FailureNodeContext:  types.FailureNodeIsLeafNode,539		FailureNodeType:     node.NodeType,540		FailureNodeLocation: node.CodeLocation,541	}542}543func max(a, b int) int {544	if a > b {545		return a546	}547	return b548}...

...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				}212				if !terminatingPair.isZero() && terminatingNode.NestingLevel == node.NestingLevel {213					return true //...or, a run-once node at our nesting level was skipped which means this is our last chance to run214				}215			case types.SpecStateFailed, types.SpecStatePanicked: // the spec has failed...216				if isFinalAttempt {217					return true //...if this was the last attempt then we're the last spec to run and so the AfterNode should run218				}219				if !terminatingPair.isZero() { // ...and it failed in a run-once.  which will be running again220					if node.NodeType.Is(types.NodeTypeCleanupAfterEach | types.NodeTypeCleanupAfterAll) {221						return terminatingNode.ID == node.NodeIDWhereCleanupWasGenerated // we should run this node if we're a clean-up generated by it222					} else {223						return terminatingNode.NestingLevel == node.NestingLevel // ...or if we're at the same nesting level224					}225				}226			case types.SpecStateInterrupted, types.SpecStateAborted: // ...we've been interrupted and/or aborted227				return true //...that means the test run is over and we should clean up the stack.  Run the AfterNode228			}229			return false230		})231		if len(nodes) == 0 && includeDeferCleanups {232			break233		}234		for _, node := range nodes {235			afterNodeWasRun[node.ID] = true236			state, failure := g.suite.runNode(node, g.suite.interruptHandler.Status().Channel, spec.Nodes.BestTextFor(node))237			g.suite.currentSpecReport.RunTime = time.Since(g.suite.currentSpecReport.StartTime)238			if g.suite.currentSpecReport.State == types.SpecStatePassed || state == types.SpecStateAborted {239				g.suite.currentSpecReport.State = state240				g.suite.currentSpecReport.Failure = failure241			}242		}243		includeDeferCleanups = true244	}245}246func (g *group) run(specs Specs) {247	g.specs = specs248	for _, spec := range g.specs {249		g.runOncePairs[spec.SubjectID()] = runOncePairsForSpec(spec)250	}251	for _, spec := range g.specs {252		g.suite.currentSpecReport = g.initialReportForSpec(spec)253		g.suite.currentSpecReport.State, g.suite.currentSpecReport.Failure = g.evaluateSkipStatus(spec)254		g.suite.reporter.WillRun(g.suite.currentSpecReport)255		g.suite.reportEach(spec, types.NodeTypeReportBeforeEach)256		skip := g.suite.config.DryRun || g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates|types.SpecStateSkipped|types.SpecStatePending)257		g.suite.currentSpecReport.StartTime = time.Now()258		if !skip {259			maxAttempts := max(1, spec.FlakeAttempts())260			if g.suite.config.FlakeAttempts > 0 {261				maxAttempts = g.suite.config.FlakeAttempts262			}263			for attempt := 0; attempt < maxAttempts; attempt++ {264				g.suite.currentSpecReport.NumAttempts = attempt + 1265				g.suite.writer.Truncate()266				g.suite.outputInterceptor.StartInterceptingOutput()267				if attempt > 0 {268					fmt.Fprintf(g.suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)269				}270				g.attemptSpec(attempt == maxAttempts-1, spec)271				g.suite.currentSpecReport.EndTime = time.Now()272				g.suite.currentSpecReport.RunTime = g.suite.currentSpecReport.EndTime.Sub(g.suite.currentSpecReport.StartTime)273				g.suite.currentSpecReport.CapturedGinkgoWriterOutput += string(g.suite.writer.Bytes())274				g.suite.currentSpecReport.CapturedStdOutErr += g.suite.outputInterceptor.StopInterceptingAndReturnOutput()275				if g.suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {276					break277				}278			}279		}280		g.suite.reportEach(spec, types.NodeTypeReportAfterEach)281		g.suite.processCurrentSpecReport()282		if g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates) {283			g.succeeded = false284		}285		g.suite.currentSpecReport = types.SpecReport{}286	}287}288func (g *group) oldRun(specs Specs) {289	var suite = g.suite290	nodeState := map[uint]types.SpecState{}291	groupSucceeded := true292	indexOfLastSpecContainingNodeID := func(id uint) int {293		lastIdx := -1294		for idx := range specs {295			if specs[idx].Nodes.ContainsNodeID(id) && !specs[idx].Skip {296				lastIdx = idx297			}298		}299		return lastIdx300	}301	for i, spec := range specs {302		suite.currentSpecReport = types.SpecReport{303			ContainerHierarchyTexts:     spec.Nodes.WithType(types.NodeTypeContainer).Texts(),304			ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),305			ContainerHierarchyLabels:    spec.Nodes.WithType(types.NodeTypeContainer).Labels(),306			LeafNodeLocation:            spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,307			LeafNodeType:                types.NodeTypeIt,308			LeafNodeText:                spec.FirstNodeWithType(types.NodeTypeIt).Text,309			LeafNodeLabels:              []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),310			ParallelProcess:             suite.config.ParallelProcess,311			IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),312			IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),313		}314		skip := spec.Skip315		if spec.Nodes.HasNodeMarkedPending() {316			skip = true317			suite.currentSpecReport.State = types.SpecStatePending318		} else {319			if suite.interruptHandler.Status().Interrupted || suite.skipAll {320				skip = true321			}322			if !groupSucceeded {323				skip = true324				suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),325					"Spec skipped because an earlier spec in an ordered container failed")326			}327			for _, node := range spec.Nodes.WithType(types.NodeTypeBeforeAll) {328				if nodeState[node.ID] == types.SpecStateSkipped {329					skip = true330					suite.currentSpecReport.Failure = suite.failureForLeafNodeWithMessage(spec.FirstNodeWithType(types.NodeTypeIt),331						"Spec skipped because Skip() was called in BeforeAll")332					break333				}334			}335			if skip {336				suite.currentSpecReport.State = types.SpecStateSkipped337			}338		}339		if suite.config.DryRun && !skip {340			skip = true341			suite.currentSpecReport.State = types.SpecStatePassed342		}343		suite.reporter.WillRun(suite.currentSpecReport)344		//send the spec report to any attached ReportBeforeEach blocks - this will update suite.currentSpecReport if failures occur in these blocks...

1import (2type User struct {3}4func main() {5	user := User{6	}7	validate := validator.New()8	err := validate.Struct(user)9	if err != nil {10		fmt.Println(err.(validator.ValidationErrors)[0].FailureForLeafNodeWithMessage("failed"))11	}12}

1import (2func main() {3	ginkgo.RunSpecs(t, "My Suite")4}5var _ = ginkgo.Describe("My Suite", func() {6	ginkgo.It("should do something", func() {7		gomega.Expect(true).To(gomega.BeTrue())8	})9})10import (11func main() {12	ginkgo.RunSpecs(t, "My Suite")13}14var _ = ginkgo.Describe("My Suite", func() {15	ginkgo.It("should do something", func() {16		gomega.Expect(true).To(gomega.BeTrue())17	})18})19import (

1func (n *Node) failureForLeafNodeWithMessage(message string) {2    n.failureForLeafNode(message)3}4func (n *Node) failureForLeafNode(message string) {5}6func (n *Node) failureForLeafNode(message string) {7}8func (n *Node) failureForLeafNode(message string) {9}10func (n *Node) failureForLeafNode(message string) {11}12func (n *Node) failureForLeafNode(message string) {13}14func (n *Node) failureForLeafNode(message string) {15}16func (n *Node) failureForLeafNode(message string) {17}18func (n *Node) failureForLeafNode(message string) {19}20func (n *Node) failureForLeafNode(message string) {21}22func (n *Node) failureForLeafNode(message string) {23}24func (n *Node) failureForLeafNode(message string) {25}26func (n *Node) failureForLeafNode(message string) {27}28func (n *Node) failureForLeafNode(message string) {29}30func (n *Node) failureForLeafNode(message string) {31}32func (n *Node) failureForLeafNode(message string) {33}34func (n *Node) failureForLeafNode(message string) {35}

1func main() {2    err = internal.failureForLeafNodeWithMessage("error message")3    fmt.Println(err)4}5func main() {6    err = internal.failureForLeafNodeWithMessage("error message")7    fmt.Println(err)8}9func main() {10    err = internal.failureForLeafNodeWithMessage("error message")11    fmt.Println(err)12}13func main() {14    err = internal.failureForLeafNodeWithMessage("error message")15    fmt.Println(err)16}17func main() {