code review 5504080: cmd/go: two testing fixes

src/cmd/go/build.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"
         "container/heap"
         "errors"
@@ skipping 318 matching lines @@
                         // Have to use something other than .a for the suffix.
                         // It is easier on Windows if we use .exe, so use .exe everywhere.
                         // (This is the name of a temporary file.)
                         a.target = a.objdir + "a.out" + b.exe
                 }
         }
 
         return a
 }
 
+// actionList returns the list of actions in the dag rooted at root
+// as visited in a depth-first post-order traversal.
+func actionList(root *action) []*action {
+        seen := map[*action]bool{}
+        all := []*action{}
+        var walk func(*action)
+        walk = func(a *action) {
+                if seen[a] {
+                        return
+                }
+                seen[a] = true
+                for _, a1 := range a.deps {
+                        walk(a1)
+                }
+                all = append(all, a)
+        }
+        walk(root)
+        return all
+}
+
 // do runs the action graph rooted at root.
 func (b *builder) do(root *action) {
         // Build list of all actions, assigning depth-first post-order priority.
         // The original implementation here was a true queue
         // (using a channel) but it had the effect of getting
         // distracted by low-level leaf actions to the detriment
         // of completing higher-level actions.  The order of
         // work does not matter much to overall execution time,
         // but when running "go test std" it is nice to see each test
         // results as soon as possible.  The priorities assigned
         // ensure that, all else being equal, the execution prefers
         // to do what it would have done first in a simple depth-first
         // dependency order traversal.
-        all := map[*action]bool{}
-        priority := 0
-        var walk func(*action)
-        walk = func(a *action) {
-                if all[a] {
-                        return
-                }
-                all[a] = true
-                priority++
-                for _, a1 := range a.deps {
-                        walk(a1)
-                }
-                a.priority = priority
+        all := actionList(root)
+        for i, a := range all {
+                a.priority = i
         }
-        walk(root)
 
         b.readySema = make(chan bool, len(all))
         done := make(chan bool)
 
         // Initialize per-action execution state.
-        for a := range all {
+        for _, a := range all {
                 for _, a1 := range a.deps {
                         a1.triggers = append(a1.triggers, a)
                 }
                 a.pending = len(a.deps)
                 if a.pending == 0 {
                         b.ready.push(a)
                         b.readySema <- true
                 }
         }
 
@@ skipping 642 matching lines @@
         return x
 }
 
 func (q *actionQueue) push(a *action) {
         heap.Push(q, a)
 }
 
 func (q *actionQueue) pop() *action {
         return heap.Pop(q).(*action)
 }