package typeUtil

import (
	"reflect"
	"testing"
	"time"
)

func TestInt(t *testing.T) {
	var val interface{}
	expected := int(100)

	// Test with value == nil
	got, err := Int(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Int(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Int(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Int(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Int(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Int(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Int(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Int(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Int(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Int(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Int(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Int(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Int(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Int(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Int(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Int(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestIntArray(t *testing.T) {
	got, err := IntArray(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []int{1, 2}

	got, err = IntArray(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestInt8(t *testing.T) {
	var val interface{}
	expected := int8(100)

	// Test with value == nil
	got, err := Int8(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Int8(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Int8(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Int8(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Int8(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Int8(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Int8(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Int8(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Int8(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Int8(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Int8(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Int8(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Int8(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Int8(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Int8(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Int8(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestInt8Array(t *testing.T) {
	got, err := Int8Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []int8{1, 2}

	got, err = Int8Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestInt16(t *testing.T) {
	var val interface{}
	expected := int16(100)

	// Test with value == nil
	got, err := Int16(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Int16(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Int16(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Int16(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Int16(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Int16(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Int16(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Int16(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Int16(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Int16(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Int16(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Int16(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Int16(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Int16(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Int16(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Int16(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestInt16Array(t *testing.T) {
	got, err := Int16Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []int16{1, 2}

	got, err = Int16Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestInt32(t *testing.T) {
	var val interface{}
	expected := int32(100)

	// Test with value == nil
	got, err := Int32(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Int32(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Int32(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Int32(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Int32(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Int32(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Int32(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Int32(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Int32(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Int32(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Int32(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Int32(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Int32(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Int32(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Int32(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Int32(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestInt32Array(t *testing.T) {
	got, err := Int32Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []int32{1, 2}

	got, err = Int32Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestInt64(t *testing.T) {
	var val interface{}
	expected := int64(5630344025715245057)

	// Test with value == nil
	got, err := Int64(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int64 type
	val_int64 := int64(5630344025715245057)
	got, err = Int64(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(5630344025715245057)
	got, err = Int64(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(5630344025715245057)
	got, err = Int64(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "5630344025715245057"
	got, err = Int64(val_string1)
	if err != nil {
		t.Errorf("There should be an error, but now there isn't: %v", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	val_string2 := "5630344025715245057"
	got, err = Int64(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestInt64Array(t *testing.T) {
	got, err := Int64Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []int64{1, 2}

	got, err = Int64Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestUint(t *testing.T) {
	var val interface{}
	expected := uint(100)

	// Test with value == nil
	got, err := Uint(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Uint(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Uint(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Uint(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Uint(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Uint(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Uint(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Uint(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Uint(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Uint(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Uint(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Uint(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Uint(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Uint(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Uint(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Uint(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestUintArray(t *testing.T) {
	got, err := UintArray(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []uint{1, 2}

	got, err = UintArray(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestUint8(t *testing.T) {
	var val interface{}
	expected := uint8(100)

	// Test with value == nil
	got, err := Uint8(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Uint8(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Uint8(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Uint8(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Uint8(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Uint8(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Uint8(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Uint8(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Uint8(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Uint8(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Uint8(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Uint8(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Uint8(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Uint8(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Uint8(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Uint8(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestUint8Array(t *testing.T) {
	got, err := Uint8Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []uint8{1, 2}

	got, err = Uint8Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestByte(t *testing.T) {
	var val interface{}
	expected := byte(100)

	// Test with value == nil
	got, err := Byte(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Byte(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Byte(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Byte(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Byte(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Byte(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Byte(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Byte(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Byte(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Byte(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Byte(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Byte(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Byte(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Byte(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Byte(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Byte(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestByteArray(t *testing.T) {
	got, err := ByteArray(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []byte{1, 2}

	got, err = ByteArray(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestUint16(t *testing.T) {
	var val interface{}
	expected := uint16(100)

	// Test with value == nil
	got, err := Uint16(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Uint16(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Uint16(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Uint16(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Uint16(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Uint16(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Uint16(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Uint16(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Uint16(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Uint16(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Uint16(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Uint16(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Uint16(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Uint16(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Uint16(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Uint16(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestUint16Array(t *testing.T) {
	got, err := Uint16Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []uint16{1, 2}

	got, err = Uint16Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestUint32(t *testing.T) {
	var val interface{}
	expected := uint32(100)

	// Test with value == nil
	got, err := Uint32(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Uint32(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Uint32(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Uint32(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Uint32(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Uint32(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Uint32(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Uint32(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Uint32(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Uint32(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Uint32(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Uint32(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Uint32(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Uint32(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Uint32(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Uint32(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestUint32Array(t *testing.T) {
	got, err := Uint32Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []uint32{1, 2}

	got, err = Uint32Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestUint64(t *testing.T) {
	var val interface{}
	expected := uint64(100)

	// Test with value == nil
	got, err := Uint64(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Uint64(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Uint64(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Uint64(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Uint64(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Uint64(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Uint64(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Uint64(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Uint64(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Uint64(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Uint64(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Uint64(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Uint64(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Uint64(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Uint64(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Uint64(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %d, but got %d", expected, got)
		return
	}
}

func TestUint64Array(t *testing.T) {
	got, err := Uint64Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []uint64{1, 2}

	got, err = Uint64Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestFloat32(t *testing.T) {
	var val interface{}
	expected := float32(100.0)

	// Test with value == nil
	got, err := Float32(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Float32(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Float32(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Float32(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Float32(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Float32(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Float32(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Float32(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Float32(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Float32(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Float32(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Float32(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Float32(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Float32(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Float32(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Float32(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}
}

func TestFloat32Array(t *testing.T) {
	got, err := Float32Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []float32{1.0, 2.0}

	got, err = Float32Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestFloat64(t *testing.T) {
	var val interface{}
	expected := float64(100.0)

	// Test with value == nil
	got, err := Float64(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Float64(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Float64(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Float64(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Float64(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Float64(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Float64(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Float64(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Float64(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Float64(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Float64(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Float64(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Float64(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Float64(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Float64(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Float64(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %f, but got %f", expected, got)
		return
	}
}

func TestFloat64Array(t *testing.T) {
	got, err := Float64Array(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []float64{1.0, 2.0}

	got, err = Float64Array(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestBool(t *testing.T) {
	var val interface{}
	expected := true

	// Test with value == nil
	got, err := Bool(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = Bool(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = Bool(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = Bool(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = Bool(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = Bool(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = Bool(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = Bool(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = Bool(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = Bool(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = Bool(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = Bool(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100.0)
	got, err = Bool(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100.0)
	got, err = Bool(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as string type
	val_string1 := "abc"
	got, err = Bool(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 := "100"
	got, err = Bool(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with false result
	expected = false

	// Test with value as int type
	val_int = int(0)
	got, err = Bool(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 = int8(0)
	got, err = Bool(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 = int16(0)
	got, err = Bool(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 = int32(0)
	got, err = Bool(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 = int64(0)
	got, err = Bool(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint type
	val_uint = uint(0)
	got, err = Bool(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 = uint8(0)
	got, err = Bool(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 = uint16(0)
	got, err = Bool(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 = uint32(0)
	got, err = Bool(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 = uint64(0)
	got, err = Bool(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 = float32(0.0)
	got, err = Bool(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 = float64(0.0)
	got, err = Bool(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}

	// Test with value as string type
	val_string1 = "abc"
	got, err = Bool(val_string1)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't")
		return
	}

	val_string2 = "0"
	got, err = Bool(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %t, but got %t", expected, got)
		return
	}
}

func TestBoolArray(t *testing.T) {
	got, err := BoolArray(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 0)
	expected := []bool{true, false}

	got, err = BoolArray(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestString(t *testing.T) {
	var val interface{}
	expected := "100"

	// Test with value == nil
	got, err := String(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	got, err = String(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as int type
	val_int := int(100)
	got, err = String(val_int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as int8 type
	val_int8 := int8(100)
	got, err = String(val_int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as int16 type
	val_int16 := int16(100)
	got, err = String(val_int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as int32 type
	val_int32 := int32(100)
	got, err = String(val_int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as int64 type
	val_int64 := int64(100)
	got, err = String(val_int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as uint type
	val_uint := uint(100)
	got, err = String(val_uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as uint8 type
	val_uint8 := uint8(100)
	got, err = String(val_uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as uint16 type
	val_uint16 := uint16(100)
	got, err = String(val_uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as uint32 type
	val_uint32 := uint32(100)
	got, err = String(val_uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as uint64 type
	val_uint64 := uint64(100)
	got, err = String(val_uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as float32 type
	val_float32 := float32(100)
	got, err = String(val_float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as float64 type
	val_float64 := float64(100)
	got, err = String(val_float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}

	// Test with value as string type
	val_string2 := "100"
	got, err = String(val_string2)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %s, but got %s", expected, got)
		return
	}
}

func TestStringArray(t *testing.T) {
	got, err := StringArray(nil)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	valArray := make([]interface{}, 0, 2)
	valArray = append(valArray, 1)
	valArray = append(valArray, 2)
	expected := []string{"1", "2"}

	got, err = StringArray(valArray)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}

	if len(expected) != len(got) || expected[0] != got[0] || expected[1] != got[1] {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestDateTime(t *testing.T) {
	var val interface{}
	expected := time.Date(2017, time.February, 14, 5, 20, 0, 0, time.Local)

	// Test with value == nil
	_, err := DateTime(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test with value as non basic type
	val = make([]int, 0, 32)
	_, err = DateTime(val)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	timeVal := "2017-02-14 05:20:00"
	got, err := DateTime(timeVal)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}

	got, err = DateTime(got)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}

	got, err = DateTime(got.Unix())
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got != expected {
		t.Errorf("Expected %v, but got %v", expected, got)
		return
	}
}

func TestDateTimeArray(t *testing.T) {

}

func TestDateTimeByFormat(t *testing.T) {
	// var val interface{}
	// expected := time.Date(2017, time.February, 14, 5, 20, 0, 0, time.Local)

	// // Test with value == nil
	// _, err := DateTimeByFormat(val, "2006-01-02 15:04:05")
	// if err == nil {
	// 	t.Errorf("There should be an error, but now there isn't.")
	// 	return
	// }

	// // Test with value as non basic type
	// val = make([]int, 0, 32)
	// _, err = DateTimeByFormat(val, "2006-01-02 15:04:05")
	// if err == nil {
	// 	t.Errorf("There should be an error, but now there isn't.")
	// 	return
	// }

	// timeVal := "2017-02-14 05:20:00"
	// got, err := DateTimeByFormat(timeVal, "2006-01-02 15:04:05")
	// if err != nil {
	// 	t.Errorf("There should be no error, but now there is one:%s", err)
	// 	return
	// }
	// if got != expected {
	// 	t.Errorf("Expected %v, but got %v", expected, got)
	// 	return
	// }

	// got, err = DateTimeByFormat(got, "2006-01-02 15:04:05")
	// if err != nil {
	// 	t.Errorf("There should be no error, but now there is one:%s", err)
	// 	return
	// }
	// if got != expected {
	// 	t.Errorf("Expected %v, but got %v", expected, got)
	// 	return
	// }

	// got, err = DateTimeByFormat(got.Unix(), "2006-01-02 15:04:05")
	// if err != nil {
	// 	t.Errorf("There should be no error, but now there is one:%s", err)
	// 	return
	// }
	// if got != expected {
	// 	t.Errorf("Expected %v, but got %v", expected, got)
	// 	return
	// }
}

func TestDateTimeArrayByFormat(t *testing.T) {

}

func TestConvert(t *testing.T) {
	result, err := Convert([]int{}, reflect.Map)
	if err == nil {
		t.Errorf("There should be an error, but now there isn't.")
		return
	}

	// Test Convert with type int
	expected_int := 1
	result, err = Convert(1, reflect.Int)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(int); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_int {
		t.Errorf("Expected %d, but got %d", expected_int, got)
		return
	}

	// Test Convert with type int8
	expected_int8 := int8(1)
	result, err = Convert(1, reflect.Int8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(int8); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_int8 {
		t.Errorf("Expected %d, but got %d", expected_int8, got)
		return
	}

	// Test Convert with type int16
	expected_int16 := int16(1)
	result, err = Convert(1, reflect.Int16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(int16); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_int16 {
		t.Errorf("Expected %d, but got %d", expected_int16, got)
		return
	}

	// Test Convert with type int32
	expected_int32 := int32(1)
	result, err = Convert(1, reflect.Int32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(int32); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_int32 {
		t.Errorf("Expected %d, but got %d", expected_int32, got)
		return
	}

	// Test Convert with type int64
	expected_int64 := int64(1)
	result, err = Convert(1, reflect.Int64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(int64); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_int64 {
		t.Errorf("Expected %d, but got %d", expected_int64, got)
		return
	}

	// Test Convert with type uint
	expected_uint := uint(1)
	result, err = Convert(1, reflect.Uint)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(uint); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_uint {
		t.Errorf("Expected %d, but got %d", expected_uint, got)
		return
	}

	// Test Convert with type int8
	expected_uint8 := uint8(1)
	result, err = Convert(1, reflect.Uint8)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(uint8); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_uint8 {
		t.Errorf("Expected %d, but got %d", expected_uint8, got)
		return
	}

	// Test Convert with type int16
	expected_uint16 := uint16(1)
	result, err = Convert(1, reflect.Uint16)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(uint16); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_uint16 {
		t.Errorf("Expected %d, but got %d", expected_uint16, got)
		return
	}

	// Test Convert with type uint32
	expected_uint32 := uint32(1)
	result, err = Convert(1, reflect.Uint32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(uint32); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_uint32 {
		t.Errorf("Expected %d, but got %d", expected_uint32, got)
		return
	}

	// Test Convert with type uint64
	expected_uint64 := uint64(1)
	result, err = Convert(1, reflect.Uint64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(uint64); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_uint64 {
		t.Errorf("Expected %d, but got %d", expected_uint64, got)
		return
	}

	// Test Convert with type float32
	expected_float32 := float32(1.0)
	result, err = Convert(1, reflect.Float32)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(float32); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_float32 {
		t.Errorf("Expected %f, but got %f", expected_float32, got)
		return
	}

	// Test Convert with type float64
	expected_float64 := float64(1.0)
	result, err = Convert(1, reflect.Float64)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(float64); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_float64 {
		t.Errorf("Expected %f, but got %f", expected_float64, got)
		return
	}

	// Test Convert with type bool
	expected_bool := true
	result, err = Convert(true, reflect.Bool)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(bool); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_bool {
		t.Errorf("Expected %t, but got %t", expected_bool, got)
		return
	}

	// Test Convert with type string
	expected_string := "hello"
	result, err = Convert("hello", reflect.String)
	if err != nil {
		t.Errorf("There should be no error, but now there is one:%s", err)
		return
	}
	if got, ok := result.(string); !ok {
		t.Errorf("The type should be int, but now it's not.")
		return
	} else if got != expected_string {
		t.Errorf("Expected %s, but got %s", expected_string, got)
		return
	}
}
