Golang 反射 && 单元测试

一.反射

package reflecttest

import (
    "fmt"
    "reflect"
)

// 语法:const [name] [type] = [value]
// const 只能修饰int\float\string\bool作为常量
const ss string = "123"
const (
    a = iota // a是0,往后依次递增1
    b
    c
    d
)

/*
    反射：
        1.反射可以在运行时动态获取变量的各种信息，比如变量的类型(type),类别(kind)
        2.如果是结构体变量，还可以获取到结构体本身的信息（包括结构体的字段、方法）
        3.通过反射，可以修改变量的值，可以调用关联的方法
        4.使用反射，需要import("reflect")
        5.变量、interface{}、reflect.Value时可以相互转换的。
*/

func TestReflect(b interface{}) {
    // 1.将interface{}专成reflect.Value
    rVal := reflect.ValueOf(b)

    // 2.将reflect.Value转成interface{}
    iVal := rVal.Interface()

    // 3.获取kind常量
    fmt.Printf("kind=%v, type=%T\n", rVal.Kind(), rVal.Kind()) // reflect.Kind

    // 4.将interface{}专程原来的变量类型
    switch iVal.(type) {
    case int:
        fmt.Println("int")
        // 4.转reflect.Type
        reflect.ValueOf(iVal.(int)) // 返回的就是：reflect.Type
        rVal.Type()                 // 返回的就是：reflect.Type
        fmt.Printf("kind=%v\n", rVal.Type().Kind())
    default:
        fmt.Println("err type!")
    }

}

func TestStructReflect() {
    var ss string = "Tom"
    TestElem := func(b interface{}) {
        // 1.读取reflectValue
        rVal := reflect.ValueOf(b)
        // 2.Kind
        fmt.Println("Kind=", rVal.Kind())
        // 3.设置值.
        //   通过反射来修改变量,注意当使用SetXxx方法来设置时,需要通过对应的指针类型来完成,这样才能改变传入变量的值,同时需要使用到reflect.Value.Elem()方法
        //   因为rVal是指针,我们的目的是修改指针指向的内容.这里rVal.Elem()的作用是,将rVal包装成可修改指针指向内容值的reflect.Value返回
        rVal.Elem().SetString("123456789")
        // rVal.SetInt(1)
    }
    fmt.Println(&ss)
    TestElem(&ss)
    fmt.Println(&ss)
    fmt.Println(ss)
}

package reflecttest

import (
    "fmt"
    "reflect"
)

type Monster struct {
    Name  string  `json:"name"`
    Age   int     `json:"age"`
    Score float32 `json:"score"`
    Sex   string
}

/* 显示值 */
func (self *Monster) Print() {
    fmt.Println("-----start--------")
    fmt.Println(*self)
    fmt.Println("-----end--------")
}

/* 返回两个数的和  */
func (self *Monster) GetSum(a int, b int) int {
    return a + b
}

/* 赋值 */
func (self *Monster) SetValue(name string, age int, score float32, sex string) {
    self.Name = name
    self.Age = age
    self.Score = score
    self.Sex = sex
}

// 反射字段标签的用法
func TestStructFieldTag(b interface{}) {
    // 获取reflect.Type
    typ := reflect.TypeOf(b)
    typ1 := reflect.TypeOf(b)
    // 获取reflect.Value
    val := reflect.ValueOf(b)
    val1 := reflect.ValueOf(b)
    // 获取对应的类型
    kd := val.Kind()
    if kd == reflect.Ptr {
        val = val.Elem()
        kd = val.Kind()
        typ = val.Type()
    }
    // 如果不是结构体就退出
    if kd != reflect.Struct {
        fmt.Println("传入的值必须是struct类型.")
        return
    }

    // 获取该结构体有几个字段
    num := val.NumField()
    fmt.Printf("%v 结构体有%v个字段.\n", typ, num)
    // 获取每个字段的值,以及字段设定的标签
    for i := 0; i < num; i++ {
        fmt.Printf("字段%v,值=%v\n", typ.Field(i).Name, val.Field(i))
        // 注意:获取字段标签值,需要通过reflect.Type来获取
        tagVal := typ.Field(i).Tag.Get("json")
        if tagVal != "" {
            fmt.Printf("字段'%v',标签=%v\n", typ.Field(i).Name, tagVal)
        }
        if typ.Field(i).Name == "Name" {
            // 修改字段值
            val.Field(i).SetString("ReName")
        }
    }

    // 获取该结构体有多少个方法
    num = val.NumMethod()
    fmt.Printf("%v 结构体有%v个方法.\n", typ, num)
    num = typ1.NumMethod()
    fmt.Printf("%v 结构体有%v个方法.\n", typ1, num)

    // 调用结构体的方法,并传参数
    var params []reflect.Value
    // reflecttest.Monster 结构体有0个方法.
    params = append(params, reflect.ValueOf(1))
    // *reflecttest.Monster 结构体有3个方法.
    params = append(params, reflect.ValueOf(2))
    res := val1.MethodByName("GetSum").Call(params)
    // 调用结构体中的'GetSum()'=3 , 返回的类型是[]reflect.Value
    fmt.Printf("调用结构体中的'GetSum()'=%v , 返回的类型是%T\n", res[0], res)

}

// 函数适配器:给要执行的函数加日志
func TestReflectFunc(function, f1 interface{}) {

    funVal := reflect.ValueOf(function).Elem()
    funTyp := funVal.Type()

    packFunc := func(in []reflect.Value) (result []reflect.Value) {
        fmt.Println("---begin---")
        result = reflect.ValueOf(f1).Call(in)
        fmt.Println("---end---")
        return result
    }

    v := reflect.MakeFunc(funTyp, packFunc)
    funVal.Set(v)

}

func TestReflect1() {
    tfunc := func(a int, b int) int {
        return a + b
    }

    TestReflectFunc(&tfunc, tfunc)
    c := tfunc(1, 2)
    fmt.Println(c)

    obj := Monster{}
    obj.SetValue("Tom", 19, 102, "Man")
    TestStructFieldTag(&obj)
    fmt.Println(obj)
}

二.单元测试

package main

import (
    "testing"
)

func TestAddUpper(t *testing.T) {
    /*
        注意细节:
            1.测试文件名必须"_test.go"结尾.一般用测试单元文件的名加上后缀
            2.测试用例函数必须以Test开头,一般用"Test+被测试的函数名"
            3.Testddpper(t *testing.T) 的形参类型必须是"t *testing.T"
            4.一个测试用例文件中可以有多个测试用例函数
            5.运行测试用例指令
                go test      // 如果运行正确,无日志,错误时,会输出日志
                go test -v    // 运行正确错误,都输出日志
                go test [测试单元文件名main_test.go] [测试的原文件main.go]    // 测试指定的测试单元
                go test -v -test.run [具体测试的方法TestAddUpper]            // 测试具体单个方法
            6.当出现错误时,可以使用t.Fatalf 来格式化输出错误信息,并退出程序
            7.t.Logf方法可以输出相应的日志
            8.测试用例函数,并没有放在main函数中也执行了,这就是测试用例的方便之处
            9,PASS表示测试用例运行成功,FAIL表示测试用例运行失败

    */
    sum := TestUnit(10)
    if sum != 55 {
        t.Fatalf("TestUnit(10) 执行错误,期望值=%v,实际值=%v\n", 55, sum)
    }
    t.Logf("TestUnit(10) 执行正确")
}