How to use ParseProfile method of integration_test Package

...27	Fail(fmt.Sprintf("Could not find caller %s among profile lines %+v.", caller, lines), 1)28	return ProfileLine{}29}30var PROFILE_RE = regexp.MustCompile(`[\d\.]+[MBms]*\s*[\d\.]+\%\s*[\d\.]+\%\s*([\d\.]+[MBnms]*)\s*[\d\.]+\%\s*(.*)`)31func ParseProfile(binary string, path string) ProfileLines {32	cmd := exec.Command("go", "tool", "pprof", "-cum", "-top", binary, path)33	output, err := cmd.CombinedOutput()34	GinkgoWriter.Printf("Profile for: %s\n%s\n", path, string(output))35	ExpectWithOffset(1, err).ShouldNot(HaveOccurred())36	out := ProfileLines{}37	idx := 038	for _, line := range strings.Split(string(output), "\n") {39		matches := PROFILE_RE.FindStringSubmatch(line)40		if matches == nil {41			continue42		}43		cumStatEntry := matches[1]44		var cumStat float6445		if strings.Contains(cumStatEntry, "MB") {46			var err error47			cumStat, err = strconv.ParseFloat(strings.TrimRight(cumStatEntry, "MB"), 64)48			ExpectWithOffset(1, err).ShouldNot(HaveOccurred())49		} else {50			duration, err := time.ParseDuration(cumStatEntry)51			ExpectWithOffset(1, err).ShouldNot(HaveOccurred())52			cumStat = float64(duration.Milliseconds())53		}54		out = append(out, ProfileLine{55			Index:   idx,56			Caller:  matches[2],57			CumStat: cumStat,58		})59		idx += 160	}61	return out62}63var _ = Describe("Profiling Specs", func() {64	Describe("Measuring code coverage", func() {65		BeforeEach(func() {66			fm.MountFixture("coverage")67		})68		processCoverageProfile := func(path string) string {69			profileOutput, err := exec.Command("go", "tool", "cover", fmt.Sprintf("-func=%s", path)).CombinedOutput()70			ExpectWithOffset(1, err).ShouldNot(HaveOccurred())71			return string(profileOutput)72		}73		Context("when running a single package in series or in parallel with -cover", func() {74			It("emits the coverage pecentage and generates a cover profile", func() {75				seriesSession := startGinkgo(fm.PathTo("coverage"), "--no-color", "-cover")76				Eventually(seriesSession).Should(gexec.Exit(0))77				Ω(seriesSession.Out).Should(gbytes.Say(`coverage: 80\.0% of statements`))78				seriesCoverage := processCoverageProfile(fm.PathTo("coverage", "coverprofile.out"))79				fm.RemoveFile("coverage", "coverprofile.out")80				parallelSession := startGinkgo(fm.PathTo("coverage"), "--no-color", "--procs=2", "-cover")81				Eventually(parallelSession).Should(gexec.Exit(0))82				Ω(parallelSession.Out).Should(gbytes.Say(`coverage: 80\.0% of statements`))83				parallelCoverage := processCoverageProfile(fm.PathTo("coverage", "coverprofile.out"))84				Ω(parallelCoverage).Should(Equal(seriesCoverage))85			})86		})87		Context("with -coverpkg", func() {88			It("computes coverage of the passed-in additional packages", func() {89				coverPkgFlag := fmt.Sprintf("-coverpkg=%s,%s", fm.PackageNameFor("coverage"), fm.PackageNameFor("coverage/external_coverage"))90				seriesSession := startGinkgo(fm.PathTo("coverage"), coverPkgFlag)91				Eventually(seriesSession).Should(gexec.Exit(0))92				Ω(seriesSession.Out).Should(gbytes.Say("coverage: 71.4% of statements in"))93				seriesCoverage := processCoverageProfile(fm.PathTo("coverage", "coverprofile.out"))94				fm.RemoveFile("coverage", "coverprofile.out")95				parallelSession := startGinkgo(fm.PathTo("coverage"), "--no-color", "--procs=2", coverPkgFlag)96				Eventually(parallelSession).Should(gexec.Exit(0))97				Ω(parallelSession.Out).Should(gbytes.Say(`coverage: 71\.4% of statements`))98				parallelCoverage := processCoverageProfile(fm.PathTo("coverage", "coverprofile.out"))99				Ω(parallelCoverage).Should(Equal(seriesCoverage))100			})101		})102		Context("with a custom profile name", func() {103			It("generates cover profiles with the specified name", func() {104				session := startGinkgo(fm.PathTo("coverage"), "--no-color", "-coverprofile=myprofile.out")105				Eventually(session).Should(gexec.Exit(0))106				Ω(session.Out).Should(gbytes.Say(`coverage: 80\.0% of statements`))107				Ω(fm.PathTo("coverage", "myprofile.out")).Should(BeAnExistingFile())108				Ω(fm.PathTo("coverage", "coverprofile.out")).ShouldNot(BeAnExistingFile())109			})110		})111		Context("when multiple suites are tested", func() {112			BeforeEach(func() {113				fm.MountFixture("combined_coverage")114			})115			It("generates a single cover profile", func() {116				session := startGinkgo(fm.PathTo("combined_coverage"), "--no-color", "--cover", "-r", "--procs=2", "--covermode=atomic")117				Eventually(session).Should(gexec.Exit(0))118				Ω(fm.PathTo("combined_coverage", "coverprofile.out")).Should(BeAnExistingFile())119				Ω(fm.PathTo("combined_coverage", "first_package/coverprofile.out")).ShouldNot(BeAnExistingFile())120				Ω(fm.PathTo("combined_coverage", "second_package/coverprofile.out")).ShouldNot(BeAnExistingFile())121				Ω(fm.PathTo("combined_coverage", "third_package/coverprofile.out")).ShouldNot(BeAnExistingFile())122				Ω(session.Out).Should(gbytes.Say(`coverage: 80\.0% of statements`))123				Ω(session.Out).Should(gbytes.Say(`coverage: 100\.0% of statements`))124				Ω(session.Out).Should(gbytes.Say(`coverage: \[no statements\]`))125				By("ensuring there is only one 'mode:' line")126				re := regexp.MustCompile(`mode: atomic`)127				content := fm.ContentOf("combined_coverage", "coverprofile.out")128				matches := re.FindAllStringIndex(content, -1)129				Ω(len(matches)).Should(Equal(1))130				By("emitting a composite coverage score")131				Ω(session.Out).Should(gbytes.Say(`composite coverage: 90\.0% of statements`))132			})133			Context("when -keep-separate-coverprofiles is set", func() {134				It("generates separate coverprofiles", Label("slow"), func() {135					session := startGinkgo(fm.PathTo("combined_coverage"), "--no-color", "--cover", "-r", "--procs=2", "--keep-separate-coverprofiles")136					Eventually(session).Should(gexec.Exit(0))137					Ω(fm.PathTo("combined_coverage", "coverprofile.out")).ShouldNot(BeAnExistingFile())138					Ω(fm.PathTo("combined_coverage", "first_package/coverprofile.out")).Should(BeAnExistingFile())139					Ω(fm.PathTo("combined_coverage", "second_package/coverprofile.out")).Should(BeAnExistingFile())140					Ω(fm.PathTo("combined_coverage", "third_package/coverprofile.out")).Should(BeAnExistingFile())141				})142			})143		})144		Context("when -output-dir is set", func() {145			BeforeEach(func() {146				fm.MountFixture("combined_coverage")147			})148			It("puts the cover profile in -output-dir", func() {149				session := startGinkgo(fm.PathTo("combined_coverage"), "--no-color", "--cover", "-r", "--procs=2", "--output-dir=./output")150				Eventually(session).Should(gexec.Exit(0))151				Ω(fm.PathTo("combined_coverage", "output/coverprofile.out")).Should(BeAnExistingFile())152				By("emitting a composite coverage score")153				Ω(session.Out).Should(gbytes.Say(`composite coverage: 90\.0% of statements`))154			})155			Context("when -keep-separate-coverprofiles is set", func() {156				It("puts namespaced coverprofiels in the -output-dir", func() {157					session := startGinkgo(fm.PathTo("combined_coverage"), "--no-color", "--cover", "-r", "--procs=2", "--output-dir=./output", "--keep-separate-coverprofiles")158					Eventually(session).Should(gexec.Exit(0))159					Ω(fm.PathTo("combined_coverage", "output/coverprofile.out")).ShouldNot(BeAnExistingFile())160					Ω(fm.PathTo("combined_coverage", "output/first_package_coverprofile.out")).Should(BeAnExistingFile())161					Ω(fm.PathTo("combined_coverage", "output/second_package_coverprofile.out")).Should(BeAnExistingFile())162				})163			})164		})165	})166	Describe("measuring cpu, memory, block, and mutex profiles", func() {167		BeforeEach(func() {168			fm.MountFixture("profile")169		})170		DescribeTable("profile behavior",171			func(pathToBinary func(string) string, pathToProfile func(string, string) string, args ...string) {172				args = append([]string{"--no-color", "-r", "--cpuprofile=cpu.out", "--memprofile=mem.out", "--blockprofile=block.out", "--mutexprofile=mutex.out"}, args...)173				session := startGinkgo(fm.PathTo("profile"), args...)174				Eventually(session).Should(gexec.Exit(0))175				// Verify that the binaries have been preserved and the profiles were generated176				for _, pkg := range []string{"slow_memory_hog", "block_contest", "lock_contest"} {177					Ω(pathToBinary(pkg)).Should(BeAnExistingFile())178					for _, profile := range []string{"cpu.out", "mem.out", "block.out", "mutex.out"} {179						Ω(pathToProfile(pkg, profile)).Should(BeAnExistingFile())180					}181				}182				cpuProfile := ParseProfile(pathToBinary("slow_memory_hog"), pathToProfile("slow_memory_hog", "cpu.out"))183				// The CPUProfile for the slow_memory_hog test should list the slow_memory_hog.SomethingExpensive functions as one of the most time-consuming functions184				// we can't assert on time as that will vary from machine to machine, however we _can_ assert that the slow_memory_hog.SomethingExpensive185				// function has a low index186				Ω(cpuProfile.FindCaller("slow_memory_hog.SomethingExpensive").Index).Should(BeNumerically("<=", 10))187				memProfile := ParseProfile(pathToBinary("slow_memory_hog"), pathToProfile("slow_memory_hog", "mem.out"))188				// The MemProifle for the slow_memory_hog test should list the slow_memory_hog.SomethingExpensive functions as one of the most memory-consuming functions189				// Assrting on the amount of memory consumed should be stable across tests as the function always builds a large array of this size190				Ω(memProfile.FindCaller("slow_memory_hog.SomethingExpensive").CumStat).Should(BeNumerically(">=", 200))191				blockProfile := ParseProfile(pathToBinary("block_contest"), pathToProfile("block_contest", "block.out"))192				// The BlockProfile for the block_contest test should list two channel-reading functions:193				// block_contest.ReadTheChannel is called 10 times and takes ~5ms per call194				// block_contest.SlowReadTheChannel is called once and teakes ~500ms per call195				// Asserting that both times are within a range should be stable across tests196				// Note: these numbers are adjusted slightly to tolerate variance during test runs197				Ω(blockProfile.FindCaller("block_contest.ReadTheChannel").CumStat).Should(BeNumerically(">=", 45))198				Ω(blockProfile.FindCaller("block_contest.ReadTheChannel").CumStat).Should(BeNumerically("<", 500))199				Ω(blockProfile.FindCaller("block_contest.SlowReadTheChannel").CumStat).Should(BeNumerically(">=", 450))200				mutexProfile := ParseProfile(pathToBinary("lock_contest"), pathToProfile("lock_contest", "mutex.out"))201				// The MutexProfile for the lock_contest test should list two functions that wait on a lock.202				// Unfortunately go doesn't seem to capture the names of the functions - so they're listed here as203				// lock_contest_test.glob..func1.1 is called 10 times and takes ~5ms per call204				// lock_contest_test.glob..func2.1 is called once and teakes ~500ms per call205				// Asserting that both times are within a range should be stable across tests.  The function names should be as well206				// but that might become a source of failure in the future207				// Note: these numbers are adjusted slightly to tolerate variance during test runs208				Ω(mutexProfile.FindCaller("lock_contest_test.glob..func1.1").CumStat).Should(BeNumerically(">=", 45))209				Ω(mutexProfile.FindCaller("lock_contest_test.glob..func1.1").CumStat).Should(BeNumerically("<", 500))210				Ω(mutexProfile.FindCaller("lock_contest_test.glob..func2.1").CumStat).Should(BeNumerically(">=", 450))211			},212			Entry("when running in series",213				func(pkg string) string { return fm.PathTo("profile", pkg+"/"+pkg+".test") },214				func(pkg string, profile string) string { return fm.PathTo("profile", pkg+"/"+profile) },...

1import (2func main() {3	profile := integration_test.ParseProfile("profile.html")4	fmt.Println(profile)5}6import (7func main() {8	profile := integration_test.ParseProfile("profile.html")9	fmt.Println(profile)10}11import (12func main() {13	profile := integration_test.ParseProfile("profile.html")14	fmt.Println(profile)15}16import (17func main() {18	profile := integration_test.ParseProfile("profile.html")19	fmt.Println(profile)20}21import (22func main() {23	profile := integration_test.ParseProfile("profile.html")24	fmt.Println(profile)25}26import (27func main() {28	profile := integration_test.ParseProfile("profile.html")29	fmt.Println(profile)30}31import (32func main() {33	profile := integration_test.ParseProfile("profile.html")34	fmt.Println(profile)35}36import (37func main() {38	profile := integration_test.ParseProfile("profile.html")

1import (2func main() {3	profile := engine.Request{4		ParserFunc: func(contents []byte, url string) engine.ParseResult {5			return parser.ParseProfile(contents, url, "安静的雪")6		},7	}8	result := engine.Worker(profile)9	for _, item := range result.Items {10		profile, ok := item.Payload.(model.Profile)11		if ok {12			fmt.Printf("%v", profile)13		}14	}15}

1func main() {2    c := colly.NewCollector()3    c.OnHTML("a[href]", func(e *colly.HTMLElement) {4        e.Request.Visit(e.Attr("href"))5    })6    c.OnRequest(func(r *colly.Request) {7        fmt.Println("Visiting", r.URL.String())8    })9}10func main() {11    c := colly.NewCollector()12    c.OnHTML("a[href]", func(e *colly.HTMLElement) {13        e.Request.Visit(e.Attr("href"))14    })15    c.OnRequest(func(r *colly.Request) {16        fmt.Println("Visiting", r.URL.String())17    })18}19func main() {20    c := colly.NewCollector()21    c.OnHTML("a[href]", func(e *colly.HTMLElement) {22        e.Request.Visit(e.Attr("href"))23    })24    c.OnRequest(func(r *colly.Request) {25        fmt.Println("Visiting", r.URL.String())26    })27}28func main() {