coverage

Documentation

Index

• Constants
• Variables
• type Clover
  • func NewClover() *Clover
  • func (c *Clover) ParseReport(path string) (*Coverage, string, error)
• type CloverReport
• type CloverReportFile
• type Cobertura
  • func NewCobertura() *Cobertura
  • func (c *Cobertura) ParseReport(path string) (*Coverage, string, error)
• type CoberturaReport
• type CoberturaReportPackage
• type Coverage
  • func Measure(path string) (*Coverage, string, error)
  • func New() *Coverage
• type FileCoverage
  • func NewFileCoverage(fileName string) *FileCoverage
• type FileCoverages
  • func (coverages FileCoverages) FindByFileName(fileName string) (*FileCoverage, error)
• type Gocover
  • func NewGocover() *Gocover
  • func (g *Gocover) ParseReport(path string) (*Coverage, string, error)
• type Lcov
  • func NewLcov() *Lcov
  • func (l *Lcov) ParseReport(path string) (*Coverage, string, error)
• type Processor
• type Simplecov
  • func NewSimplecov() *Simplecov
  • func (s *Simplecov) ParseReport(path string) (*Coverage, string, error)
• type SimplecovCoverage
• type SimplecovFileCoverage
• type SimplecovReport
• type Type

Constants

const CloverDefaultPath = "coverage.xml"

const CoberturaDefaultPath = "coverage.xml"

const GocoverDefaultPath = "coverage.out"

Variables

var LcovDefaultPath = []string{"coverage", "lcov.info"}

var SimplecovDefaultPath = []string{"coverage", ".resultset.json"}

Types

type Clover

type Clover struct{}

func NewClover

func NewClover() *Clover

func (*Clover) ParseReport

func (c *Clover) ParseReport(path string) (*Coverage, string, error)

type CloverReport

type CloverReport struct {
	XMLName   xml.Name `xml:"coverage"`
	Generated string   `xml:"generated,attr"`
	Project   struct {
		Timestamp string             `xml:"timestamp,attr"`
		File      []CloverReportFile `xml:"file"`
		Metrics   struct {
			Files               int `xml:"files,attr"`
			Loc                 int `xml:"loc,attr"`
			Ncloc               int `xml:"ncloc,attr"`
			Classes             int `xml:"classes,attr"`
			Methods             int `xml:"methods,attr"`
			Coveredmethods      int `xml:"coveredmethods,attr"`
			Conditionals        int `xml:"conditionals,attr"`
			Coveredconditionals int `xml:"coveredconditionals,attr"`
			Statements          int `xml:"statements,attr"`
			Coveredstatements   int `xml:"coveredstatements,attr"`
			Elements            int `xml:"elements,attr"`
			Coveredelements     int `xml:"coveredelements,attr"`
		} `xml:"metrics"`
	} `xml:"project"`
}

type CloverReportFile

type CloverReportFile struct {
	XMLName xml.Name `xml:"file"`
	Name    string   `xml:"name,attr"`
	Metrics struct {
		Loc                 int `xml:"loc,attr"`
		Ncloc               int `xml:"ncloc,attr"`
		Classes             int `xml:"classes,attr"`
		Methods             int `xml:"methods,attr"`
		Coveredmethods      int `xml:"coveredmethods,attr"`
		Conditionals        int `xml:"conditionals,attr"`
		Coveredconditionals int `xml:"coveredconditionals,attr"`
		Statements          int `xml:"statements,attr"`
		Coveredstatements   int `xml:"coveredstatements,attr"`
		Elements            int `xml:"elements,attr"`
		Coveredelements     int `xml:"coveredelements,attr"`
	} `xml:"metrics"`
	Class struct {
		Name      string `xml:"name,attr"`
		Namespace string `xml:"namespace,attr"`
		Metrics   struct {
			Complexity          int `xml:"complexity,attr"`
			Methods             int `xml:"methods,attr"`
			Coveredmethods      int `xml:"coveredmethods,attr"`
			Conditionals        int `xml:"conditionals,attr"`
			Coveredconditionals int `xml:"coveredconditionals,attr"`
			Statements          int `xml:"statements,attr"`
			Coveredstatements   int `xml:"coveredstatements,attr"`
			Elements            int `xml:"elements,attr"`
			Coveredelements     int `xml:"coveredelements,attr"`
		} `xml:"metrics"`
	} `xml:"class"`
	Line []struct {
		Num        int     `xml:"num,attr"`
		Type       string  `xml:"type,attr"`
		Name       string  `xml:"name,attr"`
		Visibility string  `xml:"visibility,attr"`
		Complexity int     `xml:"complexity,attr"`
		Crap       float64 `xml:"crap,attr"`
		Count      int     `xml:"count,attr"`
	} `xml:"line"`
}

type Cobertura

type Cobertura struct{}

func NewCobertura

func NewCobertura() *Cobertura

func (*Cobertura) ParseReport

func (c *Cobertura) ParseReport(path string) (*Coverage, string, error)

type CoberturaReport

type CoberturaReport struct {
	XMLName         xml.Name `xml:"coverage"`
	Version         string   `xml:"version,attr"`
	Timestamp       string   `xml:"timestamp,attr"`
	LinesValid      int      `xml:"lines-valid,attr"`
	LinesCovered    int      `xml:"lines-covered,attr"`
	LineRate        float64  `xml:"line-rate,attr"`
	BranchesCovered int      `xml:"branches-covered,attr"`
	BranchesValid   int      `xml:"branches-valid,attr"`
	BranchRate      float64  `xml:"branch-rate,attr"`
	Complexity      int      `xml:"complexity,attr"`
	Sources         struct {
		Source []string `xml:"source"`
	} `xml:"sources"`
	Packages struct {
		Package []CoberturaReportPackage `xml:"package"`
	} `xml:"packages"`
}

type CoberturaReportPackage

type CoberturaReportPackage struct {
	Name       string  `xml:"name,attr"`
	LineRate   float64 `xml:"line-rate,attr"`
	BranchRate float64 `xml:"branch-rate,attr"`
	Complexity int     `xml:"complexity,attr"`
	Classes    struct {
		Class []struct {
			Filename   string  `xml:"filename,attr"`
			Complexity int     `xml:"complexity,attr"`
			LineRate   float64 `xml:"line-rate,attr"`
			BranchRate float64 `xml:"branch-rate,attr"`
			Methods    struct {
				Method []struct {
					Name       string  `xml:"name,attr"`
					Signature  string  `xml:"signature,attr"`
					LineRate   float64 `xml:"line-rate,attr"`
					BranchRate float64 `xml:"branch-rate,attr"`
					Lines      struct {
						Line []struct {
							Number int `xml:"number,attr"`
							Hits   int `xml:"hits,attr"`
						} `xml:"line"`
					} `xml:"lines"`
				}
			} `xml:"methods"`
			Lines struct {
				Line []struct {
					Number int `xml:"number,attr"`
					Hits   int `xml:"hits,attr"`
				} `xml:"line"`
			} `xml:"lines"`
		} `xml:"class"`
	} `xml:"classes"`
}

type Coverage

type Coverage struct {
	Type    Type          `json:"type"`
	Format  string        `json:"format"`
	Total   int           `json:"total"`
	Covered int           `json:"covered"`
	Files   FileCoverages `json:"files"`
}

func Measure

func Measure(path string) (*Coverage, string, error)

func New

func New() *Coverage

type FileCoverage

type FileCoverage struct {
	FileName string `json:"file"`
	Total    int    `json:"total"`
	Covered  int    `json:"covered"`
}

func NewFileCoverage

func NewFileCoverage(fileName string) *FileCoverage

type FileCoverages

type FileCoverages []*FileCoverage

func (FileCoverages) FindByFileName

func (coverages FileCoverages) FindByFileName(fileName string) (*FileCoverage, error)

type Gocover

type Gocover struct{}

func NewGocover

func NewGocover() *Gocover

func (*Gocover) ParseReport

func (g *Gocover) ParseReport(path string) (*Coverage, string, error)

type Lcov

type Lcov struct{}

func NewLcov

func NewLcov() *Lcov

func (*Lcov) ParseReport

func (l *Lcov) ParseReport(path string) (*Coverage, string, error)

type Processor

type Processor interface {
	Name() string
	ParseReport(path string) (*Coverage, string, error)
}

type Simplecov

type Simplecov struct{}

func NewSimplecov

func NewSimplecov() *Simplecov

func (*Simplecov) ParseReport

func (s *Simplecov) ParseReport(path string) (*Coverage, string, error)

type SimplecovCoverage

type SimplecovCoverage struct {
	Coverage map[string]SimplecovFileCoverage
}

type SimplecovFileCoverage

type SimplecovFileCoverage struct {
	Lines []interface{}
}

type SimplecovReport

type SimplecovReport map[string]SimplecovCoverage

type Type

type Type string

const (
	TypeLOC       Type = "loc"
	TypeStatement Type = "statement"
)