How to use PostSuiteDidEnd method of parallel_support Package

...92							})93						})94						Context("when SuiteDidEnd start arriving", func() {95							BeforeEach(func() {96								Ω(client.PostSuiteDidEnd(endReport1)).Should(Succeed())97								Ω(client.PostSuiteDidEnd(endReport2)).Should(Succeed())98							})99							It("does not forward them yet...", func() {100								Ω(reporter.End).Should(BeZero())101							})102							It("doesn't signal it's done", func() {103								Ω(server.GetSuiteDone()).ShouldNot(BeClosed())104							})105							Context("when the final SuiteDidEnd arrive", func() {106								BeforeEach(func() {107									Ω(client.PostSuiteDidEnd(endReport3)).Should(Succeed())108								})109								It("forwards the aggregation of all received end summaries", func() {110									Ω(reporter.End.StartTime.Unix()).Should(BeNumerically("~", t.Add(-2*time.Second).Unix()))111									Ω(reporter.End.EndTime.Unix()).Should(BeNumerically("~", t.Add(2*time.Second).Unix()))112									Ω(reporter.End.RunTime).Should(BeNumerically("~", 4*time.Second))113									Ω(reporter.End.SuiteSucceeded).Should(BeFalse())114									Ω(reporter.End.SpecReports).Should(ConsistOf(specReportA, specReportB, specReportC))115								})116								It("should signal it's done", func() {117									Ω(server.GetSuiteDone()).Should(BeClosed())118								})119							})120						})121					})122				})123			})124			Describe("supporting ReportEntries (which RPC struggled with when I first implemented it)", func() {125				BeforeEach(func() {126					Ω(client.PostSuiteWillBegin(types.Report{SuiteDescription: "my sweet suite"})).Should(Succeed())127					Ω(client.PostSuiteWillBegin(types.Report{SuiteDescription: "my sweet suite"})).Should(Succeed())128					Ω(client.PostSuiteWillBegin(types.Report{SuiteDescription: "my sweet suite"})).Should(Succeed())129				})130				It("can pass in ReportEntries that include custom types", func() {131					cl := types.NewCodeLocation(0)132					entry, err := internal.NewReportEntry("No Value Entry", cl)133					Ω(err).ShouldNot(HaveOccurred())134					Ω(client.PostDidRun(types.SpecReport{135						LeafNodeText:  "no-value",136						ReportEntries: types.ReportEntries{entry},137					})).Should(Succeed())138					entry, err = internal.NewReportEntry("String Value Entry", cl, "The String")139					Ω(err).ShouldNot(HaveOccurred())140					Ω(client.PostDidRun(types.SpecReport{141						LeafNodeText:  "string-value",142						ReportEntries: types.ReportEntries{entry},143					})).Should(Succeed())144					entry, err = internal.NewReportEntry("Custom Type Value Entry", cl, ColorableStringerStruct{Label: "apples", Count: 17})145					Ω(err).ShouldNot(HaveOccurred())146					Ω(client.PostDidRun(types.SpecReport{147						LeafNodeText:  "custom-value",148						ReportEntries: types.ReportEntries{entry},149					})).Should(Succeed())150					Ω(reporter.Did.Find("no-value").ReportEntries[0].Name).Should(Equal("No Value Entry"))151					Ω(reporter.Did.Find("no-value").ReportEntries[0].StringRepresentation()).Should(Equal(""))152					Ω(reporter.Did.Find("string-value").ReportEntries[0].Name).Should(Equal("String Value Entry"))153					Ω(reporter.Did.Find("string-value").ReportEntries[0].StringRepresentation()).Should(Equal("The String"))154					Ω(reporter.Did.Find("custom-value").ReportEntries[0].Name).Should(Equal("Custom Type Value Entry"))155					Ω(reporter.Did.Find("custom-value").ReportEntries[0].StringRepresentation()).Should(Equal("{{red}}apples {{green}}17{{/}}"))156				})157			})158			Describe("Streaming output", func() {159				It("is configured to stream to stdout", func() {160					server, err := parallel_support.NewServer(3, reporter)161					Ω(err).ShouldNot(HaveOccurred())162					Ω(server.GetOutputDestination().(*os.File).Fd()).Should(Equal(uintptr(1)))163				})164				It("streams output to the provided buffer", func() {165					n, err := client.Write([]byte("hello"))166					Ω(n).Should(Equal(5))167					Ω(err).ShouldNot(HaveOccurred())168					Ω(buffer).Should(gbytes.Say("hello"))169				})170			})171			Describe("Synchronization endpoints", func() {172				var proc1Exited, proc2Exited, proc3Exited chan interface{}173				BeforeEach(func() {174					proc1Exited, proc2Exited, proc3Exited = make(chan interface{}), make(chan interface{}), make(chan interface{})175					aliveFunc := func(c chan interface{}) func() bool {176						return func() bool {177							select {178							case <-c:179								return false180							default:181								return true182							}183						}184					}185					server.RegisterAlive(1, aliveFunc(proc1Exited))186					server.RegisterAlive(2, aliveFunc(proc2Exited))187					server.RegisterAlive(3, aliveFunc(proc3Exited))188				})189				Describe("Managing SynchronizedBeforeSuite synchronization", func() {190					Context("when proc 1 succeeds and returns data", func() {191						It("passes that data along to other procs", func() {192							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStatePassed, []byte("hello there"))).Should(Succeed())193							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()194							Ω(state).Should(Equal(types.SpecStatePassed))195							Ω(data).Should(Equal([]byte("hello there")))196							Ω(err).ShouldNot(HaveOccurred())197						})198					})199					Context("when proc 1 succeeds and the data happens to be nil", func() {200						It("passes reports success and returns nil", func() {201							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStatePassed, nil)).Should(Succeed())202							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()203							Ω(state).Should(Equal(types.SpecStatePassed))204							Ω(data).Should(BeNil())205							Ω(err).ShouldNot(HaveOccurred())206						})207					})208					Context("when proc 1 is skipped", func() {209						It("passes that state information along to the other procs", func() {210							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStateSkipped, nil)).Should(Succeed())211							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()212							Ω(state).Should(Equal(types.SpecStateSkipped))213							Ω(data).Should(BeNil())214							Ω(err).ShouldNot(HaveOccurred())215						})216					})217					Context("when proc 1 fails", func() {218						It("passes that state information along to the other procs", func() {219							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStateFailed, nil)).Should(Succeed())220							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()221							Ω(state).Should(Equal(types.SpecStateFailed))222							Ω(data).Should(BeNil())223							Ω(err).ShouldNot(HaveOccurred())224						})225					})226					Context("when proc 1 disappears before reporting back", func() {227						It("returns a meaningful error", func() {228							close(proc1Exited)229							state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()230							Ω(state).Should(Equal(types.SpecStateInvalid))231							Ω(data).Should(BeNil())232							Ω(err).Should(MatchError(types.GinkgoErrors.SynchronizedBeforeSuiteDisappearedOnProc1()))233						})234					})235					Context("when proc 1 hasn't responded yet", func() {236						It("blocks until it does", func() {237							done := make(chan interface{})238							go func() {239								defer GinkgoRecover()240								state, data, err := client.BlockUntilSynchronizedBeforeSuiteData()241								Ω(state).Should(Equal(types.SpecStatePassed))242								Ω(data).Should(Equal([]byte("hello there")))243								Ω(err).ShouldNot(HaveOccurred())244								close(done)245							}()246							Consistently(done).ShouldNot(BeClosed())247							Ω(client.PostSynchronizedBeforeSuiteCompleted(types.SpecStatePassed, []byte("hello there"))).Should(Succeed())248							Eventually(done).Should(BeClosed())249						})250					})251				})252				Describe("BlockUntilNonprimaryProcsHaveFinished", func() {253					It("blocks until non-primary procs exit", func() {254						done := make(chan interface{})255						go func() {256							defer GinkgoRecover()257							Ω(client.BlockUntilNonprimaryProcsHaveFinished()).Should(Succeed())258							close(done)259						}()260						Consistently(done).ShouldNot(BeClosed())261						close(proc2Exited)262						Consistently(done).ShouldNot(BeClosed())263						close(proc3Exited)264						Eventually(done).Should(BeClosed())265					})266				})267				Describe("BlockUntilAggregatedNonprimaryProcsReport", func() {268					var specReportA, specReportB types.SpecReport269					var endReport2, endReport3 types.Report270					BeforeEach(func() {271						specReportA = types.SpecReport{LeafNodeText: "A"}272						specReportB = types.SpecReport{LeafNodeText: "B"}273						endReport2 = types.Report{SpecReports: types.SpecReports{specReportA}}274						endReport3 = types.Report{SpecReports: types.SpecReports{specReportB}}275					})276					It("blocks until all non-primary procs exit, then returns the aggregated report", func() {277						done := make(chan interface{})278						go func() {279							defer GinkgoRecover()280							report, err := client.BlockUntilAggregatedNonprimaryProcsReport()281							Ω(err).ShouldNot(HaveOccurred())282							Ω(report.SpecReports).Should(ConsistOf(specReportA, specReportB))283							close(done)284						}()285						Consistently(done).ShouldNot(BeClosed())286						Ω(client.PostSuiteDidEnd(endReport2)).Should(Succeed())287						close(proc2Exited)288						Consistently(done).ShouldNot(BeClosed())289						Ω(client.PostSuiteDidEnd(endReport3)).Should(Succeed())290						close(proc3Exited)291						Eventually(done).Should(BeClosed())292					})293					Context("when a non-primary proc disappears without reporting back", func() {294						It("blocks returns an appropriate error", func() {295							done := make(chan interface{})296							go func() {297								defer GinkgoRecover()298								report, err := client.BlockUntilAggregatedNonprimaryProcsReport()299								Ω(err).Should(Equal(types.GinkgoErrors.AggregatedReportUnavailableDueToNodeDisappearing()))300								Ω(report).Should(BeZero())301								close(done)302							}()303							Consistently(done).ShouldNot(BeClosed())304							Ω(client.PostSuiteDidEnd(endReport2)).Should(Succeed())305							close(proc2Exited)306							Consistently(done).ShouldNot(BeClosed())307							close(proc3Exited)308							Eventually(done).Should(BeClosed())309						})310					})311				})312				Describe("Fetching counters", func() {313					It("returns ascending counters", func() {314						Ω(client.FetchNextCounter()).Should(Equal(0))315						Ω(client.FetchNextCounter()).Should(Equal(1))316						Ω(client.FetchNextCounter()).Should(Equal(2))317						Ω(client.FetchNextCounter()).Should(Equal(3))318					})...

...31	Connect() bool32	Close() error33	PostSuiteWillBegin(report types.Report) error34	PostDidRun(report types.SpecReport) error35	PostSuiteDidEnd(report types.Report) error36	PostSynchronizedBeforeSuiteCompleted(state types.SpecState, data []byte) error37	BlockUntilSynchronizedBeforeSuiteData() (types.SpecState, []byte, error)38	BlockUntilNonprimaryProcsHaveFinished() error39	BlockUntilAggregatedNonprimaryProcsReport() (types.Report, error)40	FetchNextCounter() (int, error)41	PostAbort() error42	ShouldAbort() bool43	Write(p []byte) (int, error)44}45func NewServer(parallelTotal int, reporter reporters.Reporter) (Server, error) {46	if os.Getenv("GINKGO_PARALLEL_PROTOCOL") == "HTTP" {47		return newHttpServer(parallelTotal, reporter)48	} else {49		return newRPCServer(parallelTotal, reporter)...

1import (2func TestGinkgo(t *testing.T) {3	gomega.RegisterFailHandler(ginkgo.Fail)4	junitReporter := reporters.NewJUnitReporter("report.xml")5	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{junitReporter})6}7import (8type parallel_support struct {9}10func (p parallel_support) BeforeSuiteDidRun(setupSummary *types.SetupSummary) {11	fmt.Println("BeforeSuiteDidRun")12}13func (p parallel_support) AfterSuiteDidRun(setupSummary *types.SetupSummary) {14	fmt.Println("AfterSuiteDidRun")15}16func (p parallel_support) SpecWillRun(specSummary *types.SpecSummary) {17	fmt.Println("SpecWillRun")18}19func (p parallel_support) SpecDidComplete(specSummary *types.SpecSummary) {20	fmt.Println("SpecDidComplete")21}22func (p parallel_support) SuiteWillBegin(summary *types.SuiteSummary) {23	fmt.Println("SuiteWillBegin")24}25func (p parallel_support) SuiteDidEnd(summary *types.SuiteSummary) {26	fmt.Println("SuiteDidEnd")27}28func (p parallel_support) SpecSuiteWillBegin(config config.GinkgoConfigType, summary *types.SuiteSummary) {29	fmt.Println("SpecSuiteWillBegin")30}31func (p parallel_support) SpecSuiteDidEnd(summary *types.SuiteSummary) {32	fmt.Println("SpecSuiteDidEnd")33}34func (p parallel_support) PostSuiteDidEnd() {35	fmt.Println("PostSuiteDidEnd")36}37func (p parallel_support) PreSuiteDidRun(setupSummary *types.SetupSummary) {38	fmt.Println("PreSuiteDidRun")39}40func (p parallel_support) NodeWillRun(specSummary *types.SpecSummary) {41	fmt.Println("NodeWillRun")42}

1import (2func TestParallel(t *testing.T) {3    gomega.RegisterFailHandler(ginkgo.Fail)4    parallel_support.PostSuiteDidEnd = func() {5        fmt.Println("PostSuiteDidEnd called")6    }7    jUnitReporter := reporters.NewJUnitReporter("junit.xml")8    ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Parallel Suite", []ginkgo.Reporter{jUnitReporter})9}10import (

1func (s *MySuite) PostSuiteDidEnd() {2    fmt.Println("PostSuiteDidEnd")3}4func (s *MySuite) PreSuiteDidStart() {5    fmt.Println("PreSuiteDidStart")6}7func (s *MySuite) PostSuiteDidEnd() {8    fmt.Println("PostSuiteDidEnd")9}10func (s *MySuite) PreSuiteDidStart() {11    fmt.Println("PreSuiteDidStart")12}13func (s *MySuite) PostSuiteDidEnd() {14    fmt.Println("PostSuiteDidEnd")15}16func (s *MySuite) PreSuiteDidStart() {17    fmt.Println("PreSuiteDidStart")18}19func (s *MySuite) PostSuiteDidEnd() {20    fmt.Println("PostSuiteDidEnd")21}22func (s *MySuite) PreSuiteDidStart() {23    fmt.Println("PreSuiteDidStart")24}25func (s *MySuite) PostSuiteDidEnd() {26    fmt.Println("PostSuiteDidEnd")27}28func (s *MySuite) PreSuiteDidStart() {29    fmt.Println("PreSuiteDidStart")30}31func (s *MySuite) PostSuiteDidEnd() {32    fmt.Println("PostSuiteDidEnd")33}34func (s *MySuite) PreSuiteDidStart() {

1import (2func TestGinkgo(t *testing.T) {3	gomega.RegisterFailHandler(ginkgo.Fail)4	junitReporter := reporters.NewJUnitReporter("test-report.xml")5	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{junitReporter})6}7import (8func TestGinkgo(t *testing.T) {9	gomega.RegisterFailHandler(ginkgo.Fail)10	junitReporter := reporters.NewJUnitReporter("test-report.xml")11	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{junitReporter})12}13import (14func TestGinkgo(t *testing.T) {15	gomega.RegisterFailHandler(ginkgo.Fail)16	junitReporter := reporters.NewJUnitReporter("test-report.xml")17	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{junitReporter})18}19import (

1import (2func main() {3	fmt.Println("Hello, playground")4	parallel_support.PostSuiteDidEnd()5}6import (7func PostSuiteDidEnd() {8	fmt.Println("Hello, playground")9}10import (11func PostSuiteDidEnd() {12	fmt.Println("Hello, playground")13}14import (15func PostSuiteDidEnd() {16	fmt.Println("Hello, playground")17}18import (19func PostSuiteDidEnd() {20	fmt.Println("Hello, playground")21}22import (23func PostSuiteDidEnd() {24	fmt.Println("Hello, playground")25}26import (27func PostSuiteDidEnd() {28	fmt.Println("Hello, playground")29}30import (31func PostSuiteDidEnd() {32	fmt.Println("Hello, playground")33}34import (35func PostSuiteDidEnd() {36	fmt.Println("Hello, playground")37}38import (39func PostSuiteDidEnd() {40	fmt.Println("Hello, playground")41}

1import (2func TestParallel(t *testing.T) {3    fmt.Println("TestParallel is running")4    time.Sleep(5 * time.Second)5}6import (7func TestParallel(t *testing.T) {8    fmt.Println("TestParallel is running")9    time.Sleep(5 * time.Second)10}11import (12func TestParallel(t *testing.T) {13    fmt.Println("TestParallel is running")14    time.Sleep(5 * time.Second)15}16import (17func TestParallel(t *testing.T) {18    fmt.Println("TestParallel is running")19    time.Sleep(5 * time.Second)20}21import (22func TestParallel(t *testing.T) {23    fmt.Println("TestParallel is running")24    time.Sleep(5 * time.Second)25}26import (27func TestParallel(t *testing.T) {28    fmt.Println("TestParallel is running")29    time.Sleep(5 * time.Second)30}31import (32func TestParallel(t *testing.T) {33    fmt.Println("TestParallel is running")34    time.Sleep(5 * time.Second)35}36import (37func TestParallel(t *testing.T) {