Subversion Repositories openrisc

// 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 types

import (

        "go/ast"

        "io/ioutil"

        "os/exec"

        "path/filepath"

        "runtime"

        "strings"

        "testing"

        "time"

)

var gcName, gcPath string // compiler name and path

func init() {

        // determine compiler

        switch runtime.GOARCH {

        case "386":

                gcName = "8g"

        case "amd64":

                gcName = "6g"

        case "arm":

                gcName = "5g"

        default:

                gcName = "unknown-GOARCH-compiler"

                gcPath = gcName

                return

        }

        gcPath = filepath.Join(runtime.GOROOT(), "/bin/tool/", gcName)

}

func compile(t *testing.T, dirname, filename string) {

        cmd := exec.Command(gcPath, filename)

        cmd.Dir = dirname

        out, err := cmd.CombinedOutput()

        if err != nil {

                t.Errorf("%s %s failed: %s", gcName, filename, err)

                return

        }

        t.Logf("%s", string(out))

}

// Use the same global imports map for all tests. The effect is

// as if all tested packages were imported into a single package.

var imports = make(map[string]*ast.Object)

func testPath(t *testing.T, path string) bool {

        _, err := GcImporter(imports, path)

        if err != nil {

                t.Errorf("testPath(%s): %s", path, err)

                return false

        }

        return true

}

const maxTime = 3 * time.Second

func testDir(t *testing.T, dir string, endTime time.Time) (nimports int) {

        dirname := filepath.Join(pkgRoot, dir)

        list, err := ioutil.ReadDir(dirname)

        if err != nil {

                t.Errorf("testDir(%s): %s", dirname, err)

        }

        for _, f := range list {

                if time.Now().After(endTime) {

                        t.Log("testing time used up")

                        return

                }

                switch {

                case !f.IsDir():

                        // try extensions

                        for _, ext := range pkgExts {

                                if strings.HasSuffix(f.Name(), ext) {

                                        name := f.Name()[0 : len(f.Name())-len(ext)] // remove extension

                                        if testPath(t, filepath.Join(dir, name)) {

                                                nimports++

                                        }

                                }

                        }

                case f.IsDir():

                        nimports += testDir(t, filepath.Join(dir, f.Name()), endTime)

                }

        }

        return

}

func TestGcImport(t *testing.T) {

        compile(t, "testdata", "exports.go")

        nimports := 0

        if testPath(t, "./testdata/exports") {

                nimports++

        }

        nimports += testDir(t, "", time.Now().Add(maxTime)) // installed packages

        t.Logf("tested %d imports", nimports)

}