utils

package
v1.3.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 29, 2024 License: MIT Imports: 16 Imported by: 5

README

Read this in other languages: English, 中文.

utils

async_test.go

TestAsyncInvokeWithTimeout

f1 := false
f2 := false
result := AsyncInvokeWithTimeout(time.Second*1, func() {
	time.Sleep(time.Millisecond * 500)
	f1 = true
}, func() {
	time.Sleep(time.Millisecond * 500)
	f2 = true
})

if !result {
	t.FailNow()
}

if !f1 {
	t.FailNow()
}

if !f2 {
	t.FailNow()
}
TestAsyncInvokeWithTimeouted

f1 := false
f2 := false
result := AsyncInvokeWithTimeout(time.Second*1, func() {
	time.Sleep(time.Millisecond * 1500)
	f1 = true
}, func() {
	time.Sleep(time.Millisecond * 500)
	f2 = true
})

if result {
	t.FailNow()
}

if f1 {
	t.FailNow()
}

if !f2 {
	t.FailNow()
}
TestAsyncInvokesWithTimeout

f1 := false
f2 := false

fns := []func(){
	func() {
		time.Sleep(time.Millisecond * 500)
		f1 = true
	}, func() {
		time.Sleep(time.Millisecond * 500)
		f2 = true
	},
}
result := AsyncInvokesWithTimeout(time.Second*1, fns)

if !result {
	t.FailNow()
}

if !f1 {
	t.FailNow()
}

if !f2 {
	t.FailNow()
}
TestSleep

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

t1 := time.Now()
go func() {
	cancel()
}()

Sleep(ctx, 2*time.Second)

if time.Since(t1) > time.Second {
	t.FailNow()
}

cbk

cbk_test.go
TestCbkFailed

InitCbk()

var ok bool
var lastBreaked bool
for j := 0; j < 200; j++ {
	i := j
	//safego.Go(func() {
	err := Impls[SIMPLE].Check("test") //30s 返回一次true尝试
	fmt.Println(i, "Check:", ok)

	if err == nil {
		time.Sleep(time.Millisecond * 10)
		Impls[SIMPLE].Failed("test")

		if i > 105 && lastBreaked {
			Impls[SIMPLE].Succeed("test")
			lastBreaked = false
			fmt.Println(i, "Succeed")
		}
	} else {
		if lastBreaked {
			time.Sleep(time.Second * 10)
		} else {
			lastBreaked = true
		}
	}
	//})
}

checksum

crc32_test.go
TestCompareChecksumFiles

checkSumPath, err := GenerateChecksumFile(context.Background(), testTempDirPath, testChecksumName)
if err != nil {
	t.Error(err)
	return
}
t.Log(checkSumPath)

checksumMd5Path, err := GenerateChecksumMd5File(context.Background(), checkSumPath)
if err != nil {
	t.Error(err)
	return
}

valid := IsChecksumFileValid(context.Background(), checkSumPath, checksumMd5Path)
if !valid {
	t.Error(valid)
	return
}

err = CompareChecksumFiles(context.Background(), testTempDirPath, checkSumPath)
if err != nil {
	t.Error(err)
	return
}

conv

conv.pb_test.go
conv_test.go
TestValueToString

var str string
var err error

str, err = ValueToString(100.2)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[float64](str); err != nil || val != 100.2 {
	t.Error(val, err)
}

str, err = ValueToString(200)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[int64](str); err != nil || val != 200 {
	t.Error(val, err)
}

str, err = ValueToString(true)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[bool](str); err != nil || val != true {
	t.Error(val, err)
}

str, err = ValueToString("this is str")
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[string](str); err != nil || val != "this is str" {
	t.Error(val, err)
}

st := testDataStruct{
	Field1: "f1",
	Field2: 1000,
	Field3: 2,
}
str, err = ValueToString(st)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[testDataStruct](str); err != nil || !reflect.DeepEqual(val, st) {
	t.Error(val, err)
}

if val, err := StringToValue[*testDataStruct](str); err != nil || !reflect.DeepEqual(*val, st) {
	t.Error(val, err)
}

mst := map[string]*testDataStruct{"one": &st}
str, err = ValueToString(mst)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[map[string]*testDataStruct](str); err != nil || !reflect.DeepEqual(val, mst) {
	t.Error(val, err)
}

slice := []string{"a", "b", "c"}
str, err = ValueToString(slice)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[[]string](str); err != nil || !reflect.DeepEqual(val, slice) {
	t.Error(val, err)
}

sample := &ConvSample{
	Field1: "192.168.0.1",
	Field2: "192.168.0.100",
	Ts:     12345,
}
str, err = ValueToString(sample)
if err != nil {
	t.FailNow()
}

if val, err := StringToValue[ConvSample](str); err != nil || val.Field1 != sample.Field1 || val.Field2 != sample.Field2 || val.Ts != sample.Ts {
	t.Error(val, err)
}

csv

csv_parse_test.go
TestReadCsvToDataTable

dt, err := ReadCsvFileToDataTable(context.Background(), filepath.Join(testTempDirPath, testCsvFilePath), ',',
	[]string{"id", "name", "age", "remark"}, "id", []string{"name"})
if err != nil {
	t.Error(err)
}

if !reflect.DeepEqual(dt.Row("10").Data(), []string{"10", "name10", "10", "remark10"}) {
	t.FailNow()
}

if !reflect.DeepEqual(dt.RowsBy("name", "name10")[0].Data(), []string{"10", "name10", "10", "remark10"}) {
	t.FailNow()
}
TestParseCsvRaw

records := ParseCsvRaw(context.Background(),
	`id	name	age	remark
0	name0	0	remark0
1	name1	1	remark1
2	name2	2	remark2
3	name3	3	remark3
4	name4	4	remark4
5	name5	5	remark5
6	name6	6	remark6
7	name7	7	remark7
8	name8	8	remark8
9	name9	9	remark9
10	name10	10	remark10
11	name11	11	remark11
12	name12	12	remark12
13	name13	13	remark13
14	name14	14	remark14
15	name15	15	remark15
16	name16	16	remark16
17	name17	17	remark17
18	name18	18	remark18
19	name19	19	remark19`)

dt := container.NewDataTable(records[0], "id", []string{"name"}, 20)
dt.PushAll(records[1:])

if !reflect.DeepEqual(dt.Row("10").Data(), []string{"10", "name10", "10", "remark10"}) {
	t.FailNow()
}

if !reflect.DeepEqual(dt.RowsBy("name", "name10")[0].Data(), []string{"10", "name10", "10", "remark10"}) {
	t.FailNow()
}
TestParseCsvGBK

u8 := `id	name	age	remark
0	name0	0	描述0
1	name1	1	描述1
2	name2	2	描述2
3	name3	3	描述3
4	name4	4	描述4
5	name5	5	描述5
6	name6	6	描述6
7	name7	7	描述7
8	name8	8	描述8
9	name9	9	描述9
10	name10	10	描述10
11	name11	11	描述11
12	name12	12	描述12
13	name13	13	描述13
14	name14	14	描述14
15	name15	15	描述15
16	name16	16	描述16
17	name17	17	描述17
18	name18	18	描述18
19	name19	19	描述19`

reader := transform.NewReader(bytes.NewReader([]byte(u8)), simplifiedchinese.GB18030.NewEncoder())

dt, err := ReadCsvToDataTable(context.Background(), reader, '\t',
	[]string{"id", "name", "remark"}, "", []string{"name"}) //pk default cols[0]
if err != nil {
	t.Error(err)
}

if !reflect.DeepEqual(dt.Row("10").Data(), []string{"10", "name10", "描述10"}) {

	t.Error(dt.Row("10"))
}

if !reflect.DeepEqual(dt.RowsBy("name", "name10")[0].Data(), []string{"10", "name10", "描述10"}) {
	t.FailNow()
}
TestParseShortCsv

data := `id	name	age	remark`
dt, err := ReadCsvToDataTable(context.Background(), strings.NewReader(data), '\t',
	[]string{"id", "name", "remark"}, "", []string{"name"}) //pk default cols[0]
if err != nil {
	t.Error(err)
}

if dt == nil {
	t.FailNow()
}

if len(dt.Rows()) != 0 {
	t.Error(dt.Rows())
}

dt, err = ReadCsvToDataTable(context.Background(), strings.NewReader(""), '\t',
	[]string{"id", "name", "remark"}, "", []string{"name"}) //pk default cols[0]
if err != ErrCsvIsEmpty {
	t.Error(err)
}

distlock

consullock_test.go
TestAquireConsulLock

l, _ := NewConsulLock("accountId", 10)
//l.Lock(15)
//l.Unlock()
ctx := context.Background()
fmt.Println("try lock 1")

fmt.Println(l.Lock(ctx, 5))
//time.Sleep(time.Second * 6)

//fmt.Println("try lock 2")
//fmt.Println(l.Lock(3))

l2, _ := NewConsulLock("accountId", 10)
fmt.Println("try lock 3")
fmt.Println(l2.Lock(ctx, 15))

l3, _ := NewConsulLock("accountId", 10)
fmt.Println("try lock 4")
fmt.Println(l3.Lock(ctx, 15))

time.Sleep(time.Minute)
filelock_test.go
TestFileLock

test_file_path, _ := os.Getwd()
locked_file := test_file_path

wg := sync.WaitGroup{}

for i := 0; i < 10; i++ {
	wg.Add(1)
	go func(num int) {
		flock := NewFileLock(locked_file, false)
		err := flock.Lock()
		if err != nil {
			wg.Done()
			fmt.Println(err.Error())
			return
		}
		fmt.Printf("output : %d\n", num)
		wg.Done()
	}(i)
}
wg.Wait()
time.Sleep(2 * time.Second)
rdslock_test.go
TestRdsLock

redis.InitRedises()
l, err := NewRdsLuaLock("rdscdb", "accoutId", 4)
if err != nil {
	t.Error(err)
}

l2, err := NewRdsLuaLock("rdscdb", "accoutId", 4)
if err != nil {
	t.Error(err)
}

ctx := context.Background()

if !l.Lock(ctx, 1) {
	t.Error("can not get lock")
}

time.Sleep(time.Millisecond * 300)
if l2.Lock(ctx, 1) {
	t.Error("except get lock")
}
l.Unlock(ctx)

time.Sleep(time.Millisecond * 100)

if !l2.Lock(ctx, 1) {
	t.Error("can not get lock")
}

dll_mod_test.go

TestDllCall

mod := NewDllMod("ntdll.dll")

info := &struct {
	osVersionInfoSize uint32
	MajorVersion      uint32
	MinorVersion      uint32
	BuildNumber       uint32
	PlatformId        uint32
	CsdVersion        [128]uint16
	ServicePackMajor  uint16
	ServicePackMinor  uint16
	SuiteMask         uint16
	ProductType       byte
	_                 byte
}{}

info.osVersionInfoSize = uint32(unsafe.Sizeof(*info))
retCode, err := mod.Call("RtlGetVersion", uintptr(unsafe.Pointer(info)))
if err != nil {
	t.Error(err)
}

if retCode != 0 {
	t.Error(retCode)
}

if info.MajorVersion == 0 {
	t.Error(info.MajorVersion)
}

retCode, err = mod.Call("RtlGetVersion", uintptr(unsafe.Pointer(info)))
if err != nil {
	t.Error(err)
}
if err != nil {
	t.Error(err)
}

if retCode != 0 {
	t.Error(retCode)
}

if info.MajorVersion == 0 {
	t.Error(info.MajorVersion)
}
TestDllConvertString

mod := NewDllMod("test.dll")

testStr := "abcde很棒"
var arg uintptr
var err error
arg, err = mod.convertArg(testStr)
if err != nil {
	t.FailNow()
}

var slice []byte
header := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
header.Data = arg
header.Len = len(testStr)
header.Cap = header.Len

if string(slice) != testStr {
	t.FailNow()
}
TestDllConvertInt

mod := NewDllMod("test.dll")

testDllConvertNum(t, mod, int(-1080))
testDllConvertNum(t, mod, uint(1080))
testDllConvertNum(t, mod, int8(-128))
testDllConvertNum(t, mod, uint8(255))
testDllConvertNum(t, mod, int16(-30000))
testDllConvertNum(t, mod, uint16(30000))
testDllConvertNum(t, mod, int32(-3000000))
testDllConvertNum(t, mod, uint32(3000000))
testDllConvertNum(t, mod, int64(-3000000))
testDllConvertNum(t, mod, uint64(3000000))
testDllConvertNum(t, mod, uintptr(11080))

testData := 123
up := unsafe.Pointer(&testData)
testDllConvertNum(t, mod, up)

testDllConvertNumPtr(t, mod, int(-1080))
testDllConvertNumPtr(t, mod, uint(1080))
testDllConvertNumPtr(t, mod, int8(-128))
testDllConvertNumPtr(t, mod, uint8(255))
testDllConvertNumPtr(t, mod, int16(-30000))
testDllConvertNumPtr(t, mod, uint16(30000))
testDllConvertNumPtr(t, mod, int32(-3000000))
testDllConvertNumPtr(t, mod, uint32(3000000))
testDllConvertNumPtr(t, mod, int64(-3000000))
testDllConvertNumPtr(t, mod, uint64(3000000))
testDllConvertNumPtr(t, mod, uintptr(11080))

testDllConvertNumPtr(t, mod, float32(100.12))
testDllConvertNumPtr(t, mod, float64(100.12))
testDllConvertNumPtr(t, mod, complex64(100.12))
testDllConvertNumPtr(t, mod, complex128(100.12))
TestDllConvertBool

mod := NewDllMod("test.dll")

var arg uintptr
var err error
arg, err = mod.convertArg(true)
if err != nil {
	t.FailNow()
}

if arg != 1 {
	t.FailNow()
}
TestDllConvertSlice

mod := NewDllMod("test.dll")

origSlice := []byte("testslicecvt")

var arg uintptr
var err error
arg, err = mod.convertArg(origSlice)
if err != nil {
	t.FailNow()
}

var slice []byte
header := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
header.Data = arg
header.Len = len(origSlice)
header.Cap = header.Len

if bytes.Compare(origSlice, slice) != 0 {
	t.FailNow()
}
TestDllConvertStructPtr

mod := NewDllMod("test.dll")

s := testDllModStruct{100, 200, 300}

var arg uintptr
var err error
arg, err = mod.convertArg(&s)
if err != nil {
	t.FailNow()
}

s2 := *(*testDllModStruct)(unsafe.Pointer(arg))
if s2.x1 != s.x1 || s2.x2 != s.x2 || s2.x4 != s.x4 {
	t.FailNow()
}
TestGetCStrFromUintptr

mod := NewDllMod("test.dll")

testStr := "abcde很棒"
var arg uintptr
var err error
arg, err = mod.convertArg(testStr)
if err != nil {
	t.FailNow()
}

origStr := mod.GetCStrFromUintptr(arg)

if testStr != origStr {
	t.FailNow()
}
TestDllConvertUnsupport

mod := NewDllMod("test.dll")

_, err := mod.convertArg(float32(11.12))
if err != ErrUnsupportArg {
	t.Error(err)
}

_, err = mod.convertArg(float64(11.12))
if err != ErrUnsupportArg {
	t.Error(err)
}

_, err = mod.convertArg(complex64(11.12))
if err != ErrUnsupportArg {
	t.Error(err)
}

_, err = mod.convertArg(complex128(11.12))
if err != ErrUnsupportArg {
	t.Error(err)
}

m := make(map[string]string)
_, err = mod.convertArg(m)
if err != ErrUnsupportArg {
	t.Error(err)
}

c := make(chan struct{})
_, err = mod.convertArg(c)
if err != ErrUnsupportArg {
	t.Error(err)
}

s := struct{}{}
_, err = mod.convertArg(s)
if err != ErrUnsupportArg {
	t.Error(err)
}

_, err = mod.convertArg(interface{}(s))
if err != ErrUnsupportArg {
	t.Error(err)
}

docgen

cmd
doc
docgen_test.go
TestGenDocTestUser

sb := strings.Builder{}
sb.WriteString(genDocTestUserQuery())
sb.WriteString(genDocTestUserCreate())
sb.WriteString(genDocTestUserUpdate())
sb.WriteString(genDocTestUserDelete())

GenDoc(context.Background(), "用户管理", "doc/testuser.md", 2, sb.String())

encoding_test.go

TestGBK2UTF8

src := []byte{206, 210, 202, 199, 103, 111, 117, 116, 105, 108, 115, 49}
utf8str, err := GBK2UTF8(src)
if err != nil {
	t.FailNow()
}

if string(utf8str) != "我是goutils1" {
	t.FailNow()
}
TestUTF82GBK

src := []byte{230, 136, 145, 230, 152, 175, 103, 111, 117, 116, 105, 108, 115, 49}
gbkStr, err := UTF82GBK(src)
if err != nil {
	t.FailNow()
}

if !reflect.DeepEqual(gbkStr, []byte{206, 210, 202, 199, 103, 111, 117, 116, 105, 108, 115, 49}) {
	t.FailNow()
}
TestIsGBK

if !IsGBK([]byte{206, 210}) {
	t.FailNow()
}
TestIsUtf8

if !IsUtf8([]byte{230, 136, 145}) {
	t.FailNow()
}

file_test.go

TestGetCurrPath

path := GetCurrPath()
t.Log(path)
TestFileExist

runFile := os.Args[0]

if !FileExist(runFile) {
	t.Error(runFile)
}
TestFileExt

if FileExt("aaa.txt") != ".txt" {
	t.Error(FileExt("aaa.txt"))
}

if FileExt("aaa.txt.zip") != ".zip" {
	t.Error(FileExt("aaa.txt.zip"))
}

if FileExt("aaa.txt.") != "." {
	t.Error(FileExt("aaa.txt."))
}

if FileExt("aaa") != "" {
	t.Error(FileExt("aaa"))
}
TestFileCopy

runFile := os.Args[0]
err := FileCopy(runFile, filepath.Join(testTempDirPath, "test_file"))
if err != nil {
	t.Error()
}

err = FileCopy(filepath.Join(testTempDirPath, "test_file"), filepath.Join(testTempDirPath, "test_file"))
if err != nil {
	t.Error()
}

err = FileCopy(filepath.Join(testTempDirPath, "test_file"), ".")
if err == nil {
	t.Error()
}
TestIsPathTravOut

if IsPathTravOut(`C:\a\b`, `C:\a`) {
	t.FailNow()
}

if IsPathTravOut(`C:\A\B`, `C:\a`) {
	t.FailNow()
}

if IsPathTravOut(`C:\a\b\..`, `C:\a`) {
	t.FailNow()
}

if !IsPathTravOut(`C:\a\b\..\..`, `C:\a`) {
	t.FailNow()
}

if !IsPathTravOut(`C:\A\B\..\..`, `C:\a`) {
	t.FailNow()
}

if !IsPathTravOut(`C:\a\b`, `C:\c`) {
	t.FailNow()
}
TestUniformPathStyle

if UniformPathStyle(`C:\a\b`) != `C:/a/b` {
	t.FailNow()
}

if UniformPathStyleCase(`C:\A\B`) != `c:/a/b` {
	t.FailNow()
}

if !reflect.DeepEqual(UniformPathListStyleCase([]string{`C:\A\B`}), []string{`c:/a/b`}) {
	t.FailNow()
}
TestIsSameFilePath

if !IsSameFilePath(`C:\a\b`, `C:/a/b`) {
	t.FailNow()
}

if !IsSameFilePath(`C:\a\..\a\b`, `C:/a/b`) {
	t.FailNow()
}

if IsSameFilePath(`C:\a\..\a\b\c`, `C:/a/b`) {
	t.FailNow()
}

fsm

hc

ismtp

ismtp_test.go
TestSendEmail

emailauth := LoginAuth(
	"from",
	"xxxxxx",
	"mailhost.com",
)

ctype := fmt.Sprintf("Content-Type: %s; charset=%s", "text/plain", "utf-8")

msg := fmt.Sprintf("To: %s\r\nCc: %s\r\nFrom: %s\r\nSubject: %s\r\n%s\r\n\r\n%s",
	strings.Join([]string{"target@mailhost.com"}, ";"),
	"",
	"from@mailhost.com",
	"测试",
	ctype,
	"测试")

err := SendMail("mailhost.com:port", //convert port number from int to string
	emailauth,
	"from@mailhost.com",
	[]string{"target@mailhost.com"},
	[]byte(msg),
)

if err != nil {
	t.Log(err)
	return
}

return

math_test.go

TestMathMin

if Min(10, 9) != 9 {
	t.FailNow()
}

if Min(-1, -2) != -2 {
	t.FailNow()
}

if Min(3.1, 4.02) != 3.1 {
	t.FailNow()
}
TestMathMax

if Max(10, 9) != 10 {
	t.FailNow()
}

if Max(-1, -2) != -1 {
	t.FailNow()
}

if Max(3.1, 4.02) != 4.02 {
	t.FailNow()
}
TestMathAbs

if Abs(-1) != 1 {
	t.FailNow()
}

if Abs(1) != 1 {
	t.FailNow()
}

reflectutils_test.go

TestAnyIndirect

val := reflect.ValueOf(10)
if AnyIndirect(val) != val {
	t.Error(val)
}

x := 10
val2 := reflect.ValueOf(&x)
if AnyIndirect(val2) == val2 {
	t.Error(val2)
}

if AnyIndirect(val2).Int() != int64(x) {
	t.Error(val2)
}
TestIsNil

var m map[string]string
if !IsNil(m) {
	t.Error(m)
}

var c chan string
if !IsNil(c) {
	t.Error(c)
}

var fun func()
if !IsNil(fun) {
	t.Error("func not nil")
}

var s []string
if !IsNil(s) {
	t.Error(s)
}

var sp *string
if !IsNil(sp) {
	t.Error(sp)
}

var up unsafe.Pointer
if !IsNil(up) {
	t.Error(up)
}

testIsNil[map[string]string](t)
testIsNil[chan string](t)
testIsNil[func()](t)
testIsNil[[]string](t)
testIsNil[*string](t)
testIsNil[unsafe.Pointer](t)
testIsNil[T any]

value := testWrapperNil[T]()

if value == nil {
	t.Error(value)
}

if !IsNil(value) {
	t.Error(value)
}
TestPtr

intPtr := Ptr(100)
if *intPtr != 100 {
	t.Error(intPtr)
}

strPtr := Ptr("this content")
if *strPtr != "this content" {
	t.Error(strPtr)
}

safego

snowflake

snowflake_test.go
TestSnowflake

n, err := NewNode(-1)
if err == nil {
	t.FailNow()
}

n, err = NewNode(1024)
if err == nil {
	t.FailNow()
}

n, err = NewNode(2)
if err != nil {
	t.Fatal(err)
}

id1 := n.Generate()
id2 := n.Generate()
if id1 == id2 {
	t.FailNow()
}

if ParseInt64(id1.Int64()) != id1 {
	t.FailNow()
}

idtemp, err := ParseString(id1.String())
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp, err = ParseBase2(id1.Base2())
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp, err = ParseBase32([]byte(id1.Base32()))
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp, err = ParseBase36(id1.Base36())
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp, err = ParseBase58([]byte(id1.Base58()))
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp, err = ParseBase64(id1.Base64())
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp, err = ParseBytes(id1.Bytes())
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

idtemp = ParseIntBytes(id1.IntBytes())
if idtemp != id1 {
	t.FailNow()
}

bs, err := id1.MarshalJSON()
if err != nil {
	t.Fatal(err)
}

idtemp = ID(0)
err = idtemp.UnmarshalJSON(bs)
if err != nil {
	t.Fatal(err)
}
if idtemp != id1 {
	t.FailNow()
}

stringparse_test.go

TestParseContentByTag

tagStr := "<a href='goutils' ></a>"
str, nextOffset := ParseContentByTag(tagStr, "<a", ">")

if strings.TrimSpace(str) != "href='goutils'" {
	t.Error(str)
}

if tagStr[nextOffset:] != "</a>" {
	t.Error(tagStr[nextOffset:])
}
TestCheckKeyValueExpected

keyValues := make(map[string]string)
keyValues["gotuils1"] = "tim"
keyValues["gotuils2"] = "jack"
if !CheckKeyValueExpected(keyValues, "gotuils1", "eric", []string{"tim"}) {
	t.FailNow()
}

if CheckKeyValueExpected(keyValues, "gotuils3", "eric", []string{"tim"}) {
	t.FailNow()
}

if !CheckKeyValueExpected(keyValues, "gotuils3", "tim", []string{"tim"}) {
	t.FailNow()
}

if CheckKeyValueExpected(keyValues, "gotuils1", "eric", []string{"carry"}) {
	t.FailNow()
}

if CheckKeyValueExpected(keyValues, "gotuils3", "eric", []string{"carry"}) {
	t.FailNow()
}

if !CheckKeyValueExpected(keyValues, "gotuils3", "carry", []string{"carry"}) {
	t.FailNow()
}

stringutils_test.go

TestStringsReverse

var strs = []string{"1", "2", "3", "4"}
revStrs := StringsReverse(strs)

if !reflect.DeepEqual(revStrs, []string{"4", "3", "2", "1"}) {
	t.FailNow()
}
TestStringsInArray

var strs = []string{"1", "2", "3", "4"}
ok, index := StringsInArray(strs, "3")
if !ok {
	t.FailNow()
}

if index != 2 {
	t.FailNow()
}

ok, index = StringsInArray(strs, "5")
if ok {
	t.FailNow()
}

if index != -1 {
	t.FailNow()
}
TestStringsExcept

var strs1 = []string{"1", "2", "3", "4"}
var strs2 = []string{"3", "4", "5", "6"}

if !reflect.DeepEqual(StringsExcept(strs1, strs2), []string{"1", "2"}) {
	t.FailNow()
}

if !reflect.DeepEqual(StringsExcept(strs1, []string{}), []string{"1", "2", "3", "4"}) {
	t.FailNow()
}

if !reflect.DeepEqual(StringsExcept([]string{}, strs2), []string{}) {
	t.FailNow()
}
TestStringsDistinct

var strs1 = []string{"1", "2", "3", "4", "1", "3"}
distincted := StringsDistinct(strs1)
sort.Strings(distincted)
if !reflect.DeepEqual(distincted, []string{"1", "2", "3", "4"}) {
	t.FailNow()
}

struct_test.go

TestCopyStruct

type SrcFoo struct {
	A                int
	B                []*string
	C                map[string]*int
	SrcUnique        string
	SameNameDiffType time.Time
}
type DstFoo struct {
	A                int
	B                []*string
	C                map[string]*int
	DstUnique        int
	SameNameDiffType string
}

// Create the initial value
str1 := "hello"
str2 := "bye bye"
int1 := 1
int2 := 2
f1 := &SrcFoo{
	A: 1,
	B: []*string{&str1, &str2},
	C: map[string]*int{
		"A": &int1,
		"B": &int2,
	},
	SrcUnique:        "unique",
	SameNameDiffType: time.Now(),
}
var f2 DstFoo

CopyStructDefault(f1, &f2)

if !reflect.DeepEqual(f1.A, f2.A) {
	t.Error(f2)
}

if !reflect.DeepEqual(f1.B, f2.B) {
	t.Error(f2)
}

if !reflect.DeepEqual(f1.C, f2.C) {
	t.Error(f2)
}

if !reflect.DeepEqual(BaseConvert(f1.SameNameDiffType, reflect.TypeOf("")), f2.SameNameDiffType) {
	t.Error(f2)
}

f3 := &DstFoo{
	A: 1,
	B: []*string{&str1, &str2},
	C: map[string]*int{
		"A": &int1,
		"B": &int2,
	},
	DstUnique:        1,
	SameNameDiffType: time.Now().Format(STRUCT_DATE_TIME_FORMAT_LAYOUT),
}
var f4 SrcFoo
CopyStruct(f3, &f4, BaseConvert)

if !reflect.DeepEqual(f3.A, f4.A) {
	t.Error(f4)
}

if !reflect.DeepEqual(f3.B, f4.B) {
	t.Error(f4)
}

if !reflect.DeepEqual(f3.C, f4.C) {
	t.Error(f4)
}

f3Time, _ := time.ParseInLocation(STRUCT_DATE_TIME_FORMAT_LAYOUT, f3.SameNameDiffType, time.Local)
if !reflect.DeepEqual(f3Time, f4.SameNameDiffType) {
	t.Error(f4)
}
TestCopyStructs

type SrcFoo struct {
	A                int
	B                []*string
	C                map[string]*int
	SrcUnique        string
	SameNameDiffType time.Time
}
type DstFoo struct {
	A                int
	B                []*string
	C                map[string]*int
	DstUnique        int
	SameNameDiffType string
}

// Create the initial value
str1 := "hello"
str2 := "bye bye"
int1 := 1
int2 := 2
f1 := []SrcFoo{{
	A: 1,
	B: []*string{&str1, &str2},
	C: map[string]*int{
		"A": &int1,
		"B": &int2,
	},
	SrcUnique:        "unique",
	SameNameDiffType: time.Now(),
}}
var f2 []DstFoo
CopyStructs(f1, &f2, BaseConvert)

if !reflect.DeepEqual(f1[0].A, f2[0].A) {
	t.Error(f2)
}

if !reflect.DeepEqual(f1[0].B, f2[0].B) {
	t.Error(f2)
}

if !reflect.DeepEqual(f1[0].C, f2[0].C) {
	t.Error(f2)
}

if !reflect.DeepEqual(BaseConvert(f1[0].SameNameDiffType, reflect.TypeOf("")), f2[0].SameNameDiffType) {
	t.Error(f2)
}

var f3 []*DstFoo
CopyStructsDefault(f1, &f3)

if !reflect.DeepEqual(f1[0].A, f3[0].A) {
	t.Error(f3)
}

if !reflect.DeepEqual(f1[0].B, f3[0].B) {
	t.Error(f3)
}

if !reflect.DeepEqual(f1[0].C, f3[0].C) {
	t.Error(f3)
}

if !reflect.DeepEqual(BaseConvert(f1[0].SameNameDiffType, reflect.TypeOf("")), f3[0].SameNameDiffType) {
	t.Error(f3)
}

tags_test.go

TestAutoGenTags

structStrWithTag := AutoGenTags(testUser{}, map[string]TAG_STYLE{
	"json":      TAG_STYLE_SNAKE,
	"bson":      TAG_STYLE_UNDERLINE,
	"form":      TAG_STYLE_ORIG,
	"nonestyle": TAG_STYLE_NONE,
})

if !strings.Contains(structStrWithTag, `bson:"user_id"`) {
	t.FailNow()
}

if !strings.Contains(structStrWithTag, `form:"UserId"`) {
	t.FailNow()
}

if !strings.Contains(structStrWithTag, `json:"userId"`) {
	t.FailNow()
}

if !strings.Contains(structStrWithTag, `json:"status"`) {
	t.FailNow()
}

if strings.Contains(structStrWithTag, `nonestyle:`) {
	t.FailNow()
}

//t.Log(structStrWithTag)

Documentation

Index

Constants

View Source 
const (
	STRUCT_DATE_TIME_FORMAT_LAYOUT = "2006-01-02 15:04:05"
	STRUCT_DATE_FORMAT_LAYOUT      = "2006-01-02"
)

Variables

View Source 
var (
	TAG_STYLE_NONE      = 0
	TAG_STYLE_ORIG      = 1
	TAG_STYLE_SNAKE     = 2
	TAG_STYLE_UNDERLINE = 3
)
View Source 
var (
	StructTimeType = reflect.TypeOf(time.Now())
)

Functions

func Abs 

func Abs[T int | int32 | int64 | float32 | float64 | time.Duration](x T) T

func AnyIndirect 

func AnyIndirect(v reflect.Value) reflect.Value

func AsyncInvokeWithTimeout 

func AsyncInvokeWithTimeout(timeout time.Duration, args ...func()) bool

usage: var respInfos []string 

result := AsyncInvokeWithTimeout(time.Second*4, func() {
	time.Sleep(time.Second*2)
	respInfos = []string{"we add1","we add2"}
	fmt.Println("1done")
},func() {

	time.Sleep(time.Second*1)
	//respInfos = append(respInfos,"we add3")
	fmt.Println("2done")
})

fmt.Println("1alldone:",result)

func AsyncInvokesWithTimeout 

func AsyncInvokesWithTimeout(timeout time.Duration, fs []func()) bool

func AutoGenTags 

func AutoGenTags(vo interface{}, tagDefs map[string]TAG_STYLE) string

func BaseConvert 

func BaseConvert(src interface{}, dstType reflect.Type) interface{}

func CheckKeyValueExpected 

func CheckKeyValueExpected(keyValues map[string]string, keyName, defaultKeyValue string, expectKeyValues []string) bool

检查keyname的keyvalue是否符合预期值expectKeyValues，如果不存在keyvalue，使用defaultKeyValue判断

func ConvertFieldStyle 

func ConvertFieldStyle(str string, style TAG_STYLE) string

func CopyStruct 

func CopyStruct(src, dest interface{}, f StructConvFunc) error

dest 必须是指针

func CopyStructDefault 

func CopyStructDefault(src, dest interface{}) error

func CopyStructs 

func CopyStructs(src, dest interface{}, f StructConvFunc) error

dest 必须是数组的指针

func CopyStructsDefault 

func CopyStructsDefault(src, dest interface{}) error

func FileCopy added in v1.1.34 

func FileCopy(src, dst string) error

func FileExist 

func FileExist(filePath string) bool

func FileExt 

func FileExt(filePath string) string

func GBK2UTF8 

func GBK2UTF8(s []byte) ([]byte, error)

func GetCurrPath added in v1.0.14 

func GetCurrPath() string

func IsGBK added in v1.0.16 

func IsGBK(data []byte) bool

func IsNil 

func IsNil(value interface{}) bool

func IsPathTravOut added in v1.3.5 

func IsPathTravOut(path, base string) bool

func IsSameFilePath added in v1.3.5 

func IsSameFilePath(src, dst string) bool

func IsUtf8 added in v1.0.16 

func IsUtf8(data []byte) bool

func Max 

func Max[T int | int32 | uint32 | int64 | uint64 | float32 | float64 | time.Duration](x, y T) T

func Min 

func Min[T int | int32 | uint32 | int64 | uint64 | float32 | float64 | time.Duration](x, y T) T

func ParseContentByTag added in v1.0.14 

func ParseContentByTag(content, tagStart, tagEnd string) (string, int)

func Ptr added in v1.3.6 

func Ptr[T any](v T) *T

func SafeIsNil 

func SafeIsNil(value *reflect.Value) bool

func Sleep added in v1.3.6 

func Sleep(ctx context.Context, duration time.Duration)

func StringsDistinct added in v1.3.5 

func StringsDistinct(input []string) []string

func StringsExcept 

func StringsExcept(ss1 []string, ss2 []string) []string

func StringsInArray 

func StringsInArray(s []string, e string) (bool, int)

func StringsReverse 

func StringsReverse(s []string) []string

func UTF82GBK 

func UTF82GBK(s []byte) ([]byte, error)

func UniformPathListStyleCase added in v1.3.5 

func UniformPathListStyleCase(pathList []string) []string

func UniformPathStyle added in v1.3.5 

func UniformPathStyle(path string) string

func UniformPathStyleCase added in v1.3.5 

func UniformPathStyleCase(path string) string

Types

type StructConvFunc 

type StructConvFunc func(interface{}, reflect.Type) interface{}

type T added in v1.3.5 

type T interface {
	comparable
}

type TAG_STYLE 

type TAG_STYLE = int

Source Files

View all Source files

Directories

Path Synopsis
cmd
Package smtp implements the Simple Mail Transfer Protocol as defined in RFC 5321.
 Package smtp implements the Simple Mail Transfer Protocol as defined in RFC 5321.
Package snowflake provides a very simple Twitter snowflake generator and parser.
 Package snowflake provides a very simple Twitter snowflake generator and parser.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.