initial import

core/utils/report.go

@@ -0,0 +1,5 @@
+package utils
+
+func Report(content string) {
+	// TODO: implement the report method
+}

core/utils/times.go

@@ -0,0 +1,38 @@
+package utils
+
+import (
+	"fmt"
+	"time"
+
+	"zero/core/timex"
+)
+
+type ElapsedTimer struct {
+	start time.Duration
+}
+
+func NewElapsedTimer() *ElapsedTimer {
+	return &ElapsedTimer{
+		start: timex.Now(),
+	}
+}
+
+func (et *ElapsedTimer) Duration() time.Duration {
+	return timex.Since(et.start)
+}
+
+func (et *ElapsedTimer) Elapsed() string {
+	return timex.Since(et.start).String()
+}
+
+func (et *ElapsedTimer) ElapsedMs() string {
+	return fmt.Sprintf("%.1fms", float32(timex.Since(et.start))/float32(time.Millisecond))
+}
+
+func CurrentMicros() int64 {
+	return time.Now().UnixNano() / int64(time.Microsecond)
+}
+
+func CurrentMillis() int64 {
+	return time.Now().UnixNano() / int64(time.Millisecond)
+}

core/utils/times_test.go

@@ -0,0 +1,40 @@
+package utils
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const sleepInterval = time.Millisecond * 10
+
+func TestElapsedTimer_Duration(t *testing.T) {
+	timer := NewElapsedTimer()
+	time.Sleep(sleepInterval)
+	assert.True(t, timer.Duration() >= sleepInterval)
+}
+
+func TestElapsedTimer_Elapsed(t *testing.T) {
+	timer := NewElapsedTimer()
+	time.Sleep(sleepInterval)
+	duration, err := time.ParseDuration(timer.Elapsed())
+	assert.Nil(t, err)
+	assert.True(t, duration >= sleepInterval)
+}
+
+func TestElapsedTimer_ElapsedMs(t *testing.T) {
+	timer := NewElapsedTimer()
+	time.Sleep(sleepInterval)
+	duration, err := time.ParseDuration(timer.ElapsedMs())
+	assert.Nil(t, err)
+	assert.True(t, duration >= sleepInterval)
+}
+
+func TestCurrent(t *testing.T) {
+	currentMillis := CurrentMillis()
+	currentMicros := CurrentMicros()
+	assert.True(t, currentMillis > 0)
+	assert.True(t, currentMicros > 0)
+	assert.True(t, currentMillis*1000 <= currentMicros)
+}

core/utils/uuid.go

@@ -0,0 +1,7 @@
+package utils
+
+import "github.com/google/uuid"
+
+func NewUuid() string {
+	return uuid.New().String()
+}

core/utils/uuid_test.go

@@ -0,0 +1,11 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUuid(t *testing.T) {
+	assert.Equal(t, 36, len(NewUuid()))
+}

core/utils/version.go

@@ -0,0 +1,37 @@
+package utils
+
+import (
+	"strconv"
+	"strings"
+)
+
+// returns -1 if the first version is lower than the second, 0 if they are equal, and 1 if the second is lower.
+func CompareVersions(a, b string) int {
+	as := strings.Split(a, ".")
+	bs := strings.Split(b, ".")
+	var loop int
+	if len(as) > len(bs) {
+		loop = len(as)
+	} else {
+		loop = len(bs)
+	}
+
+	for i := 0; i < loop; i++ {
+		var x, y string
+		if len(as) > i {
+			x = as[i]
+		}
+		if len(bs) > i {
+			y = bs[i]
+		}
+		xi, _ := strconv.Atoi(x)
+		yi, _ := strconv.Atoi(y)
+		if xi > yi {
+			return 1
+		} else if xi < yi {
+			return -1
+		}
+	}
+
+	return 0
+}

core/utils/version_test.go

@@ -0,0 +1,30 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCompareVersions(t *testing.T) {
+	cases := []struct {
+		ver1 string
+		ver2 string
+		out  int
+	}{
+		{"1", "1.0.1", -1},
+		{"1.0.1", "1.0.2", -1},
+		{"1.0.3", "1.1", -1},
+		{"1.1", "1.1.1", -1},
+		{"1.3.2", "1.2", 1},
+		{"1.1.1", "1.1.1", 0},
+		{"1.1.0", "1.1", 0},
+	}
+
+	for _, each := range cases {
+		t.Run(each.ver1, func(t *testing.T) {
+			actual := CompareVersions(each.ver1, each.ver2)
+			assert.Equal(t, each.out, actual)
+		})
+	}
+}