How to use AfterEach method of ginkgo Package

...30	counter       int3231	before        []func()32	after         []func()33	afterEach     []func()34	justAfterEach []func()35	afterFail     []func()36	started       int3237	failed        bool38	normalTests   int39	focusedTests  int40	focused       bool41}42var (43	currentScope        = &scope{}44	rootScope           = currentScope45	countersInitialized bool46	Context                               = wrapContextFunc(ginkgo.Context, false)47	FContext                              = wrapContextFunc(ginkgo.FContext, true)48	PContext                              = wrapNilContextFunc(ginkgo.PContext)49	XContext                              = wrapNilContextFunc(ginkgo.XContext)50	Describe                              = wrapContextFunc(ginkgo.Describe, false)51	FDescribe                             = wrapContextFunc(ginkgo.FDescribe, true)52	PDescribe                             = wrapNilContextFunc(ginkgo.PDescribe)53	XDescribe                             = wrapNilContextFunc(ginkgo.XDescribe)54	It                                    = wrapItFunc(ginkgo.It, false)55	FIt                                   = wrapItFunc(ginkgo.FIt, true)56	PIt                                   = ginkgo.PIt57	XIt                                   = ginkgo.XIt58	By                                    = ginkgo.By59	JustBeforeEach                        = ginkgo.JustBeforeEach60	BeforeSuite                           = ginkgo.BeforeSuite61	AfterSuite                            = ginkgo.AfterSuite62	Skip                                  = ginkgo.Skip63	Fail                                  = ginkgo.Fail64	CurrentGinkgoTestDescription          = ginkgo.CurrentGinkgoTestDescription65	GinkgoRecover                         = ginkgo.GinkgoRecover66	GinkgoT                               = ginkgo.GinkgoT67	RunSpecs                              = ginkgo.RunSpecs68	RunSpecsWithCustomReporters           = ginkgo.RunSpecsWithCustomReporters69	RunSpecsWithDefaultAndCustomReporters = ginkgo.RunSpecsWithDefaultAndCustomReporters70)71type Done ginkgo.Done72func init() {73	// Only use the Ginkgo options and discard all other options74	args := []string{}75	for _, arg := range os.Args[1:] {76		if strings.Contains(arg, "-ginkgo") {77			args = append(args, arg)78		}79	}80	//Get GinkgoConfig flags81	commandFlags := flag.NewFlagSet("ginkgo", flag.ContinueOnError)82	commandFlags.SetOutput(new(bytes.Buffer))83	config.Flags(commandFlags, "ginkgo", true)84	commandFlags.Parse(args)85}86// BeforeAll runs the function once before any test in context87func BeforeAll(body func()) bool {88	if currentScope != nil {89		if body == nil {90			currentScope.before = nil91			return true92		}93		currentScope.before = append(currentScope.before, body)94		return BeforeEach(func() {})95	}96	return true97}98// AfterAll runs the function once after any test in context99func AfterAll(body func()) bool {100	if currentScope != nil {101		if body == nil {102			currentScope.before = nil103			return true104		}105		currentScope.after = append(currentScope.after, body)106		return AfterEach(func() {})107	}108	return true109}110// JustAfterEach runs the function just after each test, before all AfterEach,111// AfterFailed and AfterAll112func JustAfterEach(body func()) bool {113	if currentScope != nil {114		if body == nil {115			currentScope.before = nil116			return true117		}118		currentScope.justAfterEach = append(currentScope.justAfterEach, body)119		return AfterEach(func() {})120	}121	return true122}123// JustAfterFailed runs the function after test and JustAfterEach if the test124// has failed and before all AfterEach125func AfterFailed(body func()) bool {126	if currentScope != nil {127		if body == nil {128			currentScope.before = nil129			return true130		}131		currentScope.afterFail = append(currentScope.afterFail, body)132		return AfterEach(func() {})133	}134	return true135}136// justAfterEachStatus map to store what `justAfterEach` functions have been137// already executed for the given test138var justAfterEachStatus map[string]bool = map[string]bool{}139// runAllJustAfterEach runs all the `scope.justAfterEach` functions for the140// given scope and parent scopes. This function make sure that all the141// `JustAfterEach` functions are called before AfterEach functions.142func runAllJustAfterEach(cs *scope, testName string) {143	if _, ok := justAfterEachStatus[testName]; ok {144		// JustAfterEach calls are already executed in the children145		return146	}147	for _, body := range cs.justAfterEach {148		body()149	}150	if cs.parent != nil {151		runAllJustAfterEach(cs.parent, testName)152	}153}154// afterFailedStatus map to store what `AfterFail` functions have been155// already executed for the given test.156var afterFailedStatus map[string]bool = map[string]bool{}157// runAllAfterFail runs all the afterFail functions for the given158// scope and parent scopes. This function make sure that all the `AfterFail`159// functions are called before AfterEach.160func runAllAfterFail(cs *scope, testName string) {161	if _, ok := afterFailedStatus[testName]; ok {162		// AfterFailcalls are already executed in the children163		return164	}165	for _, body := range cs.afterFail {166		if ginkgo.CurrentGinkgoTestDescription().Failed {167			body()168		}169	}170	if cs.parent != nil {171		runAllAfterFail(cs.parent, testName)172	}173}174// RunAfterEach is a wrapper that executes all AfterEach functions that are175// stored in cs.afterEach array.176func RunAfterEach(cs *scope) {177	if cs == nil {178		return179	}180	testName := ginkgo.CurrentGinkgoTestDescription().FullTestText181	runAllJustAfterEach(cs, testName)182	justAfterEachStatus[testName] = true183	runAllAfterFail(cs, testName)184	afterFailedStatus[testName] = true185	for _, body := range cs.afterEach {186		body()187	}188	// Only run afterAll when all the counters are 0 and all afterEach are executed189	after := func() {190		if cs.counter == 0 && cs.after != nil {191			for _, after := range cs.after {192				after()193			}194		}195	}196	after()197}198// AfterEach runs the function after each test in context199func AfterEach(body func(), timeout ...float64) bool {200	if currentScope == nil {201		return ginkgo.AfterEach(body, timeout...)202	}203	cs := currentScope204	result := true205	if cs.afterEach == nil {206		// If no scope, register only one AfterEach in the scope, after that207		// RunAfterEeach will run all afterEach functions registered in the208		// scope.209		fn := func() {210			RunAfterEach(cs)211		}212		result = ginkgo.AfterEach(fn, timeout...)213	}214	cs.afterEach = append(cs.afterEach, body)215	return result216}217// BeforeEach runs the function before each test in context218func BeforeEach(body interface{}, timeout ...float64) bool {219	if currentScope == nil {220		return ginkgo.BeforeEach(body, timeout...)221	}222	cs := currentScope223	before := func() {224		if atomic.CompareAndSwapInt32(&cs.started, 0, 1) && cs.before != nil {225			defer func() {226				if r := recover(); r != nil {...

1import (2var _ = Describe("AfterEach", func() {3	AfterEach(func() {4		println("AfterEach")5	})6	It("should print AfterEach", func() {7		println("It")8	})9})10import (11var _ = Describe("AfterSuite", func() {12	AfterSuite(func() {13		println("AfterSuite")14	})15	It("should print AfterSuite", func() {16		println("It")17	})18})19import (20var _ = Describe("AfterEach", func() {21	AfterEach(func() {22		println("AfterEach")23	})24	AfterSuite(func() {25		println("AfterSuite")26	})27	It("should print AfterEach and AfterSuite", func() {28		println("It")29	})30})31import (32var _ = Describe("AfterEach", func() {33	AfterEach(func() {34		println("AfterEach")35	})36	AfterSuite(func() {37		println("AfterSuite")38	})39	It("should print AfterEach and AfterSuite", func() {40		println("It")41	})42})43import (44var _ = Describe("AfterEach", func() {45	AfterEach(func() {46		println("AfterEach")47	})48	AfterSuite(func() {49		println("AfterSuite")50	})51	It("should print AfterEach and AfterSuite", func() {52		println("It")53	})54})55import (56var _ = Describe("AfterEach", func() {57	AfterEach(func() {58		println("AfterEach")59	})60	AfterSuite(func() {61		println("AfterSuite")62	})63	It("should print AfterEach and AfterSuite", func() {64		println("It")

1import (2var _ = Describe("Test", func() {3	AfterEach(func() {4		println("AfterEach")5	})6	It("Test 1", func() {7		println("Test 1")8	})9	It("Test 2", func() {10		println("Test 2")11	})12})13import (14var _ = Describe("Test", func() {15	AfterEach(func() {16		println("AfterEach")17	})18	AfterEach(func() {19		println("AfterEach 2")20	})21	It("Test 1", func() {22		println("Test 1")23	})24	It("Test 2", func() {25		println("Test 2")26	})27})28import (29var _ = Describe("Test", func() {30	AfterEach(func() {31		println("AfterEach")32	})33	AfterEach(func() {34		println("AfterEach 2")35	})36	Context("Context 1", func() {37		It("Test 1", func() {38			println("Test 1")39		})40	})41	Context("Context 2", func() {42		It("Test 2", func() {43			println("Test 2")44		})45	})46})47import (

1import (2func TestMain(t *testing.T) {3    gomega.RegisterFailHandler(ginkgo.Fail)4    ginkgo.RunSpecs(t, "Main Suite")5}6import (7var _ = ginkgo.Describe("Main", func() {8    var _ = ginkgo.BeforeEach(func() {9        fmt.Println("BeforeEach")10    })11    var _ = ginkgo.AfterEach(func() {12        fmt.Println("AfterEach")13    })14    var _ = ginkgo.It("should print BeforeEach", func() {15        gomega.Expect("BeforeEach").To(gomega.Equal("BeforeEach"))16    })17    var _ = ginkgo.It("should print AfterEach", func() {18        gomega.Expect("AfterEach").To(gomega.Equal("AfterEach"))19    })20})

1AfterEach(func() {2    fmt.Println("After Each")3})4AfterEach(func() {5    fmt.Println("After Each")6})7AfterEach(func() {8    fmt.Println("After Each")9})10AfterEach(func() {11    fmt.Println("After Each")12})13AfterEach(func() {14    fmt.Println("After Each")15})16AfterEach(func() {17    fmt.Println("After Each")18})19AfterEach(func() {20    fmt.Println("After Each")21})22AfterEach(func() {23    fmt.Println("After Each")24})25AfterEach(func() {26    fmt.Println("After Each")27})28AfterEach(func() {29    fmt.Println("After Each")30})31AfterEach(func() {32    fmt.Println("After Each")33})34AfterEach(func() {35    fmt.Println("After Each")36})37AfterEach(func() {38    fmt.Println("After Each")39})40AfterEach(func() {41    fmt.Println("After Each")42})43AfterEach(func() {44    fmt.Println("After Each")45})46AfterEach(func

1AfterEach(func() {2})3AfterEach(func() {4})5AfterEach(func() {6})7AfterEach(func() {8})9AfterEach(func() {10})11AfterEach(func() {12})13AfterEach(func() {14})15AfterEach(func() {16})17AfterEach(func() {18})19AfterEach(func() {20})21AfterEach(func() {22})23AfterEach(func() {24})25AfterEach(func() {26})27AfterEach(func() {28})

1AfterEach(func() {2})3AfterSuite(func() {4})5BeforeEach(func() {6})7BeforeSuite(func() {8})9Describe("Test Suite", func() {10})11FDescribe("Test Suite", func() {12})13FIt("Test Case", func() {14})15FMeasure("Test Case", func(b Benchmarker) {16}, 1)17FSpecify("Test Case", func() {18})19FSpecify("Test Case", func() {20})21It("Test Case", func() {22})23Measure("Test Case", func(b Benchmarker) {24}, 1)25PDescribe("Test Suite", func() {