code review 10264045: cmd/go: write coverage to file, add percentage statistic

src/cmd/go/test.go

 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package main
 
 import (
         "bytes"
         "fmt"
         "go/ast"
@@ skipping 115 matching lines @@
 
         -cover set,count,atomic
             TODO: This feature is not yet fully implemented.
             Set the mode for coverage analysis for the package[s] being tested.
             The default is to do none.
             The values:
                 set: boolean: does this statement execute?
                 count: integer: how many times does this statement execute?
                 atomic: integer: like count, but correct in multithreaded tests;
                         significantly more expensive.
-            Sets -v.
+            Sets -v. TODO: This will change.
 
         -coverprofile cover.out
             Write a coverage profile to the specified file after all tests
             have passed.
 
         -cpu 1,2,4
             Specify a list of GOMAXPROCS values for which the tests or
             benchmarks should be executed.  The default is the current value
             of GOMAXPROCS.
 
@@ skipping 383 matching lines @@
         ptestObj := buildToolchain.pkgpath(testDir, p)
 
         // Create the directory for the .a files.
         ptestDir, _ := filepath.Split(ptestObj)
         if err := b.mkdir(ptestDir); err != nil {
                 return nil, nil, nil, err
         }
 
         if testCover != "" {
                 p.coverMode = testCover
-                p.coverVars = declareCoverVars(p.GoFiles...)
+                p.coverVars = declareCoverVars(p.ImportPath, p.GoFiles...)
         }
 
         if err := writeTestmain(filepath.Join(testDir, "_testmain.go"), p, p.coverVars); err != nil {
                 return nil, nil, nil, err
         }
 
         // Test package.
         if len(p.TestGoFiles) > 0 || testCover != "" {
                 ptest = new(Package)
                 *ptest = *p
@@ skipping 123 matching lines @@
                 }
         }
 
         return pmainAction, runAction, printAction, nil
 }
 
 var coverIndex = 0
 
 // declareCoverVars attaches the required cover variables names
 // to the files, to be used when annotating the files.
-func declareCoverVars(files ...string) map[string]*CoverVar {
+func declareCoverVars(importPath string, files ...string) map[string]*CoverVar {
         coverVars := make(map[string]*CoverVar)
         for _, file := range files {
                 coverVars[file] = &CoverVar{
-                        File: file,
+                        File: filepath.Join(importPath, file),
                         Var:  fmt.Sprintf("GoCover_%d", coverIndex),
                 }
                 coverIndex++
         }
         return coverVars
 }
 
 // runTest is the action for running a test binary.
 func (b *builder) runTest(a *action) error {
         args := stringList(a.deps[0].target, testArgs)
@@ skipping 275 matching lines @@
 {{if .CoverEnabled}}
 
 // Only updated by init functions, so no need for atomicity.
 var (
         coverCounters = make(map[string][]uint32)
         coverBlocks = make(map[string][]testing.CoverBlock)
 )
 
 func init() {
         {{range $file, $cover := .CoverVars}}
-        coverRegisterFile({{printf "%q" $file}}, _test.{{$cover.Var}}.Count[:], _test.{{$cover.Var}}.Pos[:], _test.{{$cover.Var}}.NumStmt[:])
+        coverRegisterFile({{printf "%q" $cover.File}}, _test.{{$cover.Var}}.Count[:], _test.{{$cover.Var}}.Pos[:], _test.{{$cover.Var}}.NumStmt[:])
         {{end}}
 }
 
 func coverRegisterFile(fileName string, counter []uint32, pos []uint32, numStmts []uint16) {
         if 3*len(counter) != len(pos) || len(counter) != len(numStmts) {
                 panic("coverage: mismatched sizes")
         }
         if coverCounters[fileName] != nil {
                 panic("coverage: duplicate counter array for " + fileName)
         }
         coverCounters[fileName] = counter
         block := make([]testing.CoverBlock, len(counter))
         for i := range counter {
                 block[i] = testing.CoverBlock{
                         Line0: pos[3*i+0],
                         Col0: uint16(pos[3*i+2]),
                         Line1: pos[3*i+1],
                         Col1: uint16(pos[3*i+2]>>16),
                         Stmts: numStmts[i],
                 }
         }
         coverBlocks[fileName] = block
 }
 {{end}}
 
 func main() {
 {{if .CoverEnabled}}
-        testing.CoverRegister(coverCounters, coverBlocks)
+        testing.RegisterCover(coverCounters, coverBlocks)
 {{end}}
         testing.Main(matchString, tests, benchmarks, examples)
 }
 
 `))