coverage

type BlockCoverage struct {
	Type      Type `json:"type"`
	StartLine *int `json:"start_line,omitempty"`
	StartCol  *int `json:"start_col,omitempty"`
	EndLine   *int `json:"end_line,omitempty"`
	EndCol    *int `json:"end_col,omitempty"`
	NumStmt   *int `json:"num_stmt,omitempty"`
	Count     *int `json:"count,omitempty"`
}

type BlockCoverages []*BlockCoverage

type Clover struct{}

type CloverReport struct {
	XMLName   xml.Name             `xml:"coverage"`
	Generated string               `xml:"generated,attr"`
	Project   *CloverReportProject `xml:"project"`
}

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 CloverReportPackage struct {
	XMLName xml.Name           `xml:"package"`
	Name    string             `xml:"name,attr"`
	File    []CloverReportFile `xml:"file"`
}

type CloverReportProject struct {
	Timestamp string                `xml:"timestamp,attr"`
	File      []CloverReportFile    `xml:"file"`
	Package   []CloverReportPackage `xml:"package"`
	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"`
}

type Cobertura struct{}

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 *CoberturaReportPackages `xml:"packages"`
}

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 CoberturaReportPackages struct {
	Package []CoberturaReportPackage `xml:"package"`
}

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

type DiffCoverage struct {
	A         float64           `json:"a"`
	B         float64           `json:"b"`
	Diff      float64           `json:"diff"`
	CoverageA *Coverage         `json:"-"`
	CoverageB *Coverage         `json:"-"`
	Files     DiffFileCoverages `json:"files"`
}

type DiffFileCoverage struct {
	File          string        `json:"file"`
	A             float64       `json:"a"`
	B             float64       `json:"b"`
	Diff          float64       `json:"diff"`
	FileCoverageA *FileCoverage `json:"-"`
	FileCoverageB *FileCoverage `json:"-"`
}

type DiffFileCoverages []*DiffFileCoverage

type FileCoverage struct {
	Type    Type           `json:"type"`
	File    string         `json:"file"`
	Total   int            `json:"total"`
	Covered int            `json:"covered"`
	Blocks  BlockCoverages `json:"blocks,omitempty"`
	// contains filtered or unexported fields
}

type FileCoverages []*FileCoverage

type Gocover struct{}

type Jacoco struct{}

type JacocoReport struct {
	XMLName     xml.Name `xml:"report"`
	Text        string   `xml:",chardata"`
	Name        string   `xml:"name,attr"`
	Sessioninfo []struct {
		Text  string `xml:",chardata"`
		ID    string `xml:"id,attr"`
		Start string `xml:"start,attr"`
		Dump  string `xml:"dump,attr"`
	} `xml:"sessioninfo"`
	Package []*JacocoReportPackage `xml:"package"`
	Counter []*JacocoReportCounter `xml:"counter"`
}

type JacocoReportCounter struct {
	Text    string `xml:",chardata"`
	Type    string `xml:"type,attr"`
	Missed  int    `xml:"missed,attr"`
	Covered int    `xml:"covered,attr"`
}

type JacocoReportPackage struct {
	Text  string `xml:",chardata"`
	Name  string `xml:"name,attr"`
	Class []struct {
		Text           string `xml:",chardata"`
		Name           string `xml:"name,attr"`
		Sourcefilename string `xml:"sourcefilename,attr"`
		Method         []struct {
			Text    string                 `xml:",chardata"`
			Name    string                 `xml:"name,attr"`
			Desc    string                 `xml:"desc,attr"`
			Line    int                    `xml:"line,attr"`
			Counter []*JacocoReportCounter `xml:"counter"`
		} `xml:"method"`
		Counter []*JacocoReportCounter `xml:"counter"`
	} `xml:"class"`
	Sourcefile []struct {
		Text string `xml:",chardata"`
		Name string `xml:"name,attr"`
		Line []struct {
			Text string `xml:",chardata"`
			Nr   int    `xml:"nr,attr"` // line number
			Mi   int    `xml:"mi,attr"` // missed interactions
			Ci   int    `xml:"ci,attr"` // covered interactions
			Mb   int    `xml:"mb,attr"` // missed branches
			Cb   int    `xml:"cb,attr"` // covered branches
		} `xml:"line"`
		Counter []*JacocoReportCounter `xml:"counter"`
	} `xml:"sourcefile"`
	Counter []*JacocoReportCounter `xml:"counter"`
}

type Lcov struct{}

type LineCoverage struct {
	Line         int
	Count        int
	PosCoverages PosCoverages
}

type LineCoverages []*LineCoverage

type PosCoverage struct {
	Pos   int
	Count int
}

type PosCoverages []*PosCoverage

type Printer struct {
	// contains filtered or unexported fields
}

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

type Simplecov struct{}

type SimplecovCoverage struct {
	Coverage map[string]SimplecovFileCoverage `json:"coverage"`
}

type SimplecovFileCoverage struct {
	Lines []any `json:"lines"`
}

type SimplecovReport map[string]SimplecovCoverage

type Type string