How to use OrderSpecs method of internal Package

...18}19func (tt SpecTexts) Join() string {20	return strings.Join(tt, "")21}22var _ = Describe("OrderSpecs", func() {23	var conf types.SuiteConfig24	var specs Specs25	BeforeEach(func() {26		conf = types.SuiteConfig{}27		conf.RandomSeed = 128		conf.ParallelTotal = 129		con1 := N(ntCon)30		con2 := N(ntCon)31		specs = Specs{32			S(N("A", ntIt)),33			S(N("B", ntIt)),34			S(con1, N("C", ntIt)),35			S(con1, N("D", ntIt)),36			S(con1, N(ntCon), N("E", ntIt)),37			S(N("F", ntIt)),38			S(con2, N("G", ntIt)),39			S(con2, N("H", ntIt)),40		}41	})42	Context("when configured to only randomize top-level specs", func() {43		It("shuffles top level specs only", func() {44			for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {45				groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)46				Ω(serialSpecIndices).Should(BeEmpty())47				Ω(getTexts(specs, groupedSpecIndices).Join()).Should(ContainSubstring("CDE"))48				Ω(getTexts(specs, groupedSpecIndices).Join()).Should(ContainSubstring("GH"))49			}50			conf.RandomSeed = 151			groupedSpecIndices1, _ := internal.OrderSpecs(specs, conf)52			conf.RandomSeed = 253			groupedSpecIndices2, _ := internal.OrderSpecs(specs, conf)54			Ω(getTexts(specs, groupedSpecIndices1)).ShouldNot(Equal(getTexts(specs, groupedSpecIndices2)))55		})56	})57	Context("when configured to randomize all specs", func() {58		BeforeEach(func() {59			conf.RandomizeAllSpecs = true60		})61		It("shuffles all specs", func() {62			hasCDE := true63			hasGH := true64			for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {65				groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)66				Ω(serialSpecIndices).Should(BeEmpty())67				hasCDE, _ = ContainSubstring("CDE").Match(getTexts(specs, groupedSpecIndices).Join())68				hasGH, _ = ContainSubstring("GH").Match(getTexts(specs, groupedSpecIndices).Join())69				if !hasCDE && !hasGH {70					break71				}72			}73			Ω(hasCDE || hasGH).Should(BeFalse(), "after 10 randomizations, we really shouldn't have gotten CDE and GH in order as all specs should be shuffled, not just top-level containers and specs")74			conf.RandomSeed = 175			groupedSpecIndices1, _ := internal.OrderSpecs(specs, conf)76			conf.RandomSeed = 277			groupedSpecIndices2, _ := internal.OrderSpecs(specs, conf)78			Ω(getTexts(specs, groupedSpecIndices1)).ShouldNot(Equal(getTexts(specs, groupedSpecIndices2)))79		})80	})81	Context("when passed the same seed", func() {82		It("always generates the same order", func() {83			for _, conf.RandomizeAllSpecs = range []bool{true, false} {84				for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {85					groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)86					Ω(serialSpecIndices).Should(BeEmpty())87					for i := 0; i < 10; i++ {88						reshuffledGroupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)89						Ω(serialSpecIndices).Should(BeEmpty())90						Ω(getTexts(specs, groupedSpecIndices)).Should(Equal(getTexts(specs, reshuffledGroupedSpecIndices)))91					}92				}93			}94		})95	})96	Context("when specs are in different files and the files are loaded in an undefined order", func() {97		var specsInFileA, specsInFileB Specs98		BeforeEach(func() {99			con1 := N(ntCon, CL("file_A", 10))100			specsInFileA = Specs{101				S(N("A", ntIt, CL("file_A", 1))),102				S(N("B", ntIt, CL("file_A", 5))),103				S(con1, N("C", ntIt, CL("file_A", 15))),104				S(con1, N("D", ntIt, CL("file_A", 20))),105				S(con1, N(ntCon, CL("file_A", 25)), N("E", ntIt, CL("file_A", 30))),106			}107			con2 := N(ntCon, CL("file_B", 10))108			specsInFileB = Specs{109				S(N("F", ntIt, CL("file_B", 1))),110				S(con2, N("G", ntIt, CL("file_B", 15))),111				S(con2, N("H", ntIt, CL("file_B", 20))),112			}113		})114		It("always generates a consistent randomization when given the same seed", func() {115			for _, conf.RandomizeAllSpecs = range []bool{true, false} {116				for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {117					specsOrderAB := Specs{}118					specsOrderAB = append(specsOrderAB, specsInFileA...)119					specsOrderAB = append(specsOrderAB, specsInFileB...)120					specsOrderBA := Specs{}121					specsOrderBA = append(specsOrderBA, specsInFileB...)122					specsOrderBA = append(specsOrderBA, specsInFileA...)123					groupedSpecIndicesAB, serialSpecIndices := internal.OrderSpecs(specsOrderAB, conf)124					Ω(serialSpecIndices).Should(BeEmpty())125					groupedSpecIndicesBA, serialSpecIndices := internal.OrderSpecs(specsOrderBA, conf)126					Ω(serialSpecIndices).Should(BeEmpty())127					Ω(getTexts(specsOrderAB, groupedSpecIndicesAB)).Should(Equal(getTexts(specsOrderBA, groupedSpecIndicesBA)))128				}129			}130		})131	})132	Context("when there are ordered specs and randomize-all is true", func() {133		BeforeEach(func() {134			con1 := N(ntCon, Ordered)135			con2 := N(ntCon)136			specs = Specs{137				S(N("A", ntIt)),138				S(N("B", ntIt)),139				S(con1, N("C", ntIt)),140				S(con1, N("D", ntIt)),141				S(con1, N(ntCon), N("E", ntIt)),142				S(N("F", ntIt)),143				S(con2, N("G", ntIt)),144				S(con2, N("H", ntIt)),145			}146			conf.RandomizeAllSpecs = true147		})148		It("never shuffles the specs in ordered specs", func() {149			for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {150				groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)151				Ω(serialSpecIndices).Should(BeEmpty())152				Ω(getTexts(specs, groupedSpecIndices).Join()).Should(ContainSubstring("CDE"))153			}154		})155	})156	Context("when there are ordered specs and randomize-all is false and everything is in an enclosing container", func() {157		BeforeEach(func() {158			con0 := N(ntCon)159			con1 := N(ntCon, Ordered)160			con2 := N(ntCon)161			specs = Specs{162				S(con0, N("A", ntIt)),163				S(con0, N("B", ntIt)),164				S(con0, con1, N("C", ntIt)),165				S(con0, con1, N("D", ntIt)),166				S(con0, con1, N(ntCon), N("E", ntIt)),167				S(con0, N("F", ntIt)),168				S(con0, con2, N("G", ntIt)),169				S(con0, con2, N("H", ntIt)),170			}171			conf.RandomizeAllSpecs = false172		})173		It("runs all the specs in order", func() {174			for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {175				groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)176				Ω(serialSpecIndices).Should(BeEmpty())177				Ω(getTexts(specs, groupedSpecIndices).Join()).Should(Equal("ABCDEFGH"))178			}179		})180	})181	Context("when there are serial specs", func() {182		BeforeEach(func() {183			con1 := N(ntCon, Ordered, Serial)184			con2 := N(ntCon)185			specs = Specs{186				S(N("A", Serial, ntIt)),187				S(N("B", ntIt)),188				S(con1, N("C", ntIt)),189				S(con1, N("D", ntIt)),190				S(con1, N(ntCon), N("E", ntIt)),191				S(N("F", ntIt)),192				S(con2, N("G", ntIt)),193				S(con2, N("H", ntIt, Serial)),194			}195			conf.RandomizeAllSpecs = true196		})197		Context("and the tests are not running in parallel", func() {198			BeforeEach(func() {199				conf.ParallelTotal = 1200			})201			It("puts all the tests in the parallelizable group and returns an empty serial group", func() {202				for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {203					groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)204					Ω(serialSpecIndices).Should(BeEmpty())205					Ω(getTexts(specs, groupedSpecIndices).Join()).Should(ContainSubstring("CDE"))206					Ω(getTexts(specs, groupedSpecIndices)).Should(ConsistOf("A", "B", "C", "D", "E", "F", "G", "H"))207				}208				conf.RandomSeed = 1209				groupedSpecIndices1, _ := internal.OrderSpecs(specs, conf)210				conf.RandomSeed = 2211				groupedSpecIndices2, _ := internal.OrderSpecs(specs, conf)212				Ω(getTexts(specs, groupedSpecIndices1)).ShouldNot(Equal(getTexts(specs, groupedSpecIndices2)))213			})214		})215		Context("and the tests are running in parallel", func() {216			BeforeEach(func() {217				conf.ParallelTotal = 2218			})219			It("puts all parallelizable tests in the parallelizable group and all serial tests in the serial group, preserving ordered test order", func() {220				for conf.RandomSeed = 1; conf.RandomSeed < 10; conf.RandomSeed += 1 {221					groupedSpecIndices, serialSpecIndices := internal.OrderSpecs(specs, conf)222					Ω(getTexts(specs, groupedSpecIndices)).Should(ConsistOf("B", "F", "G"))223					Ω(getTexts(specs, serialSpecIndices).Join()).Should(ContainSubstring("CDE"))224					Ω(getTexts(specs, serialSpecIndices)).Should(ConsistOf("A", "C", "D", "E", "H"))225				}226				conf.RandomSeed = 1227				groupedSpecIndices1, serialSpecIndices1 := internal.OrderSpecs(specs, conf)228				conf.RandomSeed = 2229				groupedSpecIndices2, serialSpecIndices2 := internal.OrderSpecs(specs, conf)230				Ω(getTexts(specs, groupedSpecIndices1)).ShouldNot(Equal(getTexts(specs, groupedSpecIndices2)))231				Ω(getTexts(specs, serialSpecIndices1)).ShouldNot(Equal(getTexts(specs, serialSpecIndices2)))232			})233		})234	})235})...

...5	"github.com/bsm/ginkgo/v2/types"6)7type GroupedSpecIndices []SpecIndices8type SpecIndices []int9func OrderSpecs(specs Specs, suiteConfig types.SuiteConfig) (GroupedSpecIndices, GroupedSpecIndices) {10	/*11		Ginkgo has sophisticated support for randomizing specs.  Specs are guaranteed to have the same12		order for a given seed across test runs.13		By default only top-level containers and specs are shuffled - this makes for a more intuitive debugging14		experience - specs within a given container run in the order they appear in the file.15		Developers can set -randomizeAllSpecs to shuffle _all_ specs.16		In addition, spec containers can be marked as Ordered.  Specs within an Ordered container are never shuffled.17		Finally, specs and spec containers can be marked as Serial.  When running in parallel, serial specs run on Process #1 _after_ all other processes have finished.18	*/19	// Seed a new random source based on thee configured random seed.20	r := rand.New(rand.NewSource(suiteConfig.RandomSeed))21	// first break things into execution groups22	// a group represents a single unit of execution and is a collection of SpecIndices23	// usually a group is just a single spec, however ordered containers must be preserved as a single group...

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

1import (2func main() {3    o := order.NewOrder()4    o.Add("item1", 1, 1.0)5    o.Add("item2", 2, 2.0)6    o.Add("item3", 3, 3.0)7    items := o.OrderSpecs()8    for _, item := range items {9        fmt.Println(item)10    }11}12The example above is a simple example, but it shows the basic idea of using the package. In this case, we have a main package and a package named order . The main package uses the order package. The order package is not in the same directory as the main package, but it is in the same workspace. You can see that the import statement imports the order package. The import statement is the same as the import statement you use when importing a package from the standard library. The order package is in the same workspace as the main package, so you

1import (2func main() {3    fmt.Println(xyz.OrderSpecs())4}5panic(0x4d6d60, 0xc8200c2a40)6github.com/jmoiron/sqlx.MustConnect(0x4f0b70, 0x6, 0xc82000e2f0, 0x1, 0x1, 0x0, 0x0)7main.main()

1import "fmt"2import "github.com/1.go"3func main() {4    order := OrderSpecs{5, 6}5    fmt.Println(order)6}7type OrderSpecs struct {8}9import "fmt"10import "github.com/2.go"11func main() {12    order := OrderSpecs{5, 6}13    fmt.Println(order)14}15type OrderSpecs struct {16}17I’m not sure if it’s related, but I also noticed that if I have a package with a single file in it, and that file has the same name as the package, then the package can’t be imported. For example, I have a file named “foo.go” with the package name “foo”, and I can’t import it with “import “foo””, but I can import it with “import “./foo””. I think this is related because it sounds like the package name is being used to determine the path, and in this case the package name is the same as

1import "github.com/Prashant-Surya/Go-Training/1"2func main() {3    s = append(s, "Prashant", "Surya", "Prashant Surya")4    s = OrderSpecs(s)5    for _, v := range s {6        fmt.Println(v)7    }8}9import "fmt"10func OrderSpecs(s []string) []string {11}12import "testing"13func TestOrderSpecs(t *testing.T) {14    s = append(s, "Prashant", "Surya", "Prashant Surya")15    s = OrderSpecs(s)16    if s[0] != "Prashant" {17        t.Error("Expected Prashant, got ", s[0])18    }19}