Subversion Repositories openrisc

// Copyright 2012 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 doc

import (

        "bytes"

        "flag"

        "fmt"

        "go/parser"

        "go/printer"

        "go/token"

        "io/ioutil"

        "os"

        "path/filepath"

        "strings"

        "testing"

        "text/template"

)

var update = flag.Bool("update", false, "update golden (.out) files")

const dataDir = "testdata"

var templateTxt = readTemplate("template.txt")

func readTemplate(filename string) *template.Template {

        t := template.New(filename)

        t.Funcs(template.FuncMap{

                "node":     nodeFmt,

                "synopsis": synopsisFmt,

        })

        return template.Must(t.ParseFiles(filepath.Join(dataDir, filename)))

}

func nodeFmt(node interface{}, fset *token.FileSet) string {

        var buf bytes.Buffer

        printer.Fprint(&buf, fset, node)

        return strings.Replace(strings.TrimSpace(buf.String()), "\n", "\n\t", -1)

}

func synopsisFmt(s string) string {

        const n = 64

        if len(s) > n {

                // cut off excess text and go back to a word boundary

                s = s[0:n]

                if i := strings.LastIndexAny(s, "\t\n "); i >= 0 {

                        s = s[0:i]

                }

                s = strings.TrimSpace(s) + " ..."

        }

        return "// " + strings.Replace(s, "\n", " ", -1)

}

func isGoFile(fi os.FileInfo) bool {

        name := fi.Name()

        return !fi.IsDir() &&

                len(name) > 0 && name[0] != '.' && // ignore .files

                filepath.Ext(name) == ".go"

}

type bundle struct {

        *Package

        FSet *token.FileSet

}

func test(t *testing.T, mode Mode) {

        // get all packages

        fset := token.NewFileSet()

        pkgs, err := parser.ParseDir(fset, dataDir, isGoFile, parser.ParseComments)

        if err != nil {

                t.Fatal(err)

        }

        // test all packages

        for _, pkg := range pkgs {

                importpath := dataDir + "/" + pkg.Name

                doc := New(pkg, importpath, mode)

                // golden files always use / in filenames - canonicalize them

                for i, filename := range doc.Filenames {

                        doc.Filenames[i] = filepath.ToSlash(filename)

                }

                // print documentation

                var buf bytes.Buffer

                if err := templateTxt.Execute(&buf, bundle{doc, fset}); err != nil {

                        t.Error(err)

                        continue

                }

                got := buf.Bytes()

                // update golden file if necessary

                golden := filepath.Join(dataDir, fmt.Sprintf("%s.%d.golden", pkg.Name, mode))

                if *update {

                        err := ioutil.WriteFile(golden, got, 0644)

                        if err != nil {

                                t.Error(err)

                        }

                        continue

                }

                // get golden file

                want, err := ioutil.ReadFile(golden)

                if err != nil {

                        t.Error(err)

                        continue

                }

                // compare

                if bytes.Compare(got, want) != 0 {

                        t.Errorf("package %s\n\tgot:\n%s\n\twant:\n%s", pkg.Name, got, want)

                }

        }

}

func Test(t *testing.T) {

        test(t, 0)

        test(t, AllDecls)

        test(t, AllMethods)

}