How to use PushNode method of internal Package

...312// pushNode is used by the various test construction DSL methods to push nodes onto the suite313// it handles returned errors, emits a detailed error message to help the user learn what they may have done wrong, then exits314func pushNode(node internal.Node, errors []error) bool {315	exitIfErrors(errors)316	exitIfErr(global.Suite.PushNode(node))317	return true318}319/*320Describe nodes are Container nodes that allow you to organize your specs.  A Describe node's closure can contain any number of321Setup nodes (e.g. BeforeEach, AfterEach, JustBeforeEach), and Subject nodes (i.e. It).322Context and When nodes are aliases for Describe - use whichever gives your suite a better narrative flow.  It is idomatic323to Describe the behavior of an object or function and, within that Describe, outline a number of Contexts and Whens.324You can learn more at https://onsi.github.io/ginkgo/#organizing-specs-with-container-nodes325In addition, container nodes can be decorated with a variety of decorators.  You can learn more here: https://onsi.github.io/ginkgo/#decorator-reference326*/327func Describe(text string, args ...interface{}) bool {328	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, text, args...))329}330/*...

...40	Describe("Constructing Trees", func() {41		Describe("PhaseBuildTopLevel vs PhaseBuildTree", func() {42			var err1, err2, err3 error43			BeforeEach(func() {44				err1 = suite.PushNode(N(ntCon, "a top-level container", func() {45					rt.Run("traversing outer")46					err2 = suite.PushNode(N(ntCon, "a nested container", func() {47						rt.Run("traversing nested")48						err3 = suite.PushNode(N(ntIt, "an it", rt.T("running it")))49					}))50				}))51			})52			It("only traverses top-level containers when told to BuildTree", func() {53				fmt.Fprintln(GinkgoWriter, "HELLO!")54				Ω(rt).Should(HaveTrackedNothing())55				Ω(suite.BuildTree()).Should(Succeed())56				Ω(rt).Should(HaveTracked("traversing outer", "traversing nested"))57				rt.Reset()58				suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)59				Ω(rt).Should(HaveTracked("running it"))60				Ω(err1).ShouldNot(HaveOccurred())61				Ω(err2).ShouldNot(HaveOccurred())62				Ω(err3).ShouldNot(HaveOccurred())63			})64		})65		Describe("InRunPhase", func() {66			It("returns true when in the run phase and false when not in the run phase", func() {67				falsey := true68				truey := false69				err := suite.PushNode(N(ntCon, "a top-level container", func() {70					falsey = suite.InRunPhase()71					suite.PushNode(N(ntIt, "an it", func() {72						truey = suite.InRunPhase()73					}))74				}))75				Ω(suite.BuildTree()).Should(Succeed())76				suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)77				Ω(err).ShouldNot(HaveOccurred())78				Ω(truey).Should(BeTrue())79				Ω(falsey).Should(BeFalse())80			})81		})82		Context("when pushing nodes during PhaseRun", func() {83			var pushNodeErrDuringRun error84			BeforeEach(func() {85				err := suite.PushNode(N(ntCon, "a top-level container", func() {86					suite.PushNode(N(ntIt, "an it", func() {87						rt.Run("in it")88						pushNodeErrDuringRun = suite.PushNode(N(ntIt, "oops - illegal operation", cl, rt.T("illegal")))89					}))90				}))91				Ω(err).ShouldNot(HaveOccurred())92				Ω(suite.BuildTree()).Should(Succeed())93			})94			It("errors", func() {95				suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)96				Ω(pushNodeErrDuringRun).Should(HaveOccurred())97				Ω(rt).Should(HaveTracked("in it"))98			})99		})100		Context("when the user attempts to fail during PhaseBuildTree", func() {101			BeforeEach(func() {102				suite.PushNode(N(ntCon, "a top-level container", func() {103					failer.Fail("boom", cl)104					panic("simulate ginkgo panic")105				}))106			})107			It("errors", func() {108				err := suite.BuildTree()109				Ω(err.Error()).Should(ContainSubstring(cl.String()))110				Ω(err.Error()).Should(ContainSubstring("simulate ginkgo panic"))111			})112		})113		Context("when the user panics during PhaseBuildTree", func() {114			BeforeEach(func() {115				suite.PushNode(N(ntCon, "a top-level container", func() {116					panic("boom")117				}))118			})119			It("errors", func() {120				err := suite.BuildTree()121				Ω(err).Should(HaveOccurred())122				Ω(err.Error()).Should(ContainSubstring("boom"))123			})124		})125		Describe("Suite Nodes", func() {126			Context("when pushing suite nodes at the top level", func() {127				BeforeEach(func() {128					err := suite.PushNode(N(types.NodeTypeBeforeSuite))129					Ω(err).ShouldNot(HaveOccurred())130					err = suite.PushNode(N(types.NodeTypeAfterSuite))131					Ω(err).ShouldNot(HaveOccurred())132				})133				Context("when pushing more than one BeforeSuite node", func() {134					It("errors", func() {135						err := suite.PushNode(N(types.NodeTypeBeforeSuite))136						Ω(err).Should(HaveOccurred())137						err = suite.PushNode(N(types.NodeTypeSynchronizedBeforeSuite))138						Ω(err).Should(HaveOccurred())139					})140				})141				Context("when pushing more than one AfterSuite node", func() {142					It("errors", func() {143						err := suite.PushNode(N(types.NodeTypeAfterSuite))144						Ω(err).Should(HaveOccurred())145						err = suite.PushNode(N(types.NodeTypeSynchronizedAfterSuite))146						Ω(err).Should(HaveOccurred())147					})148				})149			})150			Context("when pushing a serial node in an ordered container", func() {151				Context("when the outer-most ordered container is marked serial", func() {152					It("succeeds", func() {153						var errors = make([]error, 3)154						errors[0] = suite.PushNode(N(ntCon, "top-level-container", Ordered, Serial, func() {155							errors[1] = suite.PushNode(N(ntCon, "inner-container", func() {156								errors[2] = suite.PushNode(N(ntIt, "it", Serial, func() {}))157							}))158						}))159						Ω(errors[0]).ShouldNot(HaveOccurred())160						Ω(suite.BuildTree()).Should(Succeed())161						Ω(errors[1]).ShouldNot(HaveOccurred())162						Ω(errors[2]).ShouldNot(HaveOccurred())163					})164				})165				Context("when the outer-most ordered container is not marked serial", func() {166					It("errors", func() {167						var errors = make([]error, 3)168						errors[0] = suite.PushNode(N(ntCon, "top-level-container", Ordered, func() {169							errors[1] = suite.PushNode(N(ntCon, "inner-container", func() {170								errors[2] = suite.PushNode(N(ntIt, "it", Serial, cl, func() {}))171							}))172						}))173						Ω(errors[0]).ShouldNot(HaveOccurred())174						Ω(suite.BuildTree()).Should(Succeed())175						Ω(errors[1]).ShouldNot(HaveOccurred())176						Ω(errors[2]).Should(MatchError(types.GinkgoErrors.InvalidSerialNodeInNonSerialOrderedContainer(cl, ntIt)))177					})178				})179			})180			Context("when pushing BeforeAll and AfterAll nodes", func() {181				Context("in an ordered container", func() {182					It("succeeds", func() {183						var errors = make([]error, 3)184						errors[0] = suite.PushNode(N(ntCon, "top-level-container", Ordered, func() {185							errors[1] = suite.PushNode(N(types.NodeTypeBeforeAll, func() {}))186							errors[2] = suite.PushNode(N(types.NodeTypeAfterAll, func() {}))187						}))188						Ω(errors[0]).ShouldNot(HaveOccurred())189						Ω(suite.BuildTree()).Should(Succeed())190						Ω(errors[1]).ShouldNot(HaveOccurred())191						Ω(errors[2]).ShouldNot(HaveOccurred())192					})193				})194				Context("anywhere else", func() {195					It("errors", func() {196						var errors = make([]error, 3)197						errors[0] = suite.PushNode(N(ntCon, "top-level-container", func() {198							errors[1] = suite.PushNode(N(types.NodeTypeBeforeAll, cl, func() {}))199							errors[2] = suite.PushNode(N(types.NodeTypeAfterAll, cl, func() {}))200						}))201						Ω(errors[0]).ShouldNot(HaveOccurred())202						Ω(suite.BuildTree()).Should(Succeed())203						Ω(errors[1]).Should(MatchError(types.GinkgoErrors.SetupNodeNotInOrderedContainer(cl, types.NodeTypeBeforeAll)))204						Ω(errors[2]).Should(MatchError(types.GinkgoErrors.SetupNodeNotInOrderedContainer(cl, types.NodeTypeAfterAll)))205					})206				})207			})208			Context("when pushing a suite node during PhaseBuildTree", func() {209				It("errors", func() {210					var pushSuiteNodeErr error211					err := suite.PushNode(N(ntCon, "top-level-container", func() {212						pushSuiteNodeErr = suite.PushNode(N(types.NodeTypeBeforeSuite, cl))213					}))214					Ω(err).ShouldNot(HaveOccurred())215					Ω(suite.BuildTree()).Should(Succeed())216					Ω(pushSuiteNodeErr).Should(HaveOccurred())217				})218			})219			Context("when pushing a suite node during PhaseRun", func() {220				It("errors", func() {221					var pushSuiteNodeErr error222					err := suite.PushNode(N(ntIt, "top-level it", func() {223						pushSuiteNodeErr = suite.PushNode(N(types.NodeTypeBeforeSuite, cl))224					}))225					Ω(err).ShouldNot(HaveOccurred())226					Ω(suite.BuildTree()).Should(Succeed())227					suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)228					Ω(pushSuiteNodeErr).Should(HaveOccurred())229				})230			})231		})232		Describe("Cleanup Nodes", func() {233			Context("when pushing a cleanup node during PhaseTopLevel", func() {234				It("errors", func() {235					err := suite.PushNode(N(types.NodeTypeCleanupInvalid, cl))236					Ω(err).Should(MatchError(types.GinkgoErrors.PushingCleanupNodeDuringTreeConstruction(cl)))237				})238			})239			Context("when pushing a cleanup node during PhaseBuildTree", func() {240				It("errors", func() {241					var errors = make([]error, 2)242					errors[0] = suite.PushNode(N(ntCon, "container", func() {243						errors[1] = suite.PushNode(N(types.NodeTypeCleanupInvalid, cl))244					}))245					Ω(errors[0]).ShouldNot(HaveOccurred())246					Ω(suite.BuildTree()).Should(Succeed())247					Ω(errors[1]).Should(MatchError(types.GinkgoErrors.PushingCleanupNodeDuringTreeConstruction(cl)))248				})249			})250			Context("when pushing a cleanup node in a ReportBeforeEach node", func() {251				It("errors", func() {252					var errors = make([]error, 4)253					reportBeforeEachNode, _ := internal.NewReportBeforeEachNode(func(_ types.SpecReport) {254						errors[3] = suite.PushNode(N(types.NodeTypeCleanupInvalid, cl))255					}, types.NewCodeLocation(0))256					errors[0] = suite.PushNode(N(ntCon, "container", func() {257						errors[1] = suite.PushNode(reportBeforeEachNode)258						errors[2] = suite.PushNode(N(ntIt, "test"))259					}))260					Ω(errors[0]).ShouldNot(HaveOccurred())261					Ω(suite.BuildTree()).Should(Succeed())262					Ω(errors[1]).ShouldNot(HaveOccurred())263					Ω(errors[2]).ShouldNot(HaveOccurred())264					suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)265					Ω(errors[3]).Should(MatchError(types.GinkgoErrors.PushingCleanupInReportingNode(cl, types.NodeTypeReportBeforeEach)))266				})267			})268			Context("when pushing a cleanup node in a ReportAfterEach node", func() {269				It("errors", func() {270					var errors = make([]error, 4)271					reportAfterEachNode, _ := internal.NewReportAfterEachNode(func(_ types.SpecReport) {272						errors[3] = suite.PushNode(N(types.NodeTypeCleanupInvalid, cl))273					}, types.NewCodeLocation(0))274					errors[0] = suite.PushNode(N(ntCon, "container", func() {275						errors[1] = suite.PushNode(N(ntIt, "test"))276						errors[2] = suite.PushNode(reportAfterEachNode)277					}))278					Ω(errors[0]).ShouldNot(HaveOccurred())279					Ω(suite.BuildTree()).Should(Succeed())280					Ω(errors[1]).ShouldNot(HaveOccurred())281					Ω(errors[2]).ShouldNot(HaveOccurred())282					suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)283					Ω(errors[3]).Should(MatchError(types.GinkgoErrors.PushingCleanupInReportingNode(cl, types.NodeTypeReportAfterEach)))284				})285			})286			Context("when pushing a cleanup node in a ReportAfterSuite node", func() {287				It("errors", func() {288					var errors = make([]error, 4)289					reportAfterSuiteNode, _ := internal.NewReportAfterSuiteNode("report", func(_ types.Report) {290						errors[3] = suite.PushNode(N(types.NodeTypeCleanupInvalid, cl))291					}, types.NewCodeLocation(0))292					errors[0] = suite.PushNode(N(ntCon, "container", func() {293						errors[2] = suite.PushNode(N(ntIt, "test"))294					}))295					errors[1] = suite.PushNode(reportAfterSuiteNode)296					Ω(errors[0]).ShouldNot(HaveOccurred())297					Ω(errors[1]).ShouldNot(HaveOccurred())298					Ω(suite.BuildTree()).Should(Succeed())299					Ω(errors[2]).ShouldNot(HaveOccurred())300					suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)301					Ω(errors[3]).Should(MatchError(types.GinkgoErrors.PushingCleanupInReportingNode(cl, types.NodeTypeReportAfterSuite)))302				})303			})304			Context("when pushing a cleanup node within a cleanup node", func() {305				It("errors", func() {306					var errors = make([]error, 3)307					errors[0] = suite.PushNode(N(ntIt, "It", func() {308						cleanupNode, _ := internal.NewCleanupNode(nil, types.NewCustomCodeLocation("outerCleanup"), func() {309							innerCleanupNode, _ := internal.NewCleanupNode(nil, cl, func() {})310							errors[2] = suite.PushNode(innerCleanupNode)311						})312						errors[1] = suite.PushNode(cleanupNode)313					}))314					Ω(errors[0]).ShouldNot(HaveOccurred())315					Ω(suite.BuildTree()).Should(Succeed())316					suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)317					Ω(errors[1]).ShouldNot(HaveOccurred())318					Ω(errors[2]).Should(MatchError(types.GinkgoErrors.PushingCleanupInCleanupNode(cl)))319				})320			})321		})322		Describe("ReportEntries", func() {323			Context("when adding a report entry outside of the run phase", func() {324				It("errors", func() {325					entry, err := internal.NewReportEntry("name", cl)326					Ω(err).ShouldNot(HaveOccurred())...

...13	}14}15// ParseRelationshipsPattern parse a relationships pattern16func (ep *PatternParser) ParseRelationshipsPattern(q *query.QueryRelationshipsPattern, scope Scope) error {17	_, i1, err := ep.queryGraph.PushNode(q.QueryNodePattern, scope)18	if err != nil {19		return err20	}21	for _, z := range q.QueryPatternElementChains {22		_, i2, err := ep.queryGraph.PushNode(z.NodePattern, scope)23		if err != nil {24			return err25		}26		_, _, err = ep.queryGraph.PushRelation(z.RelationshipPattern, i1, i2, scope)27		if err != nil {28			return err29		}30		i1 = i231	}32	return nil33}34// ParsePatternElement parse a pattern element35func (ep *PatternParser) ParsePatternElement(q *query.QueryPatternElement, scope Scope) error {36	_, i1, err := ep.queryGraph.PushNode(q.QueryNodePattern, scope)37	if err != nil {38		return err39	}40	for _, z := range q.QueryPatternElementChains {41		_, i2, err := ep.queryGraph.PushNode(z.NodePattern, scope)42		if err != nil {43			return err44		}45		_, _, err = ep.queryGraph.PushRelation(z.RelationshipPattern, i1, i2, scope)46		if err != nil {47			return err48		}49		i1 = i250	}51	return nil52}...

1func (c *C) PushNode(n *Node) {2    c.pushNode(n)3}4func (c *C) PushNode(n *Node) {5    c.pushNode(n)6}7func (c *C) PushNode(n *Node) {8    c.pushNode(n)9}10func (c *C) PushNode(n *Node) {11    c.pushNode(n)12}13func (c *C) PushNode(n *Node) {14    c.pushNode(n)15}16func (c *C) PushNode(n *Node) {17    c.pushNode(n)18}19func (c *C) PushNode(n *Node) {20    c.pushNode(n)21}22func (c *C) PushNode(n *Node) {23    c.pushNode(n)24}25func (c *C) PushNode(n *Node) {26    c.pushNode(n)27}28func (c *C) PushNode(n *Node) {29    c.pushNode(n)30}31func (c *C) PushNode(n *Node) {32    c.pushNode(n)33}34func (c *C) PushNode(n *Node) {35    c.pushNode(n)36}37func (c *C) PushNode(n *Node) {38    c.pushNode(n)39}40func (c *

1import (2func main() {3	s := stack.NewStack()4	s.PushNode(1)5	s.PushNode(2)6	s.PushNode(3)7	s.PushNode(4)8	s.PushNode(5)9	s.PushNode(6)10	s.PushNode(7)11	s.PushNode(8)12	s.PushNode(9)13	s.PushNode(10)14	fmt.Println(s.PopNode())15	fmt.Println(s.Pop

1func main() {2    s := new(Stack)3    s.PushNode("to")4    s.PushNode("be")5    s.PushNode("or")6    s.PushNode("not")7    s.PushNode("to")8    for s.Len() > 0 {9        fmt.Printf("%s ", s.PopNode())10    }11}

1import (2func main() {3    var obj = new(package1.Node)4    obj.PushNode(1)5    obj.PushNode(2)6    obj.PushNode(3)7    fmt.Println(obj)8}9import (10func main() {11    var obj = new(package1.Node)12    obj.PushNode(4)13    obj.PushNode(5)14    obj.PushNode(6)15    fmt.Println(obj)16}17&{[1 2 3 0 0 0 0 0 0 0] 2}18&{[4 5 6 0 0 0 0 0 0 0] 2}