140 lines
3.6 KiB
Go
140 lines
3.6 KiB
Go
package util
|
|
|
|
import (
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// TestSnowflake_InvalidWorkerID 验证 WorkerID 越界拦截。
|
|
func TestSnowflake_InvalidWorkerID(t *testing.T) {
|
|
for _, id := range []int64{-1, MaxWorkerID + 1, 4096} {
|
|
if _, err := NewSnowflake(id); err == nil {
|
|
t.Errorf("workerID=%d 应报错", id)
|
|
}
|
|
}
|
|
if _, err := NewSnowflake(0); err != nil {
|
|
t.Errorf("workerID=0 不应报错: %v", err)
|
|
}
|
|
if _, err := NewSnowflake(MaxWorkerID); err != nil {
|
|
t.Errorf("workerID=%d 不应报错: %v", MaxWorkerID, err)
|
|
}
|
|
}
|
|
|
|
// TestSnowflake_Structure 验证 ID 位段结构与趋势递增。
|
|
func TestSnowflake_Structure(t *testing.T) {
|
|
s, err := NewSnowflake(5)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
prev := int64(0)
|
|
for i := 0; i < 10000; i++ {
|
|
id := s.NextID()
|
|
if id <= prev {
|
|
t.Fatalf("ID 应严格递增: %d -> %d", prev, id)
|
|
}
|
|
ms, workerID, seq := DecomposeID(id)
|
|
if workerID != 5 {
|
|
t.Fatalf("WorkerID 段 = %d, 期望 5", workerID)
|
|
}
|
|
if ms <= 0 || seq < 0 || seq > maxSequence {
|
|
t.Fatalf("位段非法: ms=%d seq=%d", ms, seq)
|
|
}
|
|
prev = id
|
|
}
|
|
}
|
|
|
|
// TestSnowflake_ConcurrentNoConflict 并发场景无 ID 冲突(验收项)。
|
|
func TestSnowflake_ConcurrentNoConflict(t *testing.T) {
|
|
const workers = 8
|
|
const perWorker = 5000
|
|
|
|
s, _ := NewSnowflake(1023)
|
|
var mu sync.Mutex
|
|
seen := make(map[int64]struct{}, workers*perWorker)
|
|
var wg sync.WaitGroup
|
|
for w := 0; w < workers; w++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
local := make([]int64, 0, perWorker)
|
|
for i := 0; i < perWorker; i++ {
|
|
local = append(local, s.NextID())
|
|
}
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
for _, id := range local {
|
|
if _, dup := seen[id]; dup {
|
|
t.Errorf("ID 冲突: %d", id)
|
|
return
|
|
}
|
|
seen[id] = struct{}{}
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
if len(seen) != workers*perWorker {
|
|
t.Errorf("唯一 ID 数 = %d, 期望 %d", len(seen), workers*perWorker)
|
|
}
|
|
}
|
|
|
|
// TestSnowflake_MultiInstanceDistinct 同毫秒下不同 WorkerID 的 ID 互不相同。
|
|
func TestSnowflake_MultiInstanceDistinct(t *testing.T) {
|
|
s1, _ := NewSnowflake(1)
|
|
s2, _ := NewSnowflake(2)
|
|
set := make(map[int64]struct{})
|
|
for i := 0; i < 1000; i++ {
|
|
set[s1.NextID()] = struct{}{}
|
|
set[s2.NextID()] = struct{}{}
|
|
}
|
|
if len(set) != 2000 {
|
|
t.Errorf("跨实例 ID 冲突: 唯一数 %d, 期望 2000", len(set))
|
|
}
|
|
}
|
|
|
|
// TestSnowflake_WorkIDGetter 验证 WorkerID 读取方法。
|
|
func TestSnowflake_WorkIDGetter(t *testing.T) {
|
|
s, _ := NewSnowflake(42)
|
|
if s.WorkerID() != 42 {
|
|
t.Errorf("WorkerID() = %d, 期望 42", s.WorkerID())
|
|
}
|
|
if _, wid, _ := DecomposeID(s.NextID()); wid != 42 {
|
|
t.Errorf("DecomposeID worker 段 = %d, 期望 42", wid)
|
|
}
|
|
}
|
|
|
|
// TestSnowflake_SequenceExhausted 白盒触发同毫秒序列耗尽:等待下一毫秒继续。
|
|
func TestSnowflake_SequenceExhausted(t *testing.T) {
|
|
s, _ := NewSnowflake(7)
|
|
s.mu.Lock()
|
|
s.lastTS = nowMillis() - Epoch // 锁定在当前毫秒
|
|
s.seq = maxSequence // 序列即将耗尽
|
|
s.mu.Unlock()
|
|
|
|
if _, _, seq := DecomposeID(s.NextID()); seq > maxSequence {
|
|
t.Fatalf("耗尽后序列非法: %d", seq)
|
|
}
|
|
if _, _, seq := DecomposeID(s.NextID()); seq > maxSequence {
|
|
t.Fatalf("序列越界: %d", seq)
|
|
}
|
|
}
|
|
|
|
// TestSnowflake_ClockBackward 白盒触发时钟回拨:NextID 等待追平后正常生成。
|
|
func TestSnowflake_ClockBackward(t *testing.T) {
|
|
s, _ := NewSnowflake(9)
|
|
s.mu.Lock()
|
|
s.lastTS = nowMillis() - Epoch + 80 // 人为领先 80ms 模拟回拨
|
|
s.mu.Unlock()
|
|
|
|
done := make(chan int64, 1)
|
|
go func() { done <- s.NextID() }()
|
|
select {
|
|
case id := <-done:
|
|
if id <= 0 {
|
|
t.Fatalf("回拨追平后 ID 非法: %d", id)
|
|
}
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("时钟回拨自旋等待超时")
|
|
}
|
|
}
|