func Measure(text string, body interface{}, samples int) bool {
	deprecationTracker.TrackDeprecation(types.Deprecations.Measure(), codelocation.New(1))
	global.Suite.PushMeasureNode(text, body, types.FlagTypeNone, codelocation.New(1), samples)
	return true
}
Measure blocks run the passed in body function repeatedly (determined by the samples argument)
and accumulate metrics provided to the Benchmarker by the body function.

The body function must have the signature:
func(b Benchmarker)
package ginkgo
import (
	"flag"
	"fmt"
	"io"
	"net/http"
	"os"
	"reflect"
	"strings"
	"time"
	"github.com/onsi/ginkgo/config"
	"github.com/onsi/ginkgo/internal/codelocation"
	"github.com/onsi/ginkgo/internal/global"
	"github.com/onsi/ginkgo/internal/remote"
	"github.com/onsi/ginkgo/internal/testingtproxy"
	"github.com/onsi/ginkgo/internal/writer"
	"github.com/onsi/ginkgo/reporters"
	"github.com/onsi/ginkgo/reporters/stenographer"
	colorable "github.com/onsi/ginkgo/reporters/stenographer/support/go-colorable"
	"github.com/onsi/ginkgo/types"
)
var deprecationTracker = types.NewDeprecationTracker()
const GINKGO_VERSION = config.VERSION
const GINKGO_PANIC = `
Your test failed.
Ginkgo panics to prevent subsequent assertions from running.
Normally Ginkgo rescues this panic so you shouldn't see it.
But, if you make an assertion in a goroutine, Ginkgo can't capture the panic.
To circumvent this, you should call
	defer GinkgoRecover()
at the top of the goroutine that caused this panic.
`
func init() {
	config.Flags(flag.CommandLine, "ginkgo", true)
	GinkgoWriter = writer.New(os.Stdout)
}
var GinkgoWriter io.Writer
type GinkgoTestingT interface {
	Fail()
}
func GinkgoRandomSeed() int64 {
	return config.GinkgoConfig.RandomSeed
}
func GinkgoParallelNode() int {
	return config.GinkgoConfig.ParallelNode
}
func GinkgoT(optionalOffset ...int) GinkgoTInterface {
	offset := 3
	if len(optionalOffset) > 0 {
		offset = optionalOffset[0]
	}
	failedFunc := func() bool {
		return CurrentGinkgoTestDescription().Failed
	}
	nameFunc := func() string {
		return CurrentGinkgoTestDescription().FullTestText
	}
	return testingtproxy.New(GinkgoWriter, Fail, Skip, failedFunc, nameFunc, offset)
}
type GinkgoTInterface interface {
	Cleanup(func())
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Fail()
	FailNow()
	Failed() bool
	Fatal(args ...interface{})
	Fatalf(format string, args ...interface{})
	Helper()
	Log(args ...interface{})
	Logf(format string, args ...interface{})
	Name() string
	Parallel()
	Skip(args ...interface{})
	SkipNow()
	Skipf(format string, args ...interface{})
	Skipped() bool
	TempDir() string
}
type Reporter reporters.Reporter
type Done chan<- interface{}
type GinkgoTestDescription struct {
	FullTestText   string
	ComponentTexts []string
	TestText       string
	IsMeasurement bool
	FileName   string
	LineNumber int
	Failed   bool
	Duration time.Duration
}
func CurrentGinkgoTestDescription() GinkgoTestDescription {
	summary, ok := global.Suite.CurrentRunningSpecSummary()
	if !ok {
		return GinkgoTestDescription{}
	}
	subjectCodeLocation := summary.ComponentCodeLocations[len(summary.ComponentCodeLocations)-1]
	return GinkgoTestDescription{
		ComponentTexts: summary.ComponentTexts[1:],
		FullTestText:   strings.Join(summary.ComponentTexts[1:], " "),
		TestText:       summary.ComponentTexts[len(summary.ComponentTexts)-1],
		IsMeasurement:  summary.IsMeasurement,
		FileName:       subjectCodeLocation.FileName,
		LineNumber:     subjectCodeLocation.LineNumber,
		Failed:         summary.HasFailureState(),
		Duration:       summary.RunTime,
	}
}
type Benchmarker interface {
	Time(name string, body func(), info ...interface{}) (elapsedTime time.Duration)
	RecordValue(name string, value float64, info ...interface{})
	RecordValueWithPrecision(name string, value float64, units string, precision int, info ...interface{})
}
func RunSpecs(t GinkgoTestingT, description string) bool {
	specReporters := []Reporter{buildDefaultReporter()}
	if config.DefaultReporterConfig.ReportFile != "" {
		reportFile := config.DefaultReporterConfig.ReportFile
		specReporters[0] = reporters.NewJUnitReporter(reportFile)
		specReporters = append(specReporters, buildDefaultReporter())
	}
	return runSpecsWithCustomReporters(t, description, specReporters)
}
func RunSpecsWithDefaultAndCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {
	deprecationTracker.TrackDeprecation(types.Deprecations.CustomReporter())
	specReporters = append(specReporters, buildDefaultReporter())
	return runSpecsWithCustomReporters(t, description, specReporters)
}
func RunSpecsWithCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {
	deprecationTracker.TrackDeprecation(types.Deprecations.CustomReporter())
	return runSpecsWithCustomReporters(t, description, specReporters)
}
func runSpecsWithCustomReporters(t GinkgoTestingT, description string, specReporters []Reporter) bool {
	writer := GinkgoWriter.(*writer.Writer)
	writer.SetStream(config.DefaultReporterConfig.Verbose)
	reporters := make([]reporters.Reporter, len(specReporters))
	for i, reporter := range specReporters {
		reporters[i] = reporter
	}
	passed, hasFocusedTests := global.Suite.Run(t, description, reporters, writer, config.GinkgoConfig)
	if deprecationTracker.DidTrackDeprecations() {
		fmt.Fprintln(colorable.NewColorableStderr(), deprecationTracker.DeprecationsReport())
	}
	if passed && hasFocusedTests && strings.TrimSpace(os.Getenv("GINKGO_EDITOR_INTEGRATION")) == "" {
		fmt.Println("PASS | FOCUSED")
		os.Exit(types.GINKGO_FOCUS_EXIT_CODE)
	}
	return passed
}
func buildDefaultReporter() Reporter {
	remoteReportingServer := config.GinkgoConfig.StreamHost
	if remoteReportingServer == "" {
		stenographer := stenographer.New(!config.DefaultReporterConfig.NoColor, config.GinkgoConfig.FlakeAttempts > 1, colorable.NewColorableStdout())
		return reporters.NewDefaultReporter(config.DefaultReporterConfig, stenographer)
	} else {
		debugFile := ""
		if config.GinkgoConfig.DebugParallel {
			debugFile = fmt.Sprintf("ginkgo-node-%d.log", config.GinkgoConfig.ParallelNode)
		}
		return remote.NewForwardingReporter(config.DefaultReporterConfig, remoteReportingServer, &http.Client{}, remote.NewOutputInterceptor(), GinkgoWriter.(*writer.Writer), debugFile)
	}
}
func Skip(message string, callerSkip ...int) {
	skip := 0
	if len(callerSkip) > 0 {
		skip = callerSkip[0]
	}
	global.Failer.Skip(message, codelocation.New(skip+1))
	panic(GINKGO_PANIC)
}
func Fail(message string, callerSkip ...int) {
	skip := 0
	if len(callerSkip) > 0 {
		skip = callerSkip[0]
	}
	global.Failer.Fail(message, codelocation.New(skip+1))
	panic(GINKGO_PANIC)
}
func GinkgoRecover() {
	e := recover()
	if e != nil {
		global.Failer.Panic(codelocation.New(1), e)
	}
}
func Describe(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
	return true
}
func FDescribe(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypeFocused, codelocation.New(1))
	return true
}
func PDescribe(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
	return true
}
func XDescribe(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
	return true
}
func Context(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypeNone, codelocation.New(1))
	return true
}
func FContext(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypeFocused, codelocation.New(1))
	return true
}
func PContext(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
	return true
}
func XContext(text string, body func()) bool {
	global.Suite.PushContainerNode(text, body, types.FlagTypePending, codelocation.New(1))
	return true
}
func When(text string, body func()) bool {
	global.Suite.PushContainerNode("when "+text, body, types.FlagTypeNone, codelocation.New(1))
	return true
}
func FWhen(text string, body func()) bool {
	global.Suite.PushContainerNode("when "+text, body, types.FlagTypeFocused, codelocation.New(1))
	return true
}
func PWhen(text string, body func()) bool {
	global.Suite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))
	return true
}
func XWhen(text string, body func()) bool {
	global.Suite.PushContainerNode("when "+text, body, types.FlagTypePending, codelocation.New(1))
	return true
}
func It(text string, body interface{}, timeout ...float64) bool {
	validateBodyFunc(body, codelocation.New(1))
	global.Suite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))
	return true
}
func FIt(text string, body interface{}, timeout ...float64) bool {
	validateBodyFunc(body, codelocation.New(1))
	global.Suite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))
	return true
}
func PIt(text string, _ ...interface{}) bool {
	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
	return true
}
func XIt(text string, _ ...interface{}) bool {
	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
	return true
}
func Specify(text string, body interface{}, timeout ...float64) bool {
	validateBodyFunc(body, codelocation.New(1))
	global.Suite.PushItNode(text, body, types.FlagTypeNone, codelocation.New(1), parseTimeout(timeout...))
	return true
}
func FSpecify(text string, body interface{}, timeout ...float64) bool {
	validateBodyFunc(body, codelocation.New(1))
	global.Suite.PushItNode(text, body, types.FlagTypeFocused, codelocation.New(1), parseTimeout(timeout...))
	return true
}
func PSpecify(text string, is ...interface{}) bool {
	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
	return true
}
func XSpecify(text string, is ...interface{}) bool {
	global.Suite.PushItNode(text, func() {}, types.FlagTypePending, codelocation.New(1), 0)
	return true
}
func By(text string, callbacks ...func()) {
	preamble := "\x1b[1mSTEP\x1b[0m"
	if config.DefaultReporterConfig.NoColor {
		preamble = "STEP"
	}
	fmt.Fprintln(GinkgoWriter, preamble+": "+text)
	if len(callbacks) == 1 {
		callbacks[0]()
	}
	if len(callbacks) > 1 {
		panic("just one callback per By, please")
	}
}