Subversion Repositories openrisc

// $G $F.go && $L $F.$A && ./$A.out

// Copyright 2010 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 main

import (
        "fmt"
        "math"
        "runtime"
        "strings"
)

type ErrorTest struct {
        name string
        fn   func()
        err  string
}

var (
        i, j, k       int   = 0, 0, 1
        i8, j8, k8    int8  = 0, 0, 1
        i16, j16, k16 int16 = 0, 0, 1
        i32, j32, k32 int32 = 0, 0, 1
        i64, j64, k64 int64 = 0, 0, 1

        u, v, w       uint    = 0, 0, 1
        u8, v8, w8    uint8   = 0, 0, 1
        u16, v16, w16 uint16  = 0, 0, 1
        u32, v32, w32 uint32  = 0, 0, 1
        u64, v64, w64 uint64  = 0, 0, 1
        up, vp, wp    uintptr = 0, 0, 1

        f, g, h                         float64 = 0, 0, 1
        f32, g32, h32                   float32 = 0, 0, 1
        f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN()

        c, d, e          complex128 = 0 + 0i, 0 + 0i, 1 + 1i
        c64, d64, e64    complex64  = 0 + 0i, 0 + 0i, 1 + 1i
        c128, d128, e128 complex128 = 0 + 0i, 0 + 0i, 1 + 1i
)

// Fool gccgo into thinking that these variables can change.
func NotCalled() {
        i++
        j++
        k++
        i8++
        j8++
        k8++
        i16++
        j16++
        k16++
        i32++
        j32++
        k32++
        i64++
        j64++
        k64++

        u++
        v++
        w++
        u8++
        v8++
        w8++
        u16++
        v16++
        w16++
        u32++
        v32++
        w32++
        u64++
        v64++
        w64++
        up++
        vp++
        wp++

        f += 1
        g += 1
        h += 1
        f32 += 1
        g32 += 1
        h32 += 1
        f64 += 1
        g64 += 1
        h64 += 1

        c += 1 + 1i
        d += 1 + 1i
        e += 1 + 1i
        c64 += 1 + 1i
        d64 += 1 + 1i
        e64 += 1 + 1i
        c128 += 1 + 1i
        d128 += 1 + 1i
        e128 += 1 + 1i
}

var tmp interface{}

// We could assign to _ but the compiler optimizes it too easily.
func use(v interface{}) {
        tmp = v
}

// Verify error/no error for all types.
var errorTests = []ErrorTest{
        // All integer divide by zero should error.
        ErrorTest{"int 0/0", func() { use(i / j) }, "divide"},
        ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"},
        ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"},
        ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"},
        ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"},

        ErrorTest{"int 1/0", func() { use(k / j) }, "divide"},
        ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"},
        ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"},
        ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"},
        ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"},

        ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"},
        ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"},
        ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"},
        ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"},
        ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"},
        ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"},

        ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"},
        ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"},
        ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"},
        ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"},
        ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"},
        ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"},

        // All float64ing divide by zero should not error.
        ErrorTest{"float64 0/0", func() { use(f / g) }, ""},
        ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""},
        ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""},

        ErrorTest{"float64 1/0", func() { use(h / g) }, ""},
        ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""},
        ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""},
        ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""},
        ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""},
        ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""},

        // All complex divide by zero should not error.
        ErrorTest{"complex 0/0", func() { use(c / d) }, ""},
        ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""},
        ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""},

        ErrorTest{"complex 1/0", func() { use(e / d) }, ""},
        ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""},
        ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""},
}

func error_(fn func()) (error string) {
        defer func() {
                if e := recover(); e != nil {
                        error = e.(runtime.Error).Error()
                }
        }()
        fn()
        return ""
}

type FloatTest struct {
        f, g float64
        out  float64
}

var float64Tests = []FloatTest{
        FloatTest{0, 0, nan},
        FloatTest{nan, 0, nan},
        FloatTest{inf, 0, inf},
        FloatTest{negInf, 0, negInf},
}

func alike(a, b float64) bool {
        switch {
        case math.IsNaN(a) && math.IsNaN(b):
                return true
        case a == b:
                return math.Signbit(a) == math.Signbit(b)
        }
        return false
}

func main() {
        bad := false
        for _, t := range errorTests {
                if t.err != "" {
                        continue
                }
                err := error_(t.fn)
                switch {
                case t.err == "" && err == "":
                        // fine
                case t.err != "" && err == "":
                        if !bad {
                                bad = true
                                fmt.Printf("BUG\n")
                        }
                        fmt.Printf("%s: expected %q; got no error\n", t.name, t.err)
                case t.err == "" && err != "":
                        if !bad {
                                bad = true
                                fmt.Printf("BUG\n")
                        }
                        fmt.Printf("%s: expected no error; got %q\n", t.name, err)
                case t.err != "" && err != "":
                        if strings.Index(err, t.err) < 0 {
                                if !bad {
                                        bad = true
                                        fmt.Printf("BUG\n")
                                }
                                fmt.Printf("%s: expected %q; got %q\n", t.name, t.err, err)
                                continue
                        }
                }
        }

        // At this point we know we don't error on the values we're testing
        for _, t := range float64Tests {
                x := t.f / t.g
                if !alike(x, t.out) {
                        if !bad {
                                bad = true
                                fmt.Printf("BUG\n")
                        }
                        fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x)
                }
        }
}