libgo/go/go/printer/printer_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package printer
   6
   7 import (
   8         "bytes"
   9         "flag"
  10         "io/ioutil"
  11         "go/ast"
  12         "go/parser"
  13         "path"
  14         "testing"
  15 )
  16
  17
  18 const (
  19         dataDir  = "testdata"
  20         tabwidth = 8
  21 )
  22
  23
  24 var update = flag.Bool("update", false, "update golden files")
  25
  26
  27 func lineString(text []byte, i int) string {
  28         i0 := i
  29         for i < len(text) && text[i] != '\n' {
  30                 i++
  31         }
  32         return string(text[i0:i])
  33 }
  34
  35
  36 type checkMode uint
  37
  38 const (
  39         export checkMode = 1 << iota
  40         rawFormat
  41 )
  42
  43
  44 func check(t *testing.T, source, golden string, mode checkMode) {
  45         // parse source
  46         prog, err := parser.ParseFile(source, nil, parser.ParseComments)
  47         if err != nil {
  48                 t.Error(err)
  49                 return
  50         }
  51
  52         // filter exports if necessary
  53         if mode&export != 0 {
  54                 ast.FileExports(prog) // ignore result
  55                 prog.Comments = nil   // don't print comments that are not in AST
  56         }
  57
  58         // determine printer configuration
  59         cfg := Config{Tabwidth: tabwidth}
  60         if mode&rawFormat != 0 {
  61                 cfg.Mode |= RawFormat
  62         }
  63
  64         // format source
  65         var buf bytes.Buffer
  66         if _, err := cfg.Fprint(&buf, prog); err != nil {
  67                 t.Error(err)
  68         }
  69         res := buf.Bytes()
  70
  71         // update golden files if necessary
  72         if *update {
  73                 if err := ioutil.WriteFile(golden, res, 0644); err != nil {
  74                         t.Error(err)
  75                 }
  76                 return
  77         }
  78
  79         // get golden
  80         gld, err := ioutil.ReadFile(golden)
  81         if err != nil {
  82                 t.Error(err)
  83                 return
  84         }
  85
  86         // compare lengths
  87         if len(res) != len(gld) {
  88                 t.Errorf("len = %d, expected %d (= len(%s))", len(res), len(gld), golden)
  89         }
  90
  91         // compare contents
  92         for i, line, offs := 0, 1, 0; i < len(res) && i < len(gld); i++ {
  93                 ch := res[i]
  94                 if ch != gld[i] {
  95                         t.Errorf("%s:%d:%d: %s", source, line, i-offs+1, lineString(res, offs))
  96                         t.Errorf("%s:%d:%d: %s", golden, line, i-offs+1, lineString(gld, offs))
  97                         t.Error()
  98                         return
  99                 }
 100                 if ch == '\n' {
 101                         line++
 102                         offs = i + 1
 103                 }
 104         }
 105 }
 106
 107
 108 type entry struct {
 109         source, golden string
 110         mode           checkMode
 111 }
 112
 113 // Use gotest -update to create/update the respective golden files.
 114 var data = []entry{
 115         {"empty.input", "empty.golden", 0},
 116         {"comments.input", "comments.golden", 0},
 117         {"comments.input", "comments.x", export},
 118         {"linebreaks.input", "linebreaks.golden", 0},
 119         {"expressions.input", "expressions.golden", 0},
 120         {"expressions.input", "expressions.raw", rawFormat},
 121         {"declarations.input", "declarations.golden", 0},
 122         {"statements.input", "statements.golden", 0},
 123 }
 124
 125
 126 func Test(t *testing.T) {
 127         for _, e := range data {
 128                 source := path.Join(dataDir, e.source)
 129                 golden := path.Join(dataDir, e.golden)
 130                 check(t, source, golden, e.mode)
 131                 // TODO(gri) check that golden is idempotent
 132                 //check(t, golden, golden, e.mode);
 133         }
 134 }