package test

import (
	"git.sxidc.com/go-framework/baize/framework/core/tag/rule"
	"github.com/pkg/errors"
	"reflect"
	"testing"
	"time"
)

type RuleTagStruct struct {
	Ignore          string
	StringValue     string    `rule:"column:string_value"`
	IntValue        int       `rule:"column:int_value"`
	Int8Value       int8      `rule:"column:int8_value"`
	Int16Value      int16     `rule:"column:int16_value"`
	Int32Value      int32     `rule:"column:int32_value"`
	Int64Value      int64     `rule:"column:int64_value"`
	UintValue       uint      `rule:"column:uint_value"`
	Uint8Value      uint8     `rule:"column:uint8_value"`
	Uint16Value     uint16    `rule:"column:uint16_value"`
	Uint32Value     uint32    `rule:"column:uint32_value"`
	Uint64Value     uint64    `rule:"column:uint64_value"`
	Float32Value    float32   `rule:"column:float32_value"`
	Float64Value    float64   `rule:"column:float64_value"`
	TimeValue       time.Time `rule:"column:time_value"`
	BoolValue       bool      `rule:"column:bool_value"`
	TagStringValue  bool      `rule:"column:string_value;type:string"`
	TagIntValue     string    `rule:"column:int_value;type:number"`
	TagInt8Value    string    `rule:"column:int8_value;type:number"`
	TagInt16Value   string    `rule:"column:int16_value;type:number"`
	TagInt32Value   string    `rule:"column:int32_value;type:number"`
	TagInt64Value   string    `rule:"column:int64_value;type:number"`
	TagUintValue    string    `rule:"column:uint_value;type:number"`
	TagUint8Value   string    `rule:"column:uint8_value;type:number"`
	TagUint16Value  string    `rule:"column:uint16_value;type:number"`
	TagUint32Value  string    `rule:"column:uint32_value;type:number"`
	TagUint64Value  string    `rule:"column:uint64_value;type:number"`
	TagFloat32Value string    `rule:"column:float32_value;type:number"`
	TagFloat64Value string    `rule:"column:float64_value;type:number"`
	TagTimeValue    string    `rule:"column:time_value;type:time"`
	TagBoolValue    string    `rule:"column:bool_value;type:bool"`
}

func (s RuleTagStruct) checkFields(t *testing.T, fields []rule.Field) {
	if len(fields) != reflect.TypeOf(s).NumField()-1 {
		t.Fatalf("%+v\n", errors.Errorf("有字段没有被解析"))
	}

	for _, field := range fields {
		if field.FieldName == "Ignore" && field.Type != "" {
			t.Fatalf("%+v\n", errors.Errorf("忽略字段没有被忽略"))
		}

		switch field.FieldName {
		case "StringValue":
			if field.ColumnName != "string_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "string_value"))
			}

			if field.Type != "string" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "IntValue":
			if field.ColumnName != "int_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int8Value":
			if field.ColumnName != "int8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int16Value":
			if field.ColumnName != "int16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int32Value":
			if field.ColumnName != "int32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int64Value":
			if field.ColumnName != "int64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "UintValue":
			if field.ColumnName != "uint_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint8Value":
			if field.ColumnName != "uint8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint16Value":
			if field.ColumnName != "uint16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint32Value":
			if field.ColumnName != "uint32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint64Value":
			if field.ColumnName != "uint64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Float32Value":
			if field.ColumnName != "float32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Float64Value":
			if field.ColumnName != "float64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TimeValue":
			if field.ColumnName != "time_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "time" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "BoolValue":
			if field.ColumnName != "bool_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "bool" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagStringValue":
			if field.ColumnName != "string_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "string_value"))
			}

			if field.Type != "string" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagIntValue":
			if field.ColumnName != "int_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt8Value":
			if field.ColumnName != "int8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt16Value":
			if field.ColumnName != "int16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt32Value":
			if field.ColumnName != "int32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt64Value":
			if field.ColumnName != "int64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUintValue":
			if field.ColumnName != "uint_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint8Value":
			if field.ColumnName != "uint8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint16Value":
			if field.ColumnName != "uint16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint32Value":
			if field.ColumnName != "uint32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint64Value":
			if field.ColumnName != "uint64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagFloat32Value":
			if field.ColumnName != "float32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagFloat64Value":
			if field.ColumnName != "float64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagTimeValue":
			if field.ColumnName != "time_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "time" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagBoolValue":
			if field.ColumnName != "bool_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "bool" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		default:
			t.Fatalf("%+v\n", errors.Errorf("未知的字段名: tag fieldName: %v", field.FieldName))
		}
	}
}

type RuleTagPointerFieldsStruct struct {
	Ignore          *string
	StringValue     *string    `rule:"column:string_value"`
	IntValue        *int       `rule:"column:int_value"`
	Int8Value       *int8      `rule:"column:int8_value"`
	Int16Value      *int16     `rule:"column:int16_value"`
	Int32Value      *int32     `rule:"column:int32_value"`
	Int64Value      *int64     `rule:"column:int64_value"`
	UintValue       *uint      `rule:"column:uint_value"`
	Uint8Value      *uint8     `rule:"column:uint8_value"`
	Uint16Value     *uint16    `rule:"column:uint16_value"`
	Uint32Value     *uint32    `rule:"column:uint32_value"`
	Uint64Value     *uint64    `rule:"column:uint64_value"`
	Float32Value    *float32   `rule:"column:float32_value"`
	Float64Value    *float64   `rule:"column:float64_value"`
	TimeValue       *time.Time `rule:"column:time_value"`
	BoolValue       *bool      `rule:"column:bool_value"`
	TagStringValue  *bool      `rule:"column:string_value;type:string"`
	TagIntValue     *string    `rule:"column:int_value;type:number"`
	TagInt8Value    *string    `rule:"column:int8_value;type:number"`
	TagInt16Value   *string    `rule:"column:int16_value;type:number"`
	TagInt32Value   *string    `rule:"column:int32_value;type:number"`
	TagInt64Value   *string    `rule:"column:int64_value;type:number"`
	TagUintValue    *string    `rule:"column:uint_value;type:number"`
	TagUint8Value   *string    `rule:"column:uint8_value;type:number"`
	TagUint16Value  *string    `rule:"column:uint16_value;type:number"`
	TagUint32Value  *string    `rule:"column:uint32_value;type:number"`
	TagUint64Value  *string    `rule:"column:uint64_value;type:number"`
	TagFloat32Value *string    `rule:"column:float32_value;type:number"`
	TagFloat64Value *string    `rule:"column:float64_value;type:number"`
	TagTimeValue    *string    `rule:"column:time_value;type:time"`
	TagBoolValue    *string    `rule:"column:bool_value;type:bool"`
}

func (s RuleTagPointerFieldsStruct) checkFields(t *testing.T, fields []rule.Field) {
	if len(fields) != reflect.TypeOf(s).NumField()-1 {
		t.Fatalf("%+v\n", errors.Errorf("有字段没有被解析"))
	}

	for _, field := range fields {
		if field.FieldName == "Ignore" && field.Type != "" {
			t.Fatalf("%+v\n", errors.Errorf("忽略字段没有被忽略"))
		}

		switch field.FieldName {
		case "StringValue":
			if field.ColumnName != "string_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "string_value"))
			}

			if field.Type != "string" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "IntValue":
			if field.ColumnName != "int_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int8Value":
			if field.ColumnName != "int8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int16Value":
			if field.ColumnName != "int16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int32Value":
			if field.ColumnName != "int32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Int64Value":
			if field.ColumnName != "int64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "UintValue":
			if field.ColumnName != "uint_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint8Value":
			if field.ColumnName != "uint8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint16Value":
			if field.ColumnName != "uint16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint32Value":
			if field.ColumnName != "uint32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Uint64Value":
			if field.ColumnName != "uint64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Float32Value":
			if field.ColumnName != "float32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "Float64Value":
			if field.ColumnName != "float64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TimeValue":
			if field.ColumnName != "time_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "time" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "BoolValue":
			if field.ColumnName != "bool_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "bool" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagStringValue":
			if field.ColumnName != "string_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "string_value"))
			}

			if field.Type != "string" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagIntValue":
			if field.ColumnName != "int_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt8Value":
			if field.ColumnName != "int8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt16Value":
			if field.ColumnName != "int16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt32Value":
			if field.ColumnName != "int32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagInt64Value":
			if field.ColumnName != "int64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "int64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUintValue":
			if field.ColumnName != "uint_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint8Value":
			if field.ColumnName != "uint8_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint8_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint16Value":
			if field.ColumnName != "uint16_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint16_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint32Value":
			if field.ColumnName != "uint32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagUint64Value":
			if field.ColumnName != "uint64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "uint64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagFloat32Value":
			if field.ColumnName != "float32_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float32_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagFloat64Value":
			if field.ColumnName != "float64_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "number" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagTimeValue":
			if field.ColumnName != "time_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "time" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		case "TagBoolValue":
			if field.ColumnName != "bool_value" {
				t.Fatalf("%+v\n", errors.Errorf("列名解析测试错误: fieldName: %v, actual column: %v",
					field.ColumnName, "float64_value"))
			}

			if field.Type != "bool" {
				t.Fatalf("%+v\n", errors.Errorf("类型解析测试错误: fieldName: %v, actual type: %v",
					field.FieldName, field.Type))
			}
		default:
			t.Fatalf("%+v\n", errors.Errorf("未知的字段名: tag fieldName: %v", field.FieldName))
		}
	}
}

func TestRuleTagDefaultUsage(t *testing.T) {
	s := RuleTagStruct{}

	sPointerFields := RuleTagPointerFieldsStruct{}

	sPointerFieldsNil := RuleTagPointerFieldsStruct{}

	fields, err := rule.DefaultUsage(s)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	s.checkFields(t, fields)

	fields, err = rule.DefaultUsage(&s)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	s.checkFields(t, fields)

	fields, err = rule.DefaultUsage(sPointerFields)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	sPointerFields.checkFields(t, fields)

	fields, err = rule.DefaultUsage(&sPointerFields)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	sPointerFields.checkFields(t, fields)

	fields, err = rule.DefaultUsage(sPointerFieldsNil)
	if err != nil {
		t.Fatalf("%+v\n", errors.Errorf("字段为nil"))
	}

	fields, err = rule.DefaultUsage(&sPointerFieldsNil)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	sPointerFieldsNil.checkFields(t, fields)
}