How to use PIt method of ginkgo Package

...59		FIt(text, body, timeout...)60	})61	return b62}63func (b *GinkgoBuilder) PIt(text string, args ...interface{}) *GinkgoBuilder {64	b.appendTesting(func() {65		PIt(text, args...)66	})67	return b68}69func (b *GinkgoBuilder) XIt(text string, args ...interface{}) *GinkgoBuilder {70	b.appendTesting(func() {71		XIt(text, args)72	})73	return b74}75func (b *GinkgoBuilder) Measure(text string, body interface{}, samples int) *GinkgoBuilder {76	b.appendTesting(func() {77		Measure(text, body, samples)78	})79	return b80}81func (b *GinkgoBuilder) FMeasure(text string, body interface{}, samples int) *GinkgoBuilder {82	b.appendTesting(func() {83		FMeasure(text, body, samples)84	})85	return b86}87func (b *GinkgoBuilder) PMeasure(text string, args ...interface{}) *GinkgoBuilder {88	b.appendTesting(func() {89		PMeasure(text, args...)90	})91	return b92}93func (b *GinkgoBuilder) XMeasure(text string, args ...interface{}) *GinkgoBuilder {94	b.appendTesting(func() {95		XMeasure(text, args...)96	})97	return b98}99func (b *GinkgoBuilder) Specify(text string, body interface{}, timeout ...float64) *GinkgoBuilder {100	b.appendTesting(func() {101		Specify(text, body, timeout...)102	})103	return b104}105func (b *GinkgoBuilder) FSpecify(text string, body interface{}, timeout ...float64) *GinkgoBuilder {106	b.appendTesting(func() {107		FSpecify(text, body, timeout...)108	})109	return b110}111func (b *GinkgoBuilder) PSpecify(text string, args ...interface{}) *GinkgoBuilder {112	b.appendTesting(func() {113		PSpecify(text, args...)114	})115	return b116}117func (b *GinkgoBuilder) XSpecify(text string, args ...interface{}) *GinkgoBuilder {118	b.appendTesting(func() {119		XSpecify(text, args...)120	})121	return b122}123func (b *GinkgoBuilder) Table(table *GinkgoTable) *GinkgoBuilder {124	b.testingTable = append(b.testingTable, table)125	return b126}127func (b *GinkgoBuilder) ToFunc() func() {128	return func() {129		b.Expose()130	}131}132// By the definition of Ginkgo, this function exposes the corresponding Ginkgo function.133func (b *GinkgoBuilder) Expose() {134	countingOfTests := b.getNumberOfTests()135	/**136	 * Before First137	 */138	for _, targetParam := range b.beforeFirst {139		BeforeEach(140			newBeforeFirstFunc(targetParam.body.(func()), countingOfTests),141			targetParam.timeout...,142		)143	}144	// :~)145	/**146	 * Before Each/After Each147	 */148	for _, beforeEachParam := range b.beforeEach {149		BeforeEach(beforeEachParam.body, beforeEachParam.timeout...)150	}151	for _, afterEachParam := range b.afterEach {152		AfterEach(afterEachParam.body, afterEachParam.timeout...)153	}154	// :~)155	/**156	 * After Last157	 */158	for _, targetParam := range b.afterLast {159		AfterEach(160			newAfterLastFunc(targetParam.body.(func()), countingOfTests),161			targetParam.timeout...,162		)163	}164	// :~)165	/**166	 * JustBeforeEach167	 */168	for _, targetParam := range b.justBeforeEach {169		JustBeforeEach(targetParam.body, targetParam.timeout...)170	}171	// :~)172	/**173	 * Executes defined tests by table cases174	 */175	for _, table := range b.testingTable {176		table.Expose()177	}178	// :~)179	/**180	 * Executes defined tests individually181	 */182	for _, execFunc := range b.testingFuncs {183		execFunc()184	}185	// :~)186}187func (b *GinkgoBuilder) ToDescribe() bool {188	return Describe(b.mainText, b.ToFunc())189}190func (b *GinkgoBuilder) ToFDescribe() bool {191	return FDescribe(b.mainText, b.ToFunc())192}193func (b *GinkgoBuilder) ToPDescribe() bool {194	return PDescribe(b.mainText, b.ToFunc())195}196func (b *GinkgoBuilder) ToXDescribe() bool {197	return XDescribe(b.mainText, b.ToFunc())198}199func (b *GinkgoBuilder) ToContext() bool {200	return Context(b.mainText, b.ToFunc())201}202func (b *GinkgoBuilder) ToFContext() bool {203	return FContext(b.mainText, b.ToFunc())204}205func (b *GinkgoBuilder) ToPContext() bool {206	return PContext(b.mainText, b.ToFunc())207}208func (b *GinkgoBuilder) ToXContext() bool {209	return XContext(b.mainText, b.ToFunc())210}211func (b *GinkgoBuilder) appendTesting(testingFunc func()) {212	b.testingFuncs = append(b.testingFuncs, testingFunc)213}214func (b *GinkgoBuilder) getNumberOfTests() int {215	finalCount := len(b.testingFuncs)216	for _, table := range b.testingTable {217		finalCount += table.GetTotalNumberOfFuncs()218	}219	return finalCount220}221func NewGinkgoTable() *GinkgoTable {222	return &GinkgoTable{223		testingType: tt_it,224		execBodies: make([]reflect.Value, 0, 1),225		cases:      make([]*caseContent, 0, 2),226	}227}228/**229 * Testing type230 */231const (232	tt_it = iota233	tt_fit234	tt_pit235	tt_xit236	tt_specify237	tt_fspecify238	tt_pspecify239	tt_xspecify240)241// :~)242var mapOfBuildingTestFunc = map[int]func(text string, targetFunc reflect.Value, params []reflect.Value) func(){243	tt_it: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {244		return func() {245			It(text, func() {246				targetFunc.Call(params)247			})248		}249	},250	tt_fit: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {251		return func() {252			FIt(text, func() {253				targetFunc.Call(params)254			})255		}256	},257	tt_pit: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {258		return func() {259			PIt(text, func() {260				targetFunc.Call(params)261			})262		}263	},264	tt_xit: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {265		return func() {266			XIt(text, func() {267				targetFunc.Call(params)268			})269		}270	},271	tt_specify: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {272		return func() {273			Specify(text, func() {274				targetFunc.Call(params)275			})276		}277	},278	tt_fspecify: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {279		return func() {280			FSpecify(text, func() {281				targetFunc.Call(params)282			})283		}284	},285	tt_pspecify: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {286		return func() {287			PSpecify(text, func() {288				targetFunc.Call(params)289			})290		}291	},292	tt_xspecify: func(text string, targetFunc reflect.Value, params []reflect.Value) func() {293		return func() {294			XSpecify(text, func() {295				targetFunc.Call(params)296			})297		}298	},299}300// A cascading pattern for building test cases as table-like paradigm.301//302// The default test block would be "It()".303type GinkgoTable struct {304	testingType int305	execBodies []reflect.Value306	cases      []*caseContent307}308func (t *GinkgoTable) Exec(body interface{}) *GinkgoTable {309	funcValue := reflect.ValueOf(body)310	if funcValue.Kind() != reflect.Func {311		panic(errors.Details(312			errors.New("Need to be function for Exec(body)."),313		))314	}315	t.execBodies = append(t.execBodies, funcValue)316	return t317}318func (t *GinkgoTable) Case(descBody interface{}, params ...interface{}) *GinkgoTable {319	valueOfDescBody := reflect.ValueOf(descBody)320	var finalDesc string321	switch valueOfDescBody.Kind() {322	case reflect.Func:323		valueOfParams := make([]reflect.Value, 0, len(params))324		for _, v := range params {325			valueOfParams = append(valueOfParams, reflect.ValueOf(v))326		}327		finalDesc = valueOfDescBody.Call(valueOfParams)[0].Interface().(string)328	case reflect.String:329		finalDesc = descBody.(string)330	}331	t.cases = append(t.cases, &caseContent{finalDesc, params})332	return t333}334func (t *GinkgoTable) AsIt() *GinkgoTable {335	t.testingType = tt_it336	return t337}338func (t *GinkgoTable) AsFIt() *GinkgoTable {339	t.testingType = tt_fit340	return t341}342func (t *GinkgoTable) AsPIt() *GinkgoTable {343	t.testingType = tt_pit344	return t345}346func (t *GinkgoTable) AsXIt() *GinkgoTable {347	t.testingType = tt_xit348	return t349}350func (t *GinkgoTable) AsSpecify() *GinkgoTable {351	t.testingType = tt_specify352	return t353}354func (t *GinkgoTable) AsFSpecify() *GinkgoTable {355	t.testingType = tt_fspecify356	return t...

...29var PContext = ginkgo.PContext30var XContext = ginkgo.XContext31var It = ginkgo.It32var FIt = ginkgo.FIt33var PIt = ginkgo.PIt34var XIt = ginkgo.XIt35var Measure = ginkgo.Measure36var FMeasure = ginkgo.FMeasure37var PMeasure = ginkgo.PMeasure38var XMeasure = ginkgo.XMeasure39var BeforeSuite = ginkgo.BeforeSuite40var AfterSuite = ginkgo.AfterSuite41var SynchronizedBeforeSuite = ginkgo.SynchronizedBeforeSuite42var SynchronizedAfterSuite = ginkgo.SynchronizedAfterSuite43var BeforeEach = ginkgo.BeforeEach44var JustBeforeEach = ginkgo.JustBeforeEach45var JustAfterEach = ginkgo.JustAfterEach46var AfterEach = ginkgo.AfterEach47// Declarations for Gomega DSL...

...32var Context, FContext, PContext, XContext = Describe, FDescribe, PDescribe, XDescribe33var When, FWhen, PWhen, XWhen = Describe, FDescribe, PDescribe, XDescribe34var It = ginkgo.It35var FIt = ginkgo.FIt36var PIt = ginkgo.PIt37var XIt = PIt38var Specify, FSpecify, PSpecify, XSpecify = It, FIt, PIt, XIt39var By = ginkgo.By40var BeforeSuite = ginkgo.BeforeSuite41var AfterSuite = ginkgo.AfterSuite42var SynchronizedBeforeSuite = ginkgo.SynchronizedBeforeSuite43var SynchronizedAfterSuite = ginkgo.SynchronizedAfterSuite44var BeforeEach = ginkgo.BeforeEach45var JustBeforeEach = ginkgo.JustBeforeEach46var AfterEach = ginkgo.AfterEach47var JustAfterEach = ginkgo.JustAfterEach48var BeforeAll = ginkgo.BeforeAll49var AfterAll = ginkgo.AfterAll50var DeferCleanup = ginkgo.DeferCleanup51var GinkgoT = ginkgo.GinkgoT...

1import (2func main() {3gomega.RegisterFailHandler(ginkgo.Fail)4ginkgo.RunSpecs(t, "My Suite")5}6import (7func main() {8gomega.RegisterFailHandler(ginkgo.Fail)9ginkgo.RunSpecs(t, "My Suite")10}11import (12func main() {13gomega.RegisterFailHandler(ginkgo.Fail)14ginkgo.RunSpecs(t, "My Suite")15}16import (17func main() {18gomega.RegisterFailHandler(ginkgo.Fail)19ginkgo.RunSpecs(t, "My Suite")20}21import (22func main() {23gomega.RegisterFailHandler(ginkgo.Fail)24ginkgo.RunSpecs(t, "My Suite")25}26import (27func main() {28gomega.RegisterFailHandler(ginkgo.Fail)29ginkgo.RunSpecs(t, "My Suite")30}31import (32func main() {33gomega.RegisterFailHandler(ginkgo.Fail)34ginkgo.RunSpecs(t, "My Suite")35}36import (37func main() {38gomega.RegisterFailHandler(ginkgo.Fail)

1import (2func TestOne(t *testing.T) {3	RegisterFailHandler(Fail)4	RunSpecs(t, "One Suite")5}6var _ = Describe("One", func() {7	It("should pass", func() {8		fmt.Println("This is a test")9	})10})11import (12func TestTwo(t *testing.T) {13	RegisterFailHandler(Fail)14	RunSpecs(t, "Two Suite")15}16var _ = Describe("Two", func() {17	It("should pass", func() {18		fmt.Println("This is a test")19	})20})21import (22func TestThree(t *testing.T) {23	RegisterFailHandler(Fail)24	RunSpecs(t, "Three Suite")25}26var _ = Describe("Three", func() {27	It("should pass", func() {28		fmt.Println("This is a test")29	})30})31import (32func TestFour(t *testing.T) {33	RegisterFailHandler(Fail)34	RunSpecs(t, "Four Suite")35}36var _ = Describe("Four", func() {37	It("should pass", func() {38		fmt.Println("This is a test")39	})40})41import (42func TestFive(t *testing.T) {43	RegisterFailHandler(Fail)44	RunSpecs(t, "Five Suite

1import (2func TestPit(t *testing.T) {3	RegisterFailHandler(Fail)4	RunSpecs(t, "Pit Suite")5}6var _ = Describe("Pit", func() {7	It("should pass", func() {8		Expect(true).To(BeTrue())9	})10	PIt("should pass", func() {11		Expect(true).To(BeTrue())12	})13})

1import (2func TestPit(t *testing.T) {3	RegisterFailHandler(Fail)4	RunSpecs(t, "Pit Suite")5}6var _ = Describe("Pit", func() {7	It("should pass", func() {8		Expect(true).To(BeTrue())9	})10	PIt("should pass", func() {11		Expect(true).To(BeTrue())12	})13})

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 (20func TestGinkgo(t *testing.T) {21	gomega.RegisterFailHandler(ginkgo.Fail)22	junitReporter := reporters.NewJUnitReporter("junit.xml")23	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Ginkgo suite", []ginkgo.Reporter{junitReporter})24}

1import (2func main() {3	fmt.Println(ginkgo.PIt("test", func() {4		gomega.Expect(1).To(gomega.Equal(1))5	}))6}7import (8func main() {9	fmt.Println(ginkgo.PMeasure("test", func(b ginkgo.Benchmarker) {10		gomega.Expect(1).To(gomega.Equal(1))11		b.Time("test", func() {12			gomega.Expect(1).To(gomega.Equal(1))13		})14	}))15}16import (17func main() {18	fmt.Println(ginkgo.PDescribe("test", func() {19		ginkgo.It("test", func() {20			gomega.Expect(1).To(gomega.Equal(1))21		})22	}))23}

1import (2func main() {3    fmt.Println(ginkgo.PIt("Test", func() {4        fmt.Println("Hello World")5    }))6}7ginkgo.PDescribe("Test", func() {8})9import (10func main() {11    fmt.Println(ginkgo.PDescribe("Test", func() {12        fmt.Println("Hello World")13    }))14}15ginkgo.PMeasure("Test", func(b Benchmarker) {16}, 100)17import (18func main() {19    fmt.Println(ginkgo.PMeasure("Test", func(b Benchmarker) {20        fmt.Println("Hello World")21    }, 100))22}23ginkgo.PSpecify("Test", func() {24})25import (26func main() {27    fmt.Println(ginkgo.PSpecify("Test",

1ginkgo.PIt("should be able to use PIt", func() {2})3ginkgo.PMeasure("should be able to use PMeasure", func(b Benchmarker) {4}, 1)5ginkgo.PSpecify("should be able to use PSpecify", func() {6})7ginkgo.PSpecify("should be able to use PSpecify", func() {8}, 1)9ginkgo.PSpecify("should be able to use PSpecify", func() {10})11ginkgo.PSpecify("should be able to use PSpecify", func() {12})13ginkgo.PSpecify("should be able to use PSpecify", func() {14})15ginkgo.PSpecify("should be able to use PSpecify", func() {16})17ginkgo.PSpecify("should be able to use PSpecify", func() {18})19ginkgo.PSpecify("should be able to use PSpecify", func() {20})21ginkgo.PSpecify("should be able to use PSpecify", func() {22})