[#5] Add covertest.Cover structure
It has embedded testing.Cover to collect coverage in standard form and sync.Mutex to be thread-safe Signed-off-by: Ekaterina Lebedeva <ekaterina.lebedeva@yadro.com>pull/10/head
parent
8e45fee116
commit
c51343019c
|
|
@ -6,32 +6,36 @@ import (
|
|||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/nspcc-dev/neo-go/pkg/compiler"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
var mu sync.Mutex
|
||||
|
||||
type coverline struct {
|
||||
Doc string
|
||||
Opcode int
|
||||
StartLine int
|
||||
StartCol int
|
||||
EndLine int
|
||||
EndCol int
|
||||
Statements int
|
||||
IsCovered bool
|
||||
type Cover struct {
|
||||
sync.Mutex
|
||||
testing.Cover
|
||||
Opcodes map[string][]int
|
||||
}
|
||||
|
||||
var cover = &Cover{}
|
||||
|
||||
// MakeCoverage generates an output file with coverage info in correct format.
|
||||
func (c *ContractInvoker) MakeCoverage(t testing.TB, ctrdi *ContractWithDebugInfo, ctrPath string, fileName string) {
|
||||
docs := getDocuments(t, ctrdi.DebugInfo.Documents, ctrPath)
|
||||
cov := getSeqPoints(t, ctrdi.DebugInfo, docs)
|
||||
for _, iMethod := range c.Methods {
|
||||
countInstructions(cov, iMethod.Instructions)
|
||||
func (c *ContractInvoker) MakeCoverage(t testing.TB, ctrdi *ContractWithDebugInfo, substr string, fileName string) {
|
||||
cover.Lock()
|
||||
defer cover.Unlock()
|
||||
if cover.Opcodes == nil {
|
||||
cover.Opcodes = make(map[string][]int)
|
||||
cover.Blocks = make(map[string][]testing.CoverBlock)
|
||||
cover.Counters = make(map[string][]uint32)
|
||||
}
|
||||
printToFile(t, cov, fileName)
|
||||
|
||||
docs := getDocuments(t, ctrdi.DebugInfo.Documents, substr)
|
||||
setBlocks(ctrdi.DebugInfo, docs)
|
||||
for _, iMethod := range c.Methods {
|
||||
countInstructions(ctrdi.DebugInfo.Documents, docs, iMethod.Instructions)
|
||||
}
|
||||
printToFile(t, fileName)
|
||||
}
|
||||
|
||||
// getDocuments returns compiler.DebugInfo.Documents indexes which contain specific substring.
|
||||
|
|
@ -50,28 +54,30 @@ func getDocuments(t testing.TB, docs []string, substr string) []int {
|
|||
return res
|
||||
}
|
||||
|
||||
// getSeqPoints accumulates sequence points from every method in compiler.DebugInfo.Methods which belong to specified documents.
|
||||
func getSeqPoints(t testing.TB, di *compiler.DebugInfo, docs []int) []coverline {
|
||||
res := make([]coverline, 0, 10)
|
||||
|
||||
// setBlocks extracts sequence points for every specific document
|
||||
// from compiler.DebugInfo and stores them in testing.Cover format
|
||||
func setBlocks(di *compiler.DebugInfo, docs []int) {
|
||||
for _, method := range di.Methods {
|
||||
maxLine := method.Range.End
|
||||
for _, seqPoint := range method.SeqPoints {
|
||||
if isValidDocument(seqPoint.Document, docs) && seqPoint.Opcode < int(maxLine) {
|
||||
res = append(res, coverline{
|
||||
Doc: di.Documents[seqPoint.Document],
|
||||
Opcode: seqPoint.Opcode,
|
||||
StartLine: seqPoint.StartLine,
|
||||
StartCol: seqPoint.StartCol,
|
||||
EndLine: seqPoint.EndLine,
|
||||
EndCol: seqPoint.EndCol,
|
||||
Statements: 1,
|
||||
IsCovered: false,
|
||||
statements := seqPoint.EndLine - seqPoint.StartLine + 1
|
||||
docStr := di.Documents[seqPoint.Document]
|
||||
if isValidDocument(seqPoint.Document, docs) {
|
||||
cover.Blocks[docStr] = append(cover.Blocks[docStr], testing.CoverBlock{
|
||||
Line0: uint32(seqPoint.StartLine),
|
||||
Col0: uint16(seqPoint.StartCol),
|
||||
Line1: uint32(seqPoint.EndLine),
|
||||
Col1: uint16(seqPoint.EndCol),
|
||||
Stmts: uint16(statements),
|
||||
})
|
||||
cover.Opcodes[docStr] = append(cover.Opcodes[docStr], seqPoint.Opcode)
|
||||
}
|
||||
}
|
||||
}
|
||||
return res
|
||||
for doc, seqPoints := range cover.Blocks {
|
||||
if hasNoCounters(doc) {
|
||||
cover.Counters[doc] = make([]uint32, len(seqPoints))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// isValidDocument checks if document index exists in an array of document indexes.
|
||||
|
|
@ -84,44 +90,96 @@ func isValidDocument(iDocToCheck int, docs []int) bool {
|
|||
return false
|
||||
}
|
||||
|
||||
func hasNoBlocks(doc string) bool {
|
||||
if _, exists := cover.Blocks[doc]; exists {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func hasNoCounters(doc string) bool {
|
||||
if _, exists := cover.Counters[doc]; exists {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// countInstructions finds for every instruction a corresponding sequence point and sets IsCovered flag to true.
|
||||
func countInstructions(cov []coverline, codes []InstrHash) {
|
||||
for i := range cov {
|
||||
for _, code := range codes {
|
||||
if code.Offset == cov[i].Opcode {
|
||||
cov[i].IsCovered = true
|
||||
}
|
||||
func countInstructions(diDocs []string, validDocs []int, instrs []InstrHash) {
|
||||
sValidDocs := getValidStrDocs(diDocs, validDocs)
|
||||
for doc, ops := range cover.Opcodes {
|
||||
if isValidStrDoc(doc, sValidDocs) {
|
||||
cover.Counters[doc] = getNewCounts(doc, ops, instrs)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// printToFile writes coverlines to file.
|
||||
func printToFile(t testing.TB, cov []coverline, name string) {
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
func getNewCounts(doc string, ops []int, instrs []InstrHash) []uint32 {
|
||||
counts := cover.Counters[doc]
|
||||
for _, instr := range instrs {
|
||||
for i, op := range ops {
|
||||
if instr.Offset == op {
|
||||
counts[i]++
|
||||
}
|
||||
}
|
||||
}
|
||||
return counts
|
||||
}
|
||||
|
||||
f, err := os.OpenFile(name, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
|
||||
func getValidStrDocs(diDocs []string, validDocs []int) []string {
|
||||
res := make([]string, len(validDocs))
|
||||
for i, iDoc := range validDocs {
|
||||
res[i] = diDocs[iDoc]
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func isValidStrDoc(docToCheck string, docs []string) bool {
|
||||
for _, doc := range docs {
|
||||
if doc == docToCheck {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// printToFile writes coverage info to file.
|
||||
func printToFile(t testing.TB, name string) {
|
||||
fileName := name
|
||||
if fileName == "" {
|
||||
// if no specific file name was provided, the output file
|
||||
// will have formatted timestamp with no spaces as its name
|
||||
fileName = fmt.Sprintf("%s.out", time.Now().Format(time.RFC3339Nano))
|
||||
}
|
||||
|
||||
f, err := os.OpenFile(fileName, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, 0600)
|
||||
require.NoError(t, err)
|
||||
|
||||
defer f.Close()
|
||||
|
||||
fi, err := os.Stat(name)
|
||||
require.NoError(t, err)
|
||||
firstToWrite := ""
|
||||
if fi.Size() == 0 {
|
||||
firstToWrite = "mode: set\n"
|
||||
}
|
||||
|
||||
_, err = f.WriteString(firstToWrite)
|
||||
_, err = f.WriteString("mode: set\n")
|
||||
require.NoError(t, err)
|
||||
|
||||
for _, info := range cov {
|
||||
covered := 0
|
||||
if info.IsCovered {
|
||||
covered++
|
||||
var count uint32
|
||||
for name, counts := range cover.Counters {
|
||||
blocks := cover.Blocks[name]
|
||||
for i := range counts {
|
||||
stmts := int64(blocks[i].Stmts)
|
||||
count = counts[i]
|
||||
|
||||
// mode: set
|
||||
if count != 0 {
|
||||
count = 1
|
||||
}
|
||||
if f != nil && stmts == 1 {
|
||||
_, err := fmt.Fprintf(f, "%s:%d.%d,%d.%d %d %d\n", name,
|
||||
blocks[i].Line0, blocks[i].Col0,
|
||||
blocks[i].Line1, blocks[i].Col1,
|
||||
stmts,
|
||||
count)
|
||||
require.NoError(t, err)
|
||||
}
|
||||
}
|
||||
line := fmt.Sprintf("%s:%d.%d,%d.%d %d %d\n", info.Doc, info.StartLine, info.StartCol, info.EndLine, info.EndCol, info.Statements, covered)
|
||||
_, err = f.WriteString(line)
|
||||
require.NoError(t, err)
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue