Add new tests to presubmit, fix errors

go/gitinfo/gitinfo.go

 // gitinfo enables querying info from a Git repository.
 package gitinfo
 
 import (
         "fmt"
         "os"
         "os/exec"
         "path"
         "regexp"
         "sort"
@@ skipping 157 matching lines @@
 //    commit b7988a21fdf23cc4ace6145a06ea824aa85db099
 //    Author: Joe Gregorio <jcgregorio@google.com>
 //    Date:   Tue Aug 5 16:19:48 2014 -0400
 //
 //        A description of the commit.
 //
 //    perf/go/skiaperf/perf.go
 //    perf/go/types/types.go
 //    perf/res/js/logic.js
 //
-func (g GitInfo) Log(begin, end string) (string, error) {
+func (g *GitInfo) Log(begin, end string) (string, error) {
         command := []string{"log", "--name-only"}
         hashrange := begin
         if end != "" {
                 hashrange += ".." + end
                 command = append(command, hashrange)
         } else {
                 command = append(command, "-n", "1", hashrange)
         }
         cmd := exec.Command("git", command...)
         cmd.Dir = g.dir
         b, err := cmd.Output()
         if err != nil {
                 return "", err
         }
         return string(b), nil
 }
 
 // FullHash gives the full commit hash for the given ref.
-func (g GitInfo) FullHash(ref string) (string, error) {
+func (g *GitInfo) FullHash(ref string) (string, error) {
         cmd := exec.Command("git", "rev-parse", ref)
         cmd.Dir = g.dir
         b, err := cmd.Output()
         if err != nil {
                 return "", err
         }
         return string(b), nil
 }
 
 // GetFile returns the contents of the given file at the given commit.
-func (g GitInfo) GetFile(fileName, commit string) (string, error) {
+func (g *GitInfo) GetFile(fileName, commit string) (string, error) {
         cmd := exec.Command("git", "show", commit+":"+fileName)
         cmd.Dir = g.dir
         b, err := cmd.Output()
         if err != nil {
                 return "", err
         }
         return string(b), nil
 }
 
 // InitalCommit returns the hash of the initial commit.
-func (g GitInfo) InitialCommit() (string, error) {
+func (g *GitInfo) InitialCommit() (string, error) {
         cmd := exec.Command("git", "rev-list", "--max-parents=0", "HEAD")
         cmd.Dir = g.dir
         b, err := cmd.Output()
         if err != nil {
                 return "", fmt.Errorf("Failed to determine initial commit: %v", err)
         }
         return strings.Trim(string(b), "\n"), nil
 }
 
 // GetBranches returns a slice of strings naming the branches in the repo.
-func (g GitInfo) GetBranches() ([]*GitBranch, error) {
+func (g *GitInfo) GetBranches() ([]*GitBranch, error) {
         return GetBranches(g.dir)
 }
 
 // ShortCommits stores a slice of ShortCommit struct.
 type ShortCommits struct {
         Commits []*ShortCommit
 }
 
 // ShortList returns a slice of ShortCommit for every commit in (begin, end].
 func (g *GitInfo) ShortList(begin, end string) (*ShortCommits, error) {
@@ skipping 128 matching lines @@
         }
         sort.Sort(gitHashSlice(gitHashes))
         hashes := make([]string, len(timestamps), len(timestamps))
         for i, h := range gitHashes {
                 hashes[i] = h.hash
         }
         return hashes, timestamps, nil
 }
 
 // SkpCommits returns the indices for all the commits that contain SKP updates.
-func (g GitInfo) SkpCommits(tile *types.Tile) ([]int, error) {
+func (g *GitInfo) SkpCommits(tile *types.Tile) ([]int, error) {
         // Executes a git log command that looks like:
         //
         //   git log --format=format:%H  32956400b4d8f33394e2cdef9b66e8369ba2a0f3..e7416bfc9858bde8fc6eb5f3bfc942bc3350953a SKP_VERSION
         //
         // The output should be a \n separated list of hashes that match.
         first, last := tile.CommitRange()
         cmd := exec.Command("git", "log", "--format=format:%H", first+".."+last, "SKP_VERSION")
         cmd.Dir = g.dir
         b, err := cmd.Output()
         if err != nil {
                 glog.Error(string(b))
                 return nil, err
         }
         hashes := strings.Split(string(b), "\n")
 
         ret := []int{}
         for i, c := range tile.Commits {
                 if c.CommitTime != 0 && util.In(c.Hash, hashes) {
                         ret = append(ret, i)
                 }
         }
         return ret, nil
 }
 
 // LastSkpCommit returns the time of the last change to the SKP_VERSION file.
-func (g GitInfo) LastSkpCommit() (time.Time, error) {
+func (g *GitInfo) LastSkpCommit() (time.Time, error) {
         // Executes a git log command that looks like:
         //
         // git log --format=format:%ct -n 1 SKP_VERSION
         //
         // The output should be a single unix timestamp.
         cmd := exec.Command("git", "log", "--format=format:%ct", "-n", "1", "SKP_VERSION")
         cmd.Dir = g.dir
         b, err := cmd.Output()
         if err != nil {
                 glog.Error("Failed to read git log: ", err)
@@ skipping 25 matching lines @@
         }
         return -1, -1, fmt.Errorf("Cannot find hash %s.\n", hash)
 }
 
 // NumCommits returns the number of commits in the repo.
 func (g *GitInfo) NumCommits() int {
         g.mutex.Lock()
         defer g.mutex.Unlock()
         return len(g.hashes)
 }