Subversion Repositories openrisc

package main

import (

        p0 "./bug0"

        p1 "./bug1"

        "reflect"

        "strings"

)

var v0 p0.T

var v1 p1.T

type I0 interface {

        M(p0.T)

}

type I1 interface {

        M(p1.T)

}

type t0 int

func (t0) M(p0.T) {}

type t1 float64

func (t1) M(p1.T) {}

var i0 I0 = t0(0) // ok

var i1 I1 = t1(0) // ok

var p0i p0.I = t0(0) // ok

var p1i p1.I = t1(0) // ok

func main() {

        // check that reflect paths are correct,

        // meaning that reflect data for v0, v1 didn't get confused.

        // path is full (rooted) path name.  check suffix for gc, prefix for gccgo

        if s := reflect.TypeOf(v0).PkgPath(); !strings.HasSuffix(s, "/bug0") && !strings.HasPrefix(s, "bug0") {

                println("bad v0 path", len(s), s)

                panic("fail")

        }

        if s := reflect.TypeOf(v1).PkgPath(); !strings.HasSuffix(s, "/bug1") && !strings.HasPrefix(s, "bug1") {

                println("bad v1 path", s)

                panic("fail")

        }

        // check that dynamic interface check doesn't get confused

        var i interface{} = t0(0)

        if _, ok := i.(I1); ok {

                println("used t0 as i1")

                panic("fail")

        }

        if _, ok := i.(p1.I); ok {

                println("used t0 as p1.I")

                panic("fail")

        }

        i = t1(1)

        if _, ok := i.(I0); ok {

                println("used t1 as i0")

                panic("fail")

        }

        if _, ok := i.(p0.I); ok {

                println("used t1 as p0.I")

                panic("fail")

        }

        // check that type switch works.

        // the worry is that if p0.T and p1.T have the same hash,

        // the binary search will handle one of them incorrectly.

        for j := 0; j < 3; j++ {

                switch j {

                case 0:

                        i = p0.T{}

                case 1:

                        i = p1.T{}

                case 2:

                        i = 3.14

                }

                switch i.(type) {

                case p0.T:

                        if j != 0 {

                                println("type switch p0.T")

                                panic("fail")

                        }

                case p1.T:

                        if j != 1 {

                                println("type switch p1.T")

                                panic("fail")

                        }

                default:

                        if j != 2 {

                                println("type switch default", j)

                                panic("fail")

                        }

                }

        }

}