package coverage
Import Path
	internal/coverage (on go.dev)
Dependency Relation
	imports 0 packages, and imported by 8 packages
Package-Level Type Names (total 11)
	
		CounterFileHeader stores files header information for a counter-data file.
		
			BigEndian bool
			CFlavor CounterFlavor
			Magic [4]byte
			MetaHash [16]byte
			Version uint32
	
		CounterFlavor describes how function and counters are
		stored/represented in the counter section of the file.
		
			func internal/coverage/encodecounter.NewCoverageDataWriter(w io.Writer, flav CounterFlavor) *encodecounter.CoverageDataWriter
		
			const CtrRaw
			const CtrULeb128
	
		CounterGranularity tracks the granularity of the coverage counters being
		used in a given coverage-instrumented program.
		
			( CounterGranularity) String() string
		
			 CounterGranularity : expvar.Var
			 CounterGranularity : fmt.Stringer
		
			func internal/coverage/cmerge.(*Merger).Granularity() CounterGranularity
			func internal/coverage/decodemeta.(*CoverageMetaFileReader).CounterGranularity() CounterGranularity
		
			func internal/coverage/cmerge.(*Merger).SetModeAndGranularity(mdf string, cmode CounterMode, cgran CounterGranularity) error
			func internal/coverage/encodemeta.(*CoverageMetaFileWriter).Write(finalHash [16]byte, blobs [][]byte, mode CounterMode, granularity CounterGranularity) error
		
			const CtrGranularityInvalid
			const CtrGranularityPerBlock
			const CtrGranularityPerFunc
	
		CounterMode tracks the "flavor" of the coverage counters being
		used in a given coverage-instrumented program.
		
			( CounterMode) String() string
		
			 CounterMode : expvar.Var
			 CounterMode : fmt.Stringer
		
			func ParseCounterMode(mode string) CounterMode
			func internal/coverage/cmerge.(*Merger).Mode() CounterMode
			func internal/coverage/decodemeta.(*CoverageMetaFileReader).CounterMode() CounterMode
		
			func internal/coverage/cformat.NewFormatter(cm CounterMode) *cformat.Formatter
			func internal/coverage/cmerge.(*Merger).SetModeAndGranularity(mdf string, cmode CounterMode, cgran CounterGranularity) error
			func internal/coverage/encodemeta.(*CoverageMetaFileWriter).Write(finalHash [16]byte, blobs [][]byte, mode CounterMode, granularity CounterGranularity) error
		
			const CtrModeAtomic
			const CtrModeCount
			const CtrModeInvalid
			const CtrModeRegOnly
			const CtrModeSet
			const CtrModeTestMain
	
		CounterSegmentHeader encapsulates information about a specific
		segment in a counter data file, which at the moment contains
		counters data from a single execution of a coverage-instrumented
		program. Following the segment header will be the string table and
		args table, and then (possibly) padding bytes to bring the byte
		size of the preamble up to a multiple of 4. Immediately following
		that will be the counter payloads.
		
		The "args" section of a segment is used to store annotations
		describing where the counter data came from; this section is
		basically a series of key-value pairs (can be thought of as an
		encoded 'map[string]string'). At the moment we only write os.Args()
		data to this section, using pairs of the form "argc=<integer>",
		"argv0=<os.Args[0]>", "argv1=<os.Args[1]>", and so on. In the
		future the args table may also include things like GOOS/GOARCH
		values, and/or tags indicating which tests were run to generate the
		counter data.
		
			ArgsLen uint32
			FcnEntries uint64
			StrTabLen uint32
	
		CoverableUnit describes the source characteristics of a single
		program unit for which we want to gather coverage info. Coverable
		units are either "simple" or "intraline"; a "simple" coverable unit
		corresponds to a basic block (region of straight-line code with no
		jumps or control transfers). An "intraline" unit corresponds to a
		logical clause nested within some other simple unit. A simple unit
		will have a zero Parent value; for an intraline unit NxStmts will
		be zero and Parent will be set to 1 plus the index of the
		containing simple statement. Example:
		
			L7:   q := 1
			L8:   x := (y == 101 || launch() == false)
			L9:   r := x * 2
		
		For the code above we would have three simple units (one for each
		line), then an intraline unit describing the "launch() == false"
		clause in line 8, with Parent pointing to the index of the line 8
		unit in the units array.
		
		Note: in the initial version of the coverage revamp, only simple
		units will be in use.
		
			EnCol uint32
			EnLine uint32
			NxStmts uint32
			Parent uint32
			StCol uint32
			StLine uint32
		
			func internal/coverage/cformat.(*Formatter).AddUnit(file string, fname string, isfnlit bool, unit CoverableUnit, count uint32)
	
		FuncDesc encapsulates the meta-data definitions for a single Go function.
		This version assumes that we're looking at a function before inlining;
		if we want to capture a post-inlining view of the world, the
		representations of source positions would need to be a good deal more
		complicated.
		
			Funcname string
			
				// true if this is a function literal
			Srcfile string
			Units []CoverableUnit
		
			func internal/coverage/decodemeta.(*CoverageMetaDataDecoder).ReadFunc(fidx uint32, f *FuncDesc) error
			func internal/coverage/encodemeta.HashFuncDesc(f *FuncDesc) [16]byte
			func internal/coverage/encodemeta.(*CoverageMetaDataBuilder).AddFunc(f FuncDesc) uint
	
		MetaFileCollection contains information generated by the Go command and
		the read in by coverage test support functions within an executing
		"go test -cover" binary.
		
			ImportPaths []string
			MetaFileFragments []string
	
		MetaFileHeader stores file header information for a meta-data file.
		
			CGranularity CounterGranularity
			CMode CounterMode
			Entries uint64
			Magic [4]byte
			MetaFileHash [16]byte
			StrTabLength uint32
			StrTabOffset uint32
			TotalLength uint64
			Version uint32
Package-Level Functions (total 3)
	
		HardCodedPkgID returns the hard-coded ID for the specified package
		path, or -1 if we don't use a hard-coded ID. Hard-coded IDs start
		at -2 and decrease as we go down the list.
	 func ParseCounterMode(mode string) CounterMode
Package-Level Variables (total 2)
	
		CovCounterMagic holds the magic string for a coverage counter-data file.
	
		CovMetaMagic holds the magic string for a meta-data file.
Package-Level Constants (total 24)
	
		CounterFilePref is the file prefix used when emitting coverage data
		output files. CounterFileTemplate describes the format of the file
		name: prefix followed by meta-file hash followed by process ID
		followed by emit UnixNanoTime.
	const CounterFileRegexp = "^%s\\.(\\S+)\\.(\\d+)\\.(\\d+)+$"	const CounterFileTempl = "%s.%x.%d.%d"	
		CounterFileVersion stores the most recent counter data file version.
	const CovMetaHeaderSize = 44 // keep in sync with above	const CtrGranularityInvalid CounterGranularity = 0	const CtrGranularityPerBlock CounterGranularity = 1	const CtrGranularityPerFunc CounterGranularity = 2	const CtrModeAtomic CounterMode = 3 // "atomic" mode	const CtrModeCount CounterMode = 2 // "count" mode	const CtrModeInvalid CounterMode = 0	const CtrModeRegOnly CounterMode = 4 // registration-only pseudo-mode	const CtrModeSet CounterMode = 1 // "set" mode	const CtrModeTestMain CounterMode = 5 // testmain pseudo-mode	
		"Raw" representation: all values (pkg ID, func ID, num counters,
		and counters themselves) are stored as uint32's.
	
		"ULeb" representation: all values (pkg ID, func ID, num counters,
		and counters themselves) are stored with ULEB128 encoding.
	const FirstCtrOffset = 3	const FuncIdOffset = 2	
		MetaFilePref is a prefix used when emitting meta-data files; these
		files are of the form "covmeta.<hash>", where hash is a hash
		computed from the hashes of all the package meta-data symbols in
		the program.
	
		Name of file within the "go test -cover" temp coverdir directory
		containing a list of meta-data files for packages being tested
		in a "go test -coverpkg=... ..." run. This constant is shared
		by the Go command and by the coverage runtime.
	
		MetaFileVersion contains the current (most recent) meta-data file version.
	
		NotHardCoded is a package pseudo-ID indicating that a given package
		is not part of the runtime and doesn't require a hard-coded ID.
	const NumCtrsOffset = 0	const PkgIdOffset = 1![]()  | 
The pages are generated with Golds v0.7.9-preview. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |