feat: 完善time delta并添加对应单元测试

Author: CC11001100

time.go

@@ -7,18 +7,30 @@ import (
 
 // ------------------------------------------------ ---------------------------------------------------------------------
 
-// ToTimeSliceDelta 对时间序列做delta
-func ToTimeSliceDelta(timeSlice []time.Time, compareToType CompareToType) []uint64 {
+// DefaultCompareToType 如果未指定delta的时候的比较对象的话，则默认将当前时间与序列相邻的上一个时间做delta比较
+const DefaultCompareToType = CompareToPrevious
+
+// ToTimeSliceDelta 对时间序列在毫秒单位做delta
+func ToTimeSliceDelta(timeSlice []time.Time, compareToType ...CompareToType) []uint64 {
+
+	if len(compareToType) == 0 {
+		compareToType = append(compareToType, DefaultCompareToType)
+	}
+
 	deltaSlice := make([]uint64, len(timeSlice))
 	for index, t := range timeSlice {
+
+		// 第一个保持原样
 		if index == 0 {
 			deltaSlice[index] = uint64(t.UnixMilli())
 			continue
 		}
-		switch compareToType {
+
+		//从第二个开始就要delta了
+		switch compareToType[0] {
 		case CompareToFirst:
 			deltaSlice[index] = TimeDelta(t, timeSlice[0])
-		case CompareToLast:
+		case CompareToPrevious:
 			deltaSlice[index] = TimeDelta(t, timeSlice[index-1])
 		default:
 			panic(fmt.Errorf("not support compare type: %#v", compareToType))
@@ -28,44 +40,60 @@ func ToTimeSliceDelta(timeSlice []time.Time, compareToType CompareToType) []uint
 }
 
 // FromTimeSliceDelta 从Time的delta恢复时间序列
-func FromTimeSliceDelta(deltaSlice []uint64, compareToType CompareToType) []time.Time {
-	timeSlice := make([]time.Time, 0)
+func FromTimeSliceDelta(deltaSlice []uint64, compareToType ...CompareToType) []time.Time {
+
+	if len(compareToType) == 0 {
+		compareToType = append(compareToType, DefaultCompareToType)
+	}
+
+	timeSlice := make([]time.Time, len(deltaSlice))
 	for index, delta := range deltaSlice {
+
 		if index == 0 {
 			timeSlice[index] = time.UnixMilli(int64(delta))
 			continue
 		}
-		switch compareToType {
+
+		switch compareToType[0] {
 		case CompareToFirst:
 			timeSlice[index] = time.UnixMilli(int64(deltaSlice[0] + delta))
-		case CompareToLast:
+		case CompareToPrevious:
 			timeSlice[index] = timeSlice[index-1].Add(time.Millisecond * time.Duration(delta))
 		default:
 			panic(fmt.Errorf("not support compare type: %#v", compareToType))
 		}
+
 	}
+
 	return timeSlice
 }
 
-// TimeDelta 求两个时间的差
+// TimeDelta 求两个时间的毫秒差
 func TimeDelta(t1 time.Time, t2 time.Time) uint64 {
 	return uint64(t1.UnixMilli() - t2.UnixMilli())
 }
 
 // ------------------------------------------------ ---------------------------------------------------------------------
 
-// ToTimestampSliceDelta 对时间戳做delta
-func ToTimestampSliceDelta(timestampSlice []uint64, compareToType CompareToType) []uint64 {
+// ToTimestampSliceDelta 对时间戳做delta，这个时间戳可以根据自己需要，可以是10位的描述，也可以是13位的毫秒数
+func ToTimestampSliceDelta(timestampSlice []uint64, compareToType ...CompareToType) []uint64 {
+
+	if len(compareToType) == 0 {
+		compareToType = append(compareToType, DefaultCompareToType)
+	}
+
 	deltaSlice := make([]uint64, len(timestampSlice))
 	for index, timestamp := range timestampSlice {
+
 		if index == 0 {
 			deltaSlice[index] = timestamp
 			continue
 		}
-		switch compareToType {
+
+		switch compareToType[0] {
 		case CompareToFirst:
 			deltaSlice[index] = timestamp - timestampSlice[0]
-		case CompareToLast:
+		case CompareToPrevious:
 			deltaSlice[index] = timestamp - timestampSlice[index-1]
 		default:
 			panic(fmt.Errorf("not support compare type: %#v", compareToType))
@@ -75,21 +103,29 @@ func ToTimestampSliceDelta(timestampSlice []uint64, compareToType CompareToType)
 }
 
 // FromTimestampSliceDelta 从时间戳的delta恢复时间戳序列
-func FromTimestampSliceDelta(deltaSlice []uint64, compareToType CompareToType) []uint64 {
-	timeSlice := make([]uint64, 0)
+func FromTimestampSliceDelta(deltaSlice []uint64, compareToType ...CompareToType) []uint64 {
+
+	if len(compareToType) == 0 {
+		compareToType = append(compareToType, DefaultCompareToType)
+	}
+
+	timeSlice := make([]uint64, len(deltaSlice))
 	for index, delta := range deltaSlice {
+
 		if index == 0 {
 			timeSlice[index] = delta
 			continue
 		}
-		switch compareToType {
+
+		switch compareToType[0] {
 		case CompareToFirst:
 			timeSlice[index] = deltaSlice[0] + delta
-		case CompareToLast:
+		case CompareToPrevious:
 			timeSlice[index] = timeSlice[index-1] + delta
 		default:
 			panic(fmt.Errorf("not support compare type: %#v", compareToType))
 		}
+
 	}
 	return timeSlice
 }

time_test.go

@@ -1,29 +1,99 @@
 package delta
 
 import (
+	"github.com/stretchr/testify/assert"
 	"testing"
+	"time"
 )
 
-func TestFromTimeSliceDelta(t *testing.T) {
-	// TODO
-	
-}
+func TestToTimeSliceDelta(t *testing.T) {
+	firstTime := time.Now()
+	timeSlice := []time.Time{
+		firstTime,
+		firstTime.Add(time.Second * 1),
+		firstTime.Add(time.Second * 2),
+		firstTime.Add(time.Second * 3),
+		firstTime.Add(time.Second * 4),
+	}
 
-func TestFromTimestampSliceDelta(t *testing.T) {
-	// TODO
+	// 都与第一个做比较
+	deltaSlice := ToTimeSliceDelta(timeSlice, CompareToFirst)
+	assert.Equal(t, []uint64{
+		uint64(firstTime.UnixMilli()),
+		uint64(1000), uint64(2000), uint64(3000), uint64(4000),
+	}, deltaSlice)
 
+	// 都与上一个做比较
+	deltaSlice = ToTimeSliceDelta(timeSlice, CompareToPrevious)
+	assert.Equal(t, []uint64{
+		uint64(firstTime.UnixMilli()),
+		uint64(1000), uint64(1000), uint64(1000), uint64(1000),
+	}, deltaSlice)
 }
 
-func TestTimeDelta(t *testing.T) {
-	// TODO
+func TestFromTimeSliceDelta(t *testing.T) {
+	firstTime := time.Unix(1698509341981, 0)
+	timeSlice := []time.Time{
+		firstTime,
+		firstTime.Add(time.Second * 1),
+		firstTime.Add(time.Second * 2),
+		firstTime.Add(time.Second * 3),
+		firstTime.Add(time.Second * 4),
+	}
+
+	// 都与第一个做比较
+	deltaSlice := ToTimeSliceDelta(timeSlice, CompareToFirst)
+	recoveredSlice := FromTimeSliceDelta(deltaSlice, CompareToFirst)
+	assert.Equal(t, timeSlice, recoveredSlice)
 
+	// 都与上一个作比较
+	deltaSlice = ToTimeSliceDelta(timeSlice, CompareToPrevious)
+	recoveredSlice = FromTimeSliceDelta(deltaSlice, CompareToPrevious)
+	assert.Equal(t, timeSlice, recoveredSlice)
 }
 
-func TestTimeSliceDelta(t *testing.T) {
+func TestToTimestampSliceDelta(t *testing.T) {
+	firstTimestamp := uint64(time.Now().UnixMilli())
+	timeSlice := []uint64{
+		firstTimestamp,
+		firstTimestamp + 1,
+		firstTimestamp + 2,
+		firstTimestamp + 3,
+		firstTimestamp + 4,
+	}
 
-	// TODO
+	// 都与第一个做比较
+	deltaSlice := ToTimestampSliceDelta(timeSlice, CompareToFirst)
+	assert.Equal(t, []uint64{
+		firstTimestamp,
+		uint64(1), uint64(2), uint64(3), uint64(4),
+	}, deltaSlice)
+
+	// 都与上一个做比较
+	deltaSlice = ToTimestampSliceDelta(timeSlice, CompareToPrevious)
+	assert.Equal(t, []uint64{
+		firstTimestamp,
+		uint64(1), uint64(1), uint64(1), uint64(1),
+	}, deltaSlice)
 }
 
-func TestTimestampSliceDelta(t *testing.T) {
-	// TODO
+func TestFromTimestampSliceDelta(t *testing.T) {
+	firstTime := uint64(1698509341981)
+	timeSlice := []uint64{
+		firstTime,
+		firstTime + 1,
+		firstTime + 2,
+		firstTime + 3,
+		firstTime + 4,
+	}
+
+	// 都与第一个做比较
+	deltaSlice := ToTimestampSliceDelta(timeSlice, CompareToFirst)
+	recoveredSlice := FromTimestampSliceDelta(deltaSlice, CompareToFirst)
+	assert.Equal(t, timeSlice, recoveredSlice)
+
+	// 都与上一个作比较
+	deltaSlice = ToTimestampSliceDelta(timeSlice, CompareToPrevious)
+	recoveredSlice = FromTimestampSliceDelta(deltaSlice, CompareToPrevious)
+	assert.Equal(t, timeSlice, recoveredSlice)
 }