Subversion Repositories openrisc

// Copyright 2009 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 printer

import (
        "bytes"
        "flag"
        "go/ast"
        "go/parser"
        "go/token"
        "io/ioutil"
        "path/filepath"
        "testing"
        "time"
)

const (
        dataDir  = "testdata"
        tabwidth = 8
)

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

var fset = token.NewFileSet()

func lineString(text []byte, i int) string {
        i0 := i
        for i < len(text) && text[i] != '\n' {
                i++
        }
        return string(text[i0:i])
}

type checkMode uint

const (
        export checkMode = 1 << iota
        rawFormat
)

func runcheck(t *testing.T, source, golden string, mode checkMode) {
        // parse source
        prog, err := parser.ParseFile(fset, source, nil, parser.ParseComments)
        if err != nil {
                t.Error(err)
                return
        }

        // filter exports if necessary
        if mode&export != 0 {
                ast.FileExports(prog) // ignore result
                prog.Comments = nil   // don't print comments that are not in AST
        }

        // determine printer configuration
        cfg := Config{Tabwidth: tabwidth}
        if mode&rawFormat != 0 {
                cfg.Mode |= RawFormat
        }

        // format source
        var buf bytes.Buffer
        if err := cfg.Fprint(&buf, fset, prog); err != nil {
                t.Error(err)
        }
        res := buf.Bytes()

        // update golden files if necessary
        if *update {
                if err := ioutil.WriteFile(golden, res, 0644); err != nil {
                        t.Error(err)
                }
                return
        }

        // get golden
        gld, err := ioutil.ReadFile(golden)
        if err != nil {
                t.Error(err)
                return
        }

        // compare lengths
        if len(res) != len(gld) {
                t.Errorf("len = %d, expected %d (= len(%s))", len(res), len(gld), golden)
        }

        // compare contents
        for i, line, offs := 0, 1, 0; i < len(res) && i < len(gld); i++ {
                ch := res[i]
                if ch != gld[i] {
                        t.Errorf("%s:%d:%d: %s", source, line, i-offs+1, lineString(res, offs))
                        t.Errorf("%s:%d:%d: %s", golden, line, i-offs+1, lineString(gld, offs))
                        t.Error()
                        return
                }
                if ch == '\n' {
                        line++
                        offs = i + 1
                }
        }
}

func check(t *testing.T, source, golden string, mode checkMode) {
        // start a timer to produce a time-out signal
        tc := make(chan int)
        go func() {
                time.Sleep(10 * time.Second) // plenty of a safety margin, even for very slow machines
                tc <- 0
        }()

        // run the test
        cc := make(chan int)
        go func() {
                runcheck(t, source, golden, mode)
                cc <- 0
        }()

        // wait for the first finisher
        select {
        case <-tc:
                // test running past time out
                t.Errorf("%s: running too slowly", source)
        case <-cc:
                // test finished within alloted time margin
        }
}

type entry struct {
        source, golden string
        mode           checkMode
}

// Use gotest -update to create/update the respective golden files.
var data = []entry{
        {"empty.input", "empty.golden", 0},
        {"comments.input", "comments.golden", 0},
        {"comments.input", "comments.x", export},
        {"linebreaks.input", "linebreaks.golden", 0},
        {"expressions.input", "expressions.golden", 0},
        {"expressions.input", "expressions.raw", rawFormat},
        {"declarations.input", "declarations.golden", 0},
        {"statements.input", "statements.golden", 0},
        {"slow.input", "slow.golden", 0},
}

func TestFiles(t *testing.T) {
        for i, e := range data {
                source := filepath.Join(dataDir, e.source)
                golden := filepath.Join(dataDir, e.golden)
                check(t, source, golden, e.mode)
                // TODO(gri) check that golden is idempotent
                //check(t, golden, golden, e.mode)
                if testing.Short() && i >= 3 {
                        break
                }
        }
}

// TestLineComments, using a simple test case, checks that consequtive line
// comments are properly terminated with a newline even if the AST position
// information is incorrect.
//
func TestLineComments(t *testing.T) {
        const src = `// comment 1
        // comment 2
        // comment 3
        package main
        `

        fset := token.NewFileSet()
        f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
        if err != nil {
                panic(err) // error in test
        }

        var buf bytes.Buffer
        fset = token.NewFileSet() // use the wrong file set
        Fprint(&buf, fset, f)

        nlines := 0
        for _, ch := range buf.Bytes() {
                if ch == '\n' {
                        nlines++
                }
        }

        const expected = 3
        if nlines < expected {
                t.Errorf("got %d, expected %d\n", nlines, expected)
                t.Errorf("result:\n%s", buf.Bytes())
        }
}

// Verify that the printer can be invoked during initialization.
func init() {
        const name = "foobar"
        var buf bytes.Buffer
        if err := Fprint(&buf, fset, &ast.Ident{Name: name}); err != nil {
                panic(err) // error in test
        }
        // in debug mode, the result contains additional information;
        // ignore it
        if s := buf.String(); !debug && s != name {
                panic("got " + s + ", want " + name)
        }
}

// Verify that the printer doesn't crash if the AST contains BadXXX nodes.
func TestBadNodes(t *testing.T) {
        const src = "package p\n("
        const res = "package p\nBadDecl\n"
        f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
        if err == nil {
                t.Error("expected illegal program") // error in test
        }
        var buf bytes.Buffer
        Fprint(&buf, fset, f)
        if buf.String() != res {
                t.Errorf("got %q, expected %q", buf.String(), res)
        }
}

// Print and parse f with 
func testComment(t *testing.T, f *ast.File, srclen int, comment *ast.Comment) {
        f.Comments[0].List[0] = comment
        var buf bytes.Buffer
        for offs := 0; offs <= srclen; offs++ {
                buf.Reset()
                // Printing f should result in a correct program no
                // matter what the (incorrect) comment position is.
                if err := Fprint(&buf, fset, f); err != nil {
                        t.Error(err)
                }
                if _, err := parser.ParseFile(fset, "", buf.Bytes(), 0); err != nil {
                        t.Fatalf("incorrect program for pos = %d:\n%s", comment.Slash, buf.String())
                }
                // Position information is just an offset.
                // Move comment one byte down in the source.
                comment.Slash++
        }
}

// Verify that the printer produces always produces a correct program
// even if the position information of comments introducing newlines
// is incorrect.
func TestBadComments(t *testing.T) {
        const src = `
// first comment - text and position changed by test
package p
import "fmt"
const pi = 3.14 // rough circle
var (
        x, y, z int = 1, 2, 3
        u, v float64
)
func fibo(n int) {
        if n < 2 {
                return n /* seed values */
        }
        return fibo(n-1) + fibo(n-2)
}
`

        f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
        if err != nil {
                t.Error(err) // error in test
        }

        comment := f.Comments[0].List[0]
        pos := comment.Pos()
        if fset.Position(pos).Offset != 1 {
                t.Error("expected offset 1") // error in test
        }

        testComment(t, f, len(src), &ast.Comment{pos, "//-style comment"})
        testComment(t, f, len(src), &ast.Comment{pos, "/*-style comment */"})
        testComment(t, f, len(src), &ast.Comment{pos, "/*-style \n comment */"})
        testComment(t, f, len(src), &ast.Comment{pos, "/*-style comment \n\n\n */"})
}