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 gob

import (

        "reflect"

        "testing"

)

type typeT struct {

        id  typeId

        str string

}

var basicTypes = []typeT{

        {tBool, "bool"},

        {tInt, "int"},

        {tUint, "uint"},

        {tFloat, "float"},

        {tBytes, "bytes"},

        {tString, "string"},

}

func getTypeUnlocked(name string, rt reflect.Type) gobType {

        typeLock.Lock()

        defer typeLock.Unlock()

        t, err := getBaseType(name, rt)

        if err != nil {

                panic("getTypeUnlocked: " + err.Error())

        }

        return t

}

// Sanity checks

func TestBasic(t *testing.T) {

        for _, tt := range basicTypes {

                if tt.id.string() != tt.str {

                        t.Errorf("checkType: expected %q got %s", tt.str, tt.id.string())

                }

                if tt.id == 0 {

                        t.Errorf("id for %q is zero", tt.str)

                }

        }

}

// Reregister some basic types to check registration is idempotent.

func TestReregistration(t *testing.T) {

        newtyp := getTypeUnlocked("int", reflect.TypeOf(int(0)))

        if newtyp != tInt.gobType() {

                t.Errorf("reregistration of %s got new type", newtyp.string())

        }

        newtyp = getTypeUnlocked("uint", reflect.TypeOf(uint(0)))

        if newtyp != tUint.gobType() {

                t.Errorf("reregistration of %s got new type", newtyp.string())

        }

        newtyp = getTypeUnlocked("string", reflect.TypeOf("hello"))

        if newtyp != tString.gobType() {

                t.Errorf("reregistration of %s got new type", newtyp.string())

        }

}

func TestArrayType(t *testing.T) {

        var a3 [3]int

        a3int := getTypeUnlocked("foo", reflect.TypeOf(a3))

        newa3int := getTypeUnlocked("bar", reflect.TypeOf(a3))

        if a3int != newa3int {

                t.Errorf("second registration of [3]int creates new type")

        }

        var a4 [4]int

        a4int := getTypeUnlocked("goo", reflect.TypeOf(a4))

        if a3int == a4int {

                t.Errorf("registration of [3]int creates same type as [4]int")

        }

        var b3 [3]bool

        a3bool := getTypeUnlocked("", reflect.TypeOf(b3))

        if a3int == a3bool {

                t.Errorf("registration of [3]bool creates same type as [3]int")

        }

        str := a3bool.string()

        expected := "[3]bool"

        if str != expected {

                t.Errorf("array printed as %q; expected %q", str, expected)

        }

}

func TestSliceType(t *testing.T) {

        var s []int

        sint := getTypeUnlocked("slice", reflect.TypeOf(s))

        var news []int

        newsint := getTypeUnlocked("slice1", reflect.TypeOf(news))

        if sint != newsint {

                t.Errorf("second registration of []int creates new type")

        }

        var b []bool

        sbool := getTypeUnlocked("", reflect.TypeOf(b))

        if sbool == sint {

                t.Errorf("registration of []bool creates same type as []int")

        }

        str := sbool.string()

        expected := "[]bool"

        if str != expected {

                t.Errorf("slice printed as %q; expected %q", str, expected)

        }

}

func TestMapType(t *testing.T) {

        var m map[string]int

        mapStringInt := getTypeUnlocked("map", reflect.TypeOf(m))

        var newm map[string]int

        newMapStringInt := getTypeUnlocked("map1", reflect.TypeOf(newm))

        if mapStringInt != newMapStringInt {

                t.Errorf("second registration of map[string]int creates new type")

        }

        var b map[string]bool

        mapStringBool := getTypeUnlocked("", reflect.TypeOf(b))

        if mapStringBool == mapStringInt {

                t.Errorf("registration of map[string]bool creates same type as map[string]int")

        }

        str := mapStringBool.string()

        expected := "map[string]bool"

        if str != expected {

                t.Errorf("map printed as %q; expected %q", str, expected)

        }

}

type Bar struct {

        X string

}

// This structure has pointers and refers to itself, making it a good test case.

type Foo struct {

        A int

        B int32 // will become int

        C string

        D []byte

        E *float64    // will become float64

        F ****float64 // will become float64

        G *Bar

        H *Bar // should not interpolate the definition of Bar again

        I *Foo // will not explode

}

func TestStructType(t *testing.T) {

        sstruct := getTypeUnlocked("Foo", reflect.TypeOf(Foo{}))

        str := sstruct.string()

        // If we can print it correctly, we built it correctly.

        expected := "Foo = struct { A int; B int; C string; D bytes; E float; F float; G Bar = struct { X string; }; H Bar; I Foo; }"

        if str != expected {

                t.Errorf("struct printed as %q; expected %q", str, expected)

        }

}

// Should be OK to register the same type multiple times, as long as they're

// at the same level of indirection.

func TestRegistration(t *testing.T) {

        type T struct{ a int }

        Register(new(T))

        Register(new(T))

}