s_cherry_e/sr/internal/extend/cache/paging_test.go

package cache

import (
	"math/rand"
	"testing"
	"time"
)

// 类型枚举
const (
	TypeWeapon = "武器"
	TypeHelmet = "头盔"
	TypeArmor  = "护甲"
	TypeBoots  = "战靴"
)

// 品质枚举
const (
	QualityExclusive = "专属"
	QualityLegendary = "传说"
	QualityEpic      = "史诗"
	QualityRare      = "稀有"
)

// 兵种枚举
const (
	ArmyInfantry = "步兵"
	ArmyCavalry  = "骑兵"
	ArmyArcher   = "弓兵"
)

// 附加属性枚举
const (
	Attr0 = 0
	Attr1 = 1
	Attr2 = 2
	Attr3 = 3
)

// 测试用结构体
type TestItem struct {
	ID         int64
	Name       string
	Type       string
	Quality    string
	Army       string
	Attr       int
	Quantity   int
	Price      float64
	CreateTime int64
}

func TestPaging(t *testing.T) {
	// 创建Paging实例
	paging := NewPaging[TestItem]()

	// 初始化随机数生成器
	rand.Seed(time.Now().UnixNano())

	// 类型列表
	types := []string{TypeWeapon, TypeHelmet, TypeArmor, TypeBoots}
	// 品质列表
	qualities := []string{QualityExclusive, QualityLegendary, QualityEpic, QualityRare}
	// 兵种列表
	armies := []string{ArmyInfantry, ArmyCavalry, ArmyArcher}
	// 附加属性列表
	attrs := []int{Attr0, Attr1, Attr2, Attr3}

	// 生成100条测试数据
	testData := make([]TestItem, 0, 100)
	for i := 0; i < 100; i++ {
		item := TestItem{
			ID:         int64(i + 1),
			Name:       "装备" + string(rune(i+65)), // A-Z
			Type:       types[rand.Intn(len(types))],
			Quality:    qualities[rand.Intn(len(qualities))],
			Army:       armies[rand.Intn(len(armies))],
			Attr:       attrs[rand.Intn(len(attrs))],
			Quantity:   rand.Intn(100) + 1,
			Price:      rand.Float64() * 10000,
			CreateTime: time.Now().UnixNano() - int64(rand.Intn(1000000000000)), // 随机创建时间，范围在最近1000秒内
		}
		testData = append(testData, item)
	}

	paging.AddAll(testData)

	// 过滤条件
	filterFunc := func(item TestItem) bool {
		// 类型 = 头盔、护甲
		typeOk := item.Type == TypeHelmet || item.Type == TypeArmor
		// 品质 = 专属、传说、史诗
		qualityOk := item.Quality == QualityExclusive || item.Quality == QualityLegendary || item.Quality == QualityEpic
		// 兵种 = 所有
		armyOk := true
		// 附加属性 = 1、2
		attrOk := item.Attr == Attr1 || item.Attr == Attr2
		// 所有条件都必须满足（并且）
		return typeOk && qualityOk && armyOk && attrOk
	}

	// 排序条件：创建时间降序，价格升序
	comparatorFunc := func(a, b TestItem) int {
		// 1. 创建时间降序
		if a.CreateTime > b.CreateTime {
			return -1
		}
		if a.CreateTime < b.CreateTime {
			return 1
		}
		// 2. 价格升序
		if a.Price < b.Price {
			return -1
		}
		if a.Price > b.Price {
			return 1
		}
		return 0
	}

	// 执行查询
	pageSize := int32(10) // 每页10条
	total, pageData := paging.Query(1, pageSize, filterFunc, comparatorFunc)

	// 输出结果
	t.Logf("符合条件的总数: %d", total)
	t.Logf("第一页数据条数: %d", len(pageData))

	// 验证排序是否正确
	if len(pageData) > 1 {
		for i := 0; i < len(pageData)-1; i++ {
			// 检查创建时间降序
			if pageData[i].CreateTime < pageData[i+1].CreateTime {
				t.Errorf("第%d条的创建时间(%d)小于第%d条的创建时间(%d)，不符合降序要求",
					i+1, pageData[i].CreateTime, i+2, pageData[i+1].CreateTime)
			}
			// 检查价格升序（当创建时间相同时）
			if pageData[i].CreateTime == pageData[i+1].CreateTime && pageData[i].Price > pageData[i+1].Price {
				t.Errorf("第%d条的价格(%.2f)大于第%d条的价格(%.2f)，创建时间相同，不符合升序要求",
					i+1, pageData[i].Price, i+2, pageData[i+1].Price)
			}
		}
	}

	// 验证过滤条件是否正确
	for _, item := range pageData {
		// 类型应该是头盔或护甲
		if item.Type != TypeHelmet && item.Type != TypeArmor {
			t.Errorf("Item %d 类型为 %s，不符合过滤条件", item.ID, item.Type)
		}
		// 品质应该是专属、传说或史诗
		if item.Quality != QualityExclusive && item.Quality != QualityLegendary && item.Quality != QualityEpic {
			t.Errorf("Item %d 品质为 %s，不符合过滤条件", item.ID, item.Quality)
		}
		// 附加属性应该是1或2
		if item.Attr != Attr1 && item.Attr != Attr2 {
			t.Errorf("Item %d 附加属性为 %d，不符合过滤条件", item.ID, item.Attr)
		}
	}

	// 测试第二页
	total, pageData2 := paging.Query(2, pageSize, filterFunc, comparatorFunc)
	t.Logf("第二页数据条数: %d", len(pageData2))

	// 验证分页是否正确（第二页应该不包含第一页的最后一条数据）
	if len(pageData) > 0 && len(pageData2) > 0 {
		lastItemPage1 := pageData[len(pageData)-1]
		firstItemPage2 := pageData2[0]
		// 比较结果：如果lastItemPage1应该排在firstItemPage2前面，返回-1
		// 对于分页来说，这是正确的顺序
		if comparatorFunc(lastItemPage1, firstItemPage2) <= 0 {
			t.Logf("分页正确：第一页最后一条数据应该在第二页第一条数据之前或相等")
		} else {
			t.Errorf("分页错误：第一页最后一条数据应该在第二页第一条数据之前")
		}
	}
}