How to use NewCleanupNode method of internal Package

...442				Ω(node.CodeLocation).Should(Equal(cl))443				Ω(node.NestingLevel).Should(Equal(0))444			})445		})446		Describe("NewCleanupNode", func() {447			var capturedFailure string448			var capturedCL types.CodeLocation449			var failFunc = func(msg string, cl types.CodeLocation) {450				capturedFailure = msg451				capturedCL = cl452			}453			BeforeEach(func() {454				capturedFailure = ""455				capturedCL = types.CodeLocation{}456			})457			Context("when passed no function", func() {458				It("errors", func() {459					node, errs := internal.NewCleanupNode(failFunc, cl)460					Ω(node.IsZero()).Should(BeTrue())461					Ω(errs).Should(ConsistOf(types.GinkgoErrors.DeferCleanupInvalidFunction(cl)))462					Ω(capturedFailure).Should(BeZero())463					Ω(capturedCL).Should(BeZero())464				})465			})466			Context("when passed a function that returns too many values", func() {467				It("errors", func() {468					node, errs := internal.NewCleanupNode(failFunc, cl, func() (int, error) {469						return 0, nil470					})471					Ω(node.IsZero()).Should(BeTrue())472					Ω(errs).Should(ConsistOf(types.GinkgoErrors.DeferCleanupInvalidFunction(cl)))473					Ω(capturedFailure).Should(BeZero())474					Ω(capturedCL).Should(BeZero())475				})476			})477			Context("when passed a function that does not return", func() {478				It("creates a body that runs the function and never calls the fail handler", func() {479					didRun := false480					node, errs := internal.NewCleanupNode(failFunc, cl, func() {481						didRun = true482					})483					Ω(node.CodeLocation).Should(Equal(cl))484					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))485					Ω(errs).Should(BeEmpty())486					node.Body()487					Ω(didRun).Should(BeTrue())488					Ω(capturedFailure).Should(BeZero())489					Ω(capturedCL).Should(BeZero())490				})491			})492			Context("when passed a function that returns nil", func() {493				It("creates a body that runs the function and does not call the fail handler", func() {494					didRun := false495					node, errs := internal.NewCleanupNode(failFunc, cl, func() error {496						didRun = true497						return nil498					})499					Ω(node.CodeLocation).Should(Equal(cl))500					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))501					Ω(errs).Should(BeEmpty())502					node.Body()503					Ω(didRun).Should(BeTrue())504					Ω(capturedFailure).Should(BeZero())505					Ω(capturedCL).Should(BeZero())506				})507			})508			Context("when passed a function that returns an error", func() {509				It("creates a body that runs the function and does not call the fail handler", func() {510					didRun := false511					node, errs := internal.NewCleanupNode(failFunc, cl, func() error {512						didRun = true513						return fmt.Errorf("welp")514					})515					Ω(node.CodeLocation).Should(Equal(cl))516					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))517					Ω(errs).Should(BeEmpty())518					node.Body()519					Ω(didRun).Should(BeTrue())520					Ω(capturedFailure).Should(Equal("DeferCleanup callback returned error: welp"))521					Ω(capturedCL).Should(Equal(cl))522				})523			})524			Context("when passed a function that takes arguments, and those arguments", func() {525				It("creates a body that runs the function and passes in those arguments", func() {526					var inA, inB, inC = "A", 2, "C"527					var receivedA, receivedC string528					var receivedB int529					node, errs := internal.NewCleanupNode(failFunc, cl, func(a string, b int, c string) error {530						receivedA, receivedB, receivedC = a, b, c531						return nil532					}, inA, inB, inC)533					inA, inB, inC = "floop", 3, "flarp"534					Ω(node.CodeLocation).Should(Equal(cl))535					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))536					Ω(errs).Should(BeEmpty())537					node.Body()538					Ω(receivedA).Should(Equal("A"))539					Ω(receivedB).Should(Equal(2))540					Ω(receivedC).Should(Equal("C"))541					Ω(capturedFailure).Should(BeZero())542					Ω(capturedCL).Should(BeZero())543				})544			})545			Context("controlling the cleanup's code location", func() {546				It("computes its own when one is not provided", func() {547					node, errs := func() (internal.Node, []error) {548						return internal.NewCleanupNode(failFunc, func() error {549							return fmt.Errorf("welp")550						})551					}()552					localCL := types.NewCodeLocation(0)553					localCL.LineNumber -= 1554					Ω(node.CodeLocation).Should(Equal(localCL))555					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))556					Ω(errs).Should(BeEmpty())557					node.Body()558					Ω(capturedFailure).Should(Equal("DeferCleanup callback returned error: welp"))559					Ω(capturedCL).Should(Equal(localCL))560				})561				It("can accept an Offset", func() {562					node, errs := func() (internal.Node, []error) {563						return func() (internal.Node, []error) {564							return internal.NewCleanupNode(failFunc, Offset(1), func() error {565								return fmt.Errorf("welp")566							})567						}()568					}()569					localCL := types.NewCodeLocation(0)570					localCL.LineNumber -= 1571					Ω(node.CodeLocation).Should(Equal(localCL))572					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))573					Ω(errs).Should(BeEmpty())574					node.Body()575					Ω(capturedFailure).Should(Equal("DeferCleanup callback returned error: welp"))576					Ω(capturedCL).Should(Equal(localCL))577				})578				It("can accept a code location", func() {579					node, errs := internal.NewCleanupNode(failFunc, cl, func() error {580						return fmt.Errorf("welp")581					})582					Ω(node.CodeLocation).Should(Equal(cl))583					Ω(node.NodeType).Should(Equal(types.NodeTypeCleanupInvalid))584					Ω(errs).Should(BeEmpty())585					node.Body()586					Ω(capturedFailure).Should(Equal("DeferCleanup callback returned error: welp"))587					Ω(capturedCL).Should(Equal(cl))588				})589			})590		})591	})592	Describe("IsZero()", func() {593		It("returns true if the node is zero", func() {...

...287			Context("when pushing a cleanup node within a cleanup node", func() {288				It("errors", func() {289					var errors = make([]error, 3)290					errors[0] = suite.PushNode(N(ntIt, "It", func() {291						cleanupNode, _ := internal.NewCleanupNode(nil, types.NewCustomCodeLocation("outerCleanup"), func() {292							innerCleanupNode, _ := internal.NewCleanupNode(nil, cl, func() {})293							errors[2] = suite.PushNode(innerCleanupNode)294						})295						errors[1] = suite.PushNode(cleanupNode)296					}))297					Ω(errors[0]).ShouldNot(HaveOccurred())298					Ω(suite.BuildTree()).Should(Succeed())299					suite.Run("suite", Labels{}, "/path/to/suite", failer, reporter, writer, outputInterceptor, interruptHandler, client, conf)300					Ω(errors[1]).ShouldNot(HaveOccurred())301					Ω(errors[2]).Should(MatchError(types.GinkgoErrors.PushingCleanupInCleanupNode(cl)))302				})303			})304		})305		Describe("ReportEntries", func() {306			Context("when adding a report entry outside of the run phase", func() {...

1func main() {2	cleanupNode := internal.NewCleanupNode()3	cleanupNode.Cleanup()4}5type CleanupNode struct {6}7func NewCleanupNode() *CleanupNode {8	return &CleanupNode{}9}10func (c *CleanupNode) Cleanup() {11}12import (13func TestCleanupNode(t *testing.T) {14}15type CleanupNode struct {16}17func NewCleanupNode() *CleanupNode {18	return &CleanupNode{}19}20func (c *CleanupNode) Cleanup() {21}22import (23func TestCleanupNode(t *testing.T) {24	cleanupNode := internal.NewCleanupNode()25	cleanupNode.Cleanup()

1import "fmt"2import "mylib"3func main() {4        var x = mylib.NewCleanupNode()5        x.NewCleanupNode()6        fmt.Println("Hello, playground")7}8type CleanupNode struct {9}10func NewCleanupNode() *CleanupNode {11        return &CleanupNode{}12}

1If you want to use the internal package in the same module, you need to use the following import statement:2import "github.com/username/project/internal"3If you want to use the internal package in a different module, you need to use the following import statement:4import "github.com/username/project/v2/internal"5If you want to use the internal package in a different module, you need to use the following import statement:6import "github.com/username/project/v2/internal"

1type cleanupNode struct {2}3func NewCleanupNode() *cleanupNode {4    return &cleanupNode{}5}6type cleanupNode struct {7}8func NewCleanupNode() *cleanupNode {9    return &cleanupNode{}10}11If we want to use the internal methods of x package in another package, we have to import this internal package. For example, if we want to use the internal methods of x package in a package called y, we have to import the internal package of x in the y package. The code will look like this:12type cleanupNode struct {13}14func NewCleanupNode() *cleanupNode {15    return &cleanupNode{}16}17type cleanupNode struct {18}19func NewCleanupNode() *cleanupNode {20    return &cleanupNode{}21}22import "internal/x"23In the above code, we have imported the internal package of x in the y package. We can use the internal methods of x package in the y

1import (2func main() {3    var c = new(internal.CleanupNode)4    c.NewCleanupNode()5    fmt.Println(c.Value)6}7type CleanupNode struct {8}9func (c *CleanupNode) NewCleanupNode() {10}