code review 7071050: testing: in example, empty output not distinguished fro...

src/pkg/go/doc/example.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.
 
 // Extract example functions from file ASTs.
 
 package doc
 
 import (
         "go/ast"
@@ skipping 38 matching lines @@
                                 hasTests = true
                                 continue
                         }
                         if !isTest(name, "Example") {
                                 continue
                         }
                         var doc string
                         if f.Doc != nil {
                                 doc = f.Doc.Text()
                         }
-                        output, emptyOutput := exampleOutput(f.Body, file.Comments)

[adg, 2013/01/11 03:10:37]

output, hasOutput := exampleOutput...

[ryanslade, 2013/01/11 12:10:31]

Done.

+                        output, hasOutput := exampleOutput(f.Body, file.Comments)
                         flist = append(flist, &Example{
                                 Name:        name[len("Example"):],
                                 Doc:         doc,
                                 Code:        f.Body,
                                 Play:        playExample(file, f.Body),
                                 Comments:    file.Comments,
                                 Output:      output,
-                                EmptyOutput: emptyOutput,

[adg, 2013/01/11 03:10:37]

output == "" && hasOutput

[ryanslade, 2013/01/11 12:10:31]

Done.

+                                EmptyOutput: output == "" && hasOutput,
                         })
                 }
                 if !hasTests && numDecl > 1 && len(flist) == 1 {
                         // If this file only has one example function, some
                         // other top-level declarations, and no tests or
                         // benchmarks, use the whole file as the example.
                         flist[0].Code = file
                         flist[0].Play = playExampleFile(file)
                 }
                 list = append(list, flist...)
         }
         sort.Sort(exampleByName(list))
         return list
 }
 
 var outputPrefix = regexp.MustCompile(`(?i)^[[:space:]]*output:`)
 
-// Extracts the expected output along with a bool indicating whether we expect it to be empty
-func exampleOutput(b *ast.BlockStmt, comments []*ast.CommentGroup) (string, bool) {

[adg, 2013/01/11 03:10:37]

the return values should be (output string, ok bool) 

and the meaning of the bool should be the opposite of what you have here; true
means that a comment was found, false means one was not

[ryanslade, 2013/01/11 12:10:31]

Done.

+// Extracts the expected output and whether there was a valid output comment
+func exampleOutput(b *ast.BlockStmt, comments []*ast.CommentGroup) (output string, ok bool) {
         if _, last := lastComment(b, comments); last != nil {
                 // test that it begins with the correct prefix
                 text := last.Text()
                 if loc := outputPrefix.FindStringIndex(text); loc != nil {
                         text = text[loc[1]:]
                         // Strip zero or more spaces followed by \n or a single space.
                         text = strings.TrimLeft(text, " ")
                         if len(text) > 0 && text[0] == '\n' {
                                 text = text[1:]
                         }
-                        return text, false
-                }
-        }
-        return "", true // no suitable comment found
+                        return text, true
+                }
+        }
+        return "", false // no suitable comment found
 }
 
 // isTest tells whether name looks like a test, example, or benchmark.
 // It is a Test (say) if there is a character after Test that is not a
 // lower-case letter. (We don't want Testiness.)
 func isTest(name, prefix string) bool {
         if !strings.HasPrefix(name, prefix) {
                 return false
         }
         if len(name) == len(prefix) { // "Test" is ok
@@ skipping 212 matching lines @@
                 if cg.Pos() < pos {
                         continue
                 }
                 if cg.End() > end {
                         break
                 }
                 i, last = j, cg
         }
         return
 }