How to use WillRun method of reporters Package

...79			failedSpec = newSpec("failed spec", noneFlag, true)80			specB = newSpec("spec B", noneFlag, false)81			skippedSpec = newSpec("skipped spec", noneFlag, false)82			skippedSpec.Skip()83			reporter1.SpecWillRunStub = func(specSummary *types.SpecSummary) {84				willRunCalls = append(willRunCalls, "Reporter1")85			}86			reporter2.SpecWillRunStub = func(specSummary *types.SpecSummary) {87				willRunCalls = append(willRunCalls, "Reporter2")88			}89			reporter1.SpecDidCompleteStub = func(specSummary *types.SpecSummary) {90				didCompleteCalls = append(didCompleteCalls, "Reporter1")91			}92			reporter2.SpecDidCompleteStub = func(specSummary *types.SpecSummary) {93				didCompleteCalls = append(didCompleteCalls, "Reporter2")94			}95			runner = newRunner(config.GinkgoConfigType{RandomSeed: 17}, newBefSuite("BefSuite", false), newAftSuite("AftSuite", false), specA, pendingSpec, anotherPendingSpec, failedSpec, specB, skippedSpec)96			runner.Run()97		})98		It("should skip skipped/pending tests", func() {99			Ω(thingsThatRan).Should(Equal([]string{"BefSuite", "spec A", "failed spec", "spec B", "AftSuite"}))100		})101		It("should report to any attached reporters", func() {102			Ω(reporter1.Config).Should(Equal(reporter2.Config))103			Ω(reporter1.BeginSummary).Should(Equal(reporter2.BeginSummary))104			Ω(reporter1.SpecWillRunSummaries).Should(Equal(reporter2.SpecWillRunSummaries))105			Ω(reporter1.SpecSummaries).Should(Equal(reporter2.SpecSummaries))106			Ω(reporter1.EndSummary).Should(Equal(reporter2.EndSummary))107		})108		It("should report that a spec did end in reverse order", func() {109			Ω(willRunCalls[0:4]).Should(Equal([]string{"Reporter1", "Reporter2", "Reporter1", "Reporter2"}))110			Ω(didCompleteCalls[0:4]).Should(Equal([]string{"Reporter2", "Reporter1", "Reporter2", "Reporter1"}))111		})112		It("should report the passed in config", func() {113			Ω(reporter1.Config.RandomSeed).Should(BeNumerically("==", 17))114		})115		It("should report the beginning of the suite", func() {116			Ω(reporter1.BeginSummary.SuiteDescription).Should(Equal("description"))117			Ω(reporter1.BeginSummary.SuiteID).Should(MatchRegexp("[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}"))118			Ω(reporter1.BeginSummary.NumberOfSpecsBeforeParallelization).Should(Equal(6))119			Ω(reporter1.BeginSummary.NumberOfTotalSpecs).Should(Equal(6))120			Ω(reporter1.BeginSummary.NumberOfSpecsThatWillBeRun).Should(Equal(3))121			Ω(reporter1.BeginSummary.NumberOfPendingSpecs).Should(Equal(2))122			Ω(reporter1.BeginSummary.NumberOfSkippedSpecs).Should(Equal(1))123		})124		It("should report the end of the suite", func() {125			Ω(reporter1.EndSummary.SuiteDescription).Should(Equal("description"))126			Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())127			Ω(reporter1.EndSummary.SuiteID).Should(MatchRegexp("[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}"))128			Ω(reporter1.EndSummary.NumberOfSpecsBeforeParallelization).Should(Equal(6))129			Ω(reporter1.EndSummary.NumberOfTotalSpecs).Should(Equal(6))130			Ω(reporter1.EndSummary.NumberOfSpecsThatWillBeRun).Should(Equal(3))131			Ω(reporter1.EndSummary.NumberOfPendingSpecs).Should(Equal(2))132			Ω(reporter1.EndSummary.NumberOfSkippedSpecs).Should(Equal(1))133			Ω(reporter1.EndSummary.NumberOfPassedSpecs).Should(Equal(2))134			Ω(reporter1.EndSummary.NumberOfFailedSpecs).Should(Equal(1))135		})136	})137	Describe("reporting on specs", func() {138		var proceed chan bool139		var ready chan bool140		var finished chan bool141		BeforeEach(func() {142			ready = make(chan bool)143			proceed = make(chan bool)144			finished = make(chan bool)145			skippedSpec := newSpec("SKIP", noneFlag, false)146			skippedSpec.Skip()147			runner = newRunner(148				config.GinkgoConfigType{},149				newBefSuite("BefSuite", false),150				newAftSuite("AftSuite", false),151				skippedSpec,152				newSpec("PENDING", pendingFlag, false),153				newSpecWithBody("RUN", func() {154					close(ready)155					<-proceed156				}),157			)158			go func() {159				runner.Run()160				close(finished)161			}()162		})163		It("should report about pending/skipped specs", func() {164			<-ready165			Ω(reporter1.SpecWillRunSummaries).Should(HaveLen(3))166			Ω(reporter1.SpecWillRunSummaries[0].ComponentTexts[0]).Should(Equal("SKIP"))167			Ω(reporter1.SpecWillRunSummaries[1].ComponentTexts[0]).Should(Equal("PENDING"))168			Ω(reporter1.SpecWillRunSummaries[2].ComponentTexts[0]).Should(Equal("RUN"))169			Ω(reporter1.SpecSummaries[0].ComponentTexts[0]).Should(Equal("SKIP"))170			Ω(reporter1.SpecSummaries[1].ComponentTexts[0]).Should(Equal("PENDING"))171			Ω(reporter1.SpecSummaries).Should(HaveLen(2))172			close(proceed)173			<-finished174			Ω(reporter1.SpecSummaries).Should(HaveLen(3))175			Ω(reporter1.SpecSummaries[2].ComponentTexts[0]).Should(Equal("RUN"))176		})177	})178	Describe("Running BeforeSuite & AfterSuite", func() {179		var success bool180		var befSuite leafnodes.SuiteNode181		var aftSuite leafnodes.SuiteNode182		Context("with a nil BeforeSuite & AfterSuite", func() {183			BeforeEach(func() {184				runner = newRunner(185					config.GinkgoConfigType{},186					nil,187					nil,188					newSpec("A", noneFlag, false),189					newSpec("B", noneFlag, false),190				)191				success = runner.Run()192			})193			It("should not report about the BeforeSuite", func() {194				Ω(reporter1.BeforeSuiteSummary).Should(BeNil())195			})196			It("should not report about the AfterSuite", func() {197				Ω(reporter1.AfterSuiteSummary).Should(BeNil())198			})199			It("should run the specs", func() {200				Ω(thingsThatRan).Should(Equal([]string{"A", "B"}))201			})202		})203		Context("when the BeforeSuite & AfterSuite pass", func() {204			BeforeEach(func() {205				befSuite = newBefSuite("BefSuite", false)206				aftSuite = newBefSuite("AftSuite", false)207				runner = newRunner(208					config.GinkgoConfigType{},209					befSuite,210					aftSuite,211					newSpec("A", noneFlag, false),212					newSpec("B", noneFlag, false),213				)214				success = runner.Run()215			})216			It("should run the BeforeSuite, the AfterSuite and the specs", func() {217				Ω(thingsThatRan).Should(Equal([]string{"BefSuite", "A", "B", "AftSuite"}))218			})219			It("should report about the BeforeSuite", func() {220				Ω(reporter1.BeforeSuiteSummary).Should(Equal(befSuite.Summary()))221			})222			It("should report about the AfterSuite", func() {223				Ω(reporter1.AfterSuiteSummary).Should(Equal(aftSuite.Summary()))224			})225			It("should report success", func() {226				Ω(success).Should(BeTrue())227				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeTrue())228				Ω(reporter1.EndSummary.NumberOfFailedSpecs).Should(Equal(0))229			})230			It("should not dump the writer", func() {231				Ω(writer.EventStream).ShouldNot(ContainElement("DUMP"))232			})233		})234		Context("when the BeforeSuite fails", func() {235			BeforeEach(func() {236				befSuite = newBefSuite("BefSuite", true)237				aftSuite = newBefSuite("AftSuite", false)238				skipped := newSpec("Skipped", noneFlag, false)239				skipped.Skip()240				runner = newRunner(241					config.GinkgoConfigType{},242					befSuite,243					aftSuite,244					newSpec("A", noneFlag, false),245					newSpec("B", noneFlag, false),246					newSpec("Pending", pendingFlag, false),247					skipped,248				)249				success = runner.Run()250			})251			It("should not run the specs, but it should run the AfterSuite", func() {252				Ω(thingsThatRan).Should(Equal([]string{"BefSuite", "AftSuite"}))253			})254			It("should report about the BeforeSuite", func() {255				Ω(reporter1.BeforeSuiteSummary).Should(Equal(befSuite.Summary()))256			})257			It("should report about the AfterSuite", func() {258				Ω(reporter1.AfterSuiteSummary).Should(Equal(aftSuite.Summary()))259			})260			It("should report failure", func() {261				Ω(success).Should(BeFalse())262				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())263				Ω(reporter1.EndSummary.NumberOfFailedSpecs).Should(Equal(2))264				Ω(reporter1.EndSummary.NumberOfSpecsThatWillBeRun).Should(Equal(2))265			})266			It("should dump the writer", func() {267				Ω(writer.EventStream).Should(ContainElement("DUMP"))268			})269		})270		Context("when some other test fails", func() {271			BeforeEach(func() {272				aftSuite = newBefSuite("AftSuite", false)273				runner = newRunner(274					config.GinkgoConfigType{},275					nil,276					aftSuite,277					newSpec("A", noneFlag, true),278				)279				success = runner.Run()280			})281			It("should still run the AfterSuite", func() {282				Ω(thingsThatRan).Should(Equal([]string{"A", "AftSuite"}))283			})284			It("should report about the AfterSuite", func() {285				Ω(reporter1.AfterSuiteSummary).Should(Equal(aftSuite.Summary()))286			})287			It("should report failure", func() {288				Ω(success).Should(BeFalse())289				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())290				Ω(reporter1.EndSummary.NumberOfFailedSpecs).Should(Equal(1))291				Ω(reporter1.EndSummary.NumberOfSpecsThatWillBeRun).Should(Equal(1))292			})293		})294		Context("when the AfterSuite fails", func() {295			BeforeEach(func() {296				befSuite = newBefSuite("BefSuite", false)297				aftSuite = newBefSuite("AftSuite", true)298				runner = newRunner(299					config.GinkgoConfigType{},300					befSuite,301					aftSuite,302					newSpec("A", noneFlag, false),303					newSpec("B", noneFlag, false),304				)305				success = runner.Run()306			})307			It("should run everything", func() {308				Ω(thingsThatRan).Should(Equal([]string{"BefSuite", "A", "B", "AftSuite"}))309			})310			It("should report about the BeforeSuite", func() {311				Ω(reporter1.BeforeSuiteSummary).Should(Equal(befSuite.Summary()))312			})313			It("should report about the AfterSuite", func() {314				Ω(reporter1.AfterSuiteSummary).Should(Equal(aftSuite.Summary()))315			})316			It("should report failure", func() {317				Ω(success).Should(BeFalse())318				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())319				Ω(reporter1.EndSummary.NumberOfFailedSpecs).Should(Equal(0))320			})321			It("should dump the writer", func() {322				Ω(writer.EventStream).Should(ContainElement("DUMP"))323			})324		})325	})326	Describe("When instructed to fail fast", func() {327		BeforeEach(func() {328			conf := config.GinkgoConfigType{329				FailFast: true,330			}331			runner = newRunner(conf, nil, newAftSuite("after-suite", false), newSpec("passing", noneFlag, false), newSpec("failing", noneFlag, true), newSpec("dont-see", noneFlag, true), newSpec("dont-see", noneFlag, true))332		})333		It("should return false, report failure, and not run anything past the failing test", func() {334			Ω(runner.Run()).Should(BeFalse())335			Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())336			Ω(thingsThatRan).Should(Equal([]string{"passing", "failing", "after-suite"}))337		})338		It("should announce the subsequent specs as skipped", func() {339			runner.Run()340			Ω(reporter1.SpecSummaries).Should(HaveLen(4))341			Ω(reporter1.SpecSummaries[2].State).Should(Equal(types.SpecStateSkipped))342			Ω(reporter1.SpecSummaries[3].State).Should(Equal(types.SpecStateSkipped))343		})344		It("should mark all subsequent specs as skipped", func() {345			runner.Run()346			Ω(reporter1.EndSummary.NumberOfSkippedSpecs).Should(Equal(2))347		})348	})349	Describe("Marking failure and success", func() {350		Context("when all tests pass", func() {351			BeforeEach(func() {352				runner = newRunner(config.GinkgoConfigType{}, nil, nil, newSpec("passing", noneFlag, false), newSpec("pending", pendingFlag, false))353			})354			It("should return true and report success", func() {355				Ω(runner.Run()).Should(BeTrue())356				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeTrue())357			})358		})359		Context("when a test fails", func() {360			BeforeEach(func() {361				runner = newRunner(config.GinkgoConfigType{}, nil, nil, newSpec("failing", noneFlag, true), newSpec("pending", pendingFlag, false))362			})363			It("should return false and report failure", func() {364				Ω(runner.Run()).Should(BeFalse())365				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())366			})367		})368		Context("when there is a pending test, but pendings count as failures", func() {369			BeforeEach(func() {370				runner = newRunner(config.GinkgoConfigType{FailOnPending: true}, nil, nil, newSpec("passing", noneFlag, false), newSpec("pending", pendingFlag, false))371			})372			It("should return false and report failure", func() {373				Ω(runner.Run()).Should(BeFalse())374				Ω(reporter1.EndSummary.SuiteSucceeded).Should(BeFalse())375			})376		})377	})378	Describe("Managing the writer", func() {379		BeforeEach(func() {380			runner = newRunner(381				config.GinkgoConfigType{},382				nil,383				nil,384				newSpec("A", noneFlag, false),385				newSpec("B", noneFlag, true),386				newSpec("C", noneFlag, false),387			)388			reporter1.SpecWillRunStub = func(specSummary *types.SpecSummary) {389				writer.AddEvent("R1.WillRun")390			}391			reporter2.SpecWillRunStub = func(specSummary *types.SpecSummary) {392				writer.AddEvent("R2.WillRun")393			}394			reporter1.SpecDidCompleteStub = func(specSummary *types.SpecSummary) {395				writer.AddEvent("R1.DidComplete")396			}397			reporter2.SpecDidCompleteStub = func(specSummary *types.SpecSummary) {398				writer.AddEvent("R2.DidComplete")399			}400			runner.Run()401		})402		It("should truncate between tests, but only dump if a test fails", func() {403			Ω(writer.EventStream).Should(Equal([]string{404				"TRUNCATE",405				"R1.WillRun",406				"R2.WillRun",407				"A",408				"R2.DidComplete",409				"R1.DidComplete",410				"TRUNCATE",411				"R1.WillRun",412				"R2.WillRun",413				"B",414				"R2.DidComplete",415				"DUMP",416				"R1.DidComplete",417				"TRUNCATE",418				"R1.WillRun",419				"R2.WillRun",420				"C",421				"R2.DidComplete",422				"R1.DidComplete",423			}))424		})425	})426	Describe("CurrentSpecSummary", func() {427		It("should return the spec summary for the currently running spec", func() {428			var summary *types.SpecSummary429			runner = newRunner(430				config.GinkgoConfigType{},431				nil,432				nil,433				newSpec("A", noneFlag, false),...

1import (2func TestGinkgo(t *testing.T) {3    gomega.RegisterFailHandler(ginkgo.Fail)4    ginkgo.RunSpecsWithCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{new(reporters.JUnitReporter)})5}6import (7func TestGinkgo(t *testing.T) {8    gomega.RegisterFailHandler(ginkgo.Fail)9    ginkgo.RunSpecsWithCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{new(reporters.JUnitReporter)})10}11import (12func TestGinkgo(t *testing.T) {13    gomega.RegisterFailHandler(ginkgo.Fail)14    ginkgo.RunSpecsWithCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{new(reporters.JUnitReporter)})15}16import (

1import (2func TestGinkgo(t *testing.T) {3	gomega.RegisterFailHandler(ginkgo.Fail)4	junitReporter := reporters.NewJUnitReporter("junit.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("junit.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("junit.xml")17	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Ginkgo Suite", []ginkgo.Reporter{junitReporter})18}19import (

1import (2func TestWillRun(t *testing.T) {3	fmt.Println("TestWillRun")4}5func TestWillRun1(t *testing.T) {6	fmt.Println("TestWillRun1")7}8func TestWillRun2(t *testing.T) {9	fmt.Println("TestWillRun2")10}11import (12func TestWillRun(t *testing.T) {13	fmt.Println("TestWillRun")14}15func TestWillRun1(t *testing.T) {16	fmt.Println("TestWillRun1")17}18func TestWillRun2(t *testing.T) {19	fmt.Println("TestWillRun2")20}21import (22func TestWillRun(t *testing.T) {23	fmt.Println("TestWillRun")24}25func TestWillRun1(t *testing.T) {26	fmt.Println("TestWillRun1")27}28func TestWillRun2(t *testing.T) {29	fmt.Println("TestWillRun2")30}31import (32func TestWillRun(t *testing.T) {33	fmt.Println("TestWillRun")34}35func TestWillRun1(t *testing.T) {36	fmt.Println("TestWillRun1")37}38func TestWillRun2(t *testing.T) {39	fmt.Println("TestWillRun2")40}41import (42func TestWillRun(t *testing.T) {43	fmt.Println("TestWillRun")44}45func TestWillRun1(t *testing.T) {46	fmt.Println("TestWillRun1")47}48func TestWillRun2(t *testing.T) {49	fmt.Println("TestWillRun2")50}51import (52func TestWillRun(t *testing.T) {53	fmt.Println("TestWillRun")54}55func TestWillRun1(t *testing.T) {56	fmt.Println("TestWillRun1")57}58func TestWillRun2(t *testing

1import (2func TestMain(m *testing.M) {3	fmt.Println("TestMain")4	os.Exit(m.Run())5}6func TestHelloWorld(t *testing.T) {7	fmt.Println("TestHelloWorld")8}9import (10func TestMain(m *testing.M) {11	fmt.Println("TestMain")12	os.Exit(m.Run())13}14func TestHelloWorld(t *testing.T) {15	fmt.Println("TestHelloWorld")16}17import (18func TestMain(m *testing.M) {19	fmt.Println("TestMain")20	os.Exit(m.Run())21}22func TestHelloWorld(t *testing.T) {23	fmt.Println("TestHelloWorld")24}25import (26func TestMain(m *testing.M) {27	fmt.Println("TestMain")28	os.Exit(m.Run())29}30func TestHelloWorld(t *testing.T) {31	fmt.Println("TestHelloWorld")32}33import (34func TestMain(m *testing.M) {35	fmt.Println("TestMain")36	os.Exit(m.Run())37}38func TestHelloWorld(t *testing.T) {39	fmt.Println("TestHelloWorld")40}41import (42func TestMain(m *testing.M) {43	fmt.Println("TestMain")44	os.Exit(m.Run())45}46func TestHelloWorld(t *testing.T) {47	fmt.Println("TestHelloWorld")48}49import (50func TestMain(m *testing.M) {51	fmt.Println("TestMain")52	os.Exit(m.Run())53}54func TestHelloWorld(t *testing.T) {55	fmt.Println("TestHelloWorld")56}

1import (2func TestMain(m *testing.M) {3	fmt.Println("Before running tests")4	m.Run()5	fmt.Println("After running tests")6}7func Test1(t *testing.T) {8	fmt.Println("Test1")9}10func Test2(t *testing.T) {11	fmt.Println("Test2")12}

1import (2type MyReporter struct{}3func (r *MyReporter) WillRun(testName string) {4    fmt.Println("WillRun:", testName)5}6func (r *MyReporter) DidRun(testName string, result testing.TestResult) {7    fmt.Println("DidRun:", testName, result)8}9func TestOne(t *testing.T) {10    t.Error("TestOne")11}12func TestTwo(t *testing.T) {13    t.Error("TestTwo")14}15func TestThree(t *testing.T) {16    t.Error("TestThree")17}18func TestFour(t *testing.T) {19    t.Error("TestFour")20}21func TestFive(t *testing.T) {22    t.Error("TestFive")23}24func TestSix(t *testing.T) {25    t.Error("TestSix")26}27func TestSeven(t *testing.T) {28    t.Error("TestSeven")29}30func TestEight(t *testing.T) {31    t.Error("TestEight")32}33func TestNine(t *testing.T) {34    t.Error("TestNine")35}36func TestTen(t *testing.T) {37    t.Error("TestTen")38}39func TestEleven(t *testing.T) {40    t.Error("TestEleven")41}42func TestTwelve(t *testing.T) {43    t.Error("TestTwelve")44}45func TestThirteen(t *testing.T) {46    t.Error("TestThirteen")47}48func TestFourteen(t *testing.T) {49    t.Error("TestFourteen")50}51func TestFifteen(t *testing.T) {52    t.Error("TestFifteen")53}54func TestSixteen(t *testing.T) {55    t.Error("TestSixteen")56}57func TestSeventeen(t *testing.T) {58    t.Error("TestSeventeen")59}60func TestEighteen(t *testing.T) {61    t.Error("TestEighteen")62}63func TestNineteen(t *testing.T) {64    t.Error("TestNineteen")65}66func TestTwenty(t *testing.T) {67    t.Error("TestTwenty")68}69func TestTwentyOne(t *testing.T) {70    t.Error("TestTwentyOne")71}72func TestTwentyTwo(t *testing.T) {73    t.Error("TestTwentyTwo")74}75func TestTwentyThree(t *testing.T) {76    t.Error("TestTwentyThree")77}

1func main() {2	reporter := reporters.NewReporter()3	reporter.WillRun()4}5func main() {6	reporter := reporters.NewReporter()7	reporter.WillRun()8}9func main() {10	reporter := reporters.NewReporter()11	reporter.WillRun()12}13func main() {14	reporter := reporters.NewReporter()15	reporter.WillRun()16}17func main() {18	reporter := reporters.NewReporter()19	reporter.WillRun()20}21func main() {22	reporter := reporters.NewReporter()23	reporter.WillRun()24}25func main() {26	reporter := reporters.NewReporter()27	reporter.WillRun()28}29func main() {30	reporter := reporters.NewReporter()31	reporter.WillRun()32}33func main() {34	reporter := reporters.NewReporter()35	reporter.WillRun()36}37func main() {38	reporter := reporters.NewReporter()39	reporter.WillRun()40}41func main() {42	reporter := reporters.NewReporter()43	reporter.WillRun()44}45func main() {46	reporter := reporters.NewReporter()47	reporter.WillRun()48}49func main() {50	reporter := reporters.NewReporter()

1import (2func TestWillRun(t *testing.T) {3   fmt.Println("Test Will Run")4}5func main() {6   fmt.Println("Main")7}8import (

1import (2func main() {3    start := time.Now()4    cmd := exec.Command("go", "run", "2.go")5    stdout, err := cmd.StdoutPipe()6    if err != nil {7        fmt.Println(err)8        os.Exit(1)9    }10    if err := cmd.Start(); err != nil {11        fmt.Println(err)12        os.Exit(1)13    }14    out := make([]byte, 1024)15    _, err = stdout.Read(out)16    if err != nil {17        fmt.Println(err)18        os.Exit(1)19    }20    fmt.Printf("%s", out)21    if err := cmd.Wait(); err != nil {22        fmt.Println(err)23        os.Exit(1)24    }25    elapsed := time.Since(start)26    fmt.Printf("Time taken: %s27    fmt.Printf("28}29import (30func main() {31    start := time.Now()32    cmd := exec.Command("go", "run", "3.go")33    stdout, err := cmd.StdoutPipe()34    if err != nil {35        fmt.Println(err)36        os.Exit(1)37    }38    if err := cmd.Start(); err != nil {39        fmt.Println(err)40        os.Exit(1)41    }42    out := make([]byte, 1024)43    _, err = stdout.Read(out)44    if err != nil {45        fmt.Println(err)46        os.Exit(1)47    }48    fmt.Printf("%s", out)49    if err := cmd.Wait(); err != nil {50        fmt.Println(err)