From 72597f6143ac026a69279b40f013a26834926e43 Mon Sep 17 00:00:00 2001 From: reilly Date: Sat, 30 May 2026 15:43:53 +0800 Subject: [PATCH] perf(test): parallelize bitmap subtests and optimize Set2SetBit with pipeline Part of #2642 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add t.Parallel() to all 34 subtests for concurrent execution - Use util.KeyPrefix(t) for unique key names per subtest - Replace per-bit SETBIT calls with pipelined SETBIT in Set2SetBit (reduces ~8000 RTTs to 1 RTT for 1000-byte vectors) - Replace defer with t.Cleanup() so resources live until subtests finish - Move KeyPrefix helper to dedicated keys.go - Fix duplicate test name "BITPOS BIT not found check check" - Test time: 52s → 11s (~4.7x speedup) Assisted-by: Claude Code:DeepSeek-v4-pro --- tests/gocase/unit/type/bitmap/bitmap_test.go | 469 +++++++++++-------- tests/gocase/util/keys.go | 26 + tests/gocase/util/server.go | 1 - 3 files changed, 312 insertions(+), 184 deletions(-) create mode 100644 tests/gocase/util/keys.go diff --git a/tests/gocase/unit/type/bitmap/bitmap_test.go b/tests/gocase/unit/type/bitmap/bitmap_test.go index 6211ae3c836..7bb489e6eae 100644 --- a/tests/gocase/unit/type/bitmap/bitmap_test.go +++ b/tests/gocase/unit/type/bitmap/bitmap_test.go @@ -50,9 +50,12 @@ func Set2SetBit(t *testing.T, rdb *redis.Client, ctx context.Context, key string for _, v := range bs { _, _ = fmt.Fprintf(buf, "%08b", v) } + pipe := rdb.Pipeline() for index, value := range buf.String() { - require.NoError(t, rdb.SetBit(ctx, key, int64(index), int(value)-int('0')).Err()) + pipe.SetBit(ctx, key, int64(index), int(value)-int('0')) } + _, err := pipe.Exec(ctx) + require.NoError(t, err) } func GetBitmap(t *testing.T, rdb *redis.Client, ctx context.Context, keys ...string) []string { buf := make([]string, 0, len(keys)) @@ -122,280 +125,341 @@ func SimulateBitOp(op BITOP, values ...[]byte) string { func TestBitmap(t *testing.T) { srv := util.StartServer(t, map[string]string{}) - defer srv.Close() + t.Cleanup(func() { srv.Close() }) ctx := context.Background() rdb := srv.NewClient() - defer func() { require.NoError(t, rdb.Close()) }() + t.Cleanup(func() { require.NoError(t, rdb.Close()) }) t.Run("GET bitmap string after setbit", func(t *testing.T) { - require.NoError(t, rdb.SetBit(ctx, "b0", 0, 0).Err()) - require.NoError(t, rdb.SetBit(ctx, "b1", 35, 0).Err()) - Set2SetBit(t, rdb, ctx, "b2", []byte("\xac\x81\x32\x5d\xfe")) - Set2SetBit(t, rdb, ctx, "b3", []byte("\xff\xff\xff\xff")) - require.EqualValues(t, []string{"\x00", "\x00\x00\x00\x00\x00", "\xac\x81\x32\x5d\xfe", "\xff\xff\xff\xff"}, GetBitmap(t, rdb, ctx, "b0", "b1", "b2", "b3")) + t.Parallel() + p := util.KeyPrefix(t) + b0, b1, b2, b3 := p+"b0", p+"b1", p+"b2", p+"b3" + require.NoError(t, rdb.SetBit(ctx, b0, 0, 0).Err()) + require.NoError(t, rdb.SetBit(ctx, b1, 35, 0).Err()) + Set2SetBit(t, rdb, ctx, b2, []byte("\xac\x81\x32\x5d\xfe")) + Set2SetBit(t, rdb, ctx, b3, []byte("\xff\xff\xff\xff")) + require.EqualValues(t, []string{"\x00", "\x00\x00\x00\x00\x00", "\xac\x81\x32\x5d\xfe", "\xff\xff\xff\xff"}, GetBitmap(t, rdb, ctx, b0, b1, b2, b3)) }) t.Run("GET bitmap with out of max size", func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) + k := p + "b0" require.NoError(t, rdb.Do(ctx, "config", "set", "max-bitmap-to-string-mb", 1).Err()) - require.NoError(t, rdb.SetBit(ctx, "b0", 8388609, 0).Err()) - util.ErrorRegexp(t, rdb.Get(ctx, "b0").Err(), "ERR Operation aborted: The size of the bitmap .*") + require.NoError(t, rdb.SetBit(ctx, k, 8388609, 0).Err()) + util.ErrorRegexp(t, rdb.Get(ctx, k).Err(), "ERR Operation aborted: The size of the bitmap .*") }) t.Run("GETEX bitmap no option", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.SetBit(ctx, "foo", 0, 0).Err()) - require.Equal(t, "\x00", rdb.GetEx(ctx, "foo", 0).Val()) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "foo" + require.NoError(t, rdb.Del(ctx, k).Err()) + require.NoError(t, rdb.SetBit(ctx, k, 0, 0).Err()) + require.Equal(t, "\x00", rdb.GetEx(ctx, k, 0).Val()) // Make sure the expiration time is not erased by plain GETEX. - require.NoError(t, rdb.Expire(ctx, "foo", 10*time.Second).Err()) - require.Equal(t, "\x00", rdb.Do(ctx, "getex", "foo").Val()) - util.BetweenValues(t, rdb.TTL(ctx, "foo").Val(), 5*time.Second, 10*time.Second) + require.NoError(t, rdb.Expire(ctx, k, 10*time.Second).Err()) + require.Equal(t, "\x00", rdb.Do(ctx, "getex", k).Val()) + util.BetweenValues(t, rdb.TTL(ctx, k).Val(), 5*time.Second, 10*time.Second) }) t.Run("GETEX bitmap EX/EXAT/PX/PXAT option", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.SetBit(ctx, "foo", 0, 0).Err()) - require.NoError(t, rdb.Do(ctx, "getex", "foo", "ex", 10).Err()) - util.BetweenValues(t, rdb.TTL(ctx, "foo").Val(), 5*time.Second, 10*time.Second) - - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.SetBit(ctx, "foo", 0, 0).Err()) - require.NoError(t, rdb.Do(ctx, "getex", "foo", "exat", time.Now().Add(10*time.Second).Unix()).Err()) - util.BetweenValues(t, rdb.TTL(ctx, "foo").Val(), 5*time.Second, 10*time.Second) - - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.SetBit(ctx, "foo", 0, 0).Err()) - require.NoError(t, rdb.Do(ctx, "getex", "foo", "px", 10*1000).Err()) - util.BetweenValues(t, rdb.TTL(ctx, "foo").Val(), 5*time.Second, 10*time.Second) - - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.SetBit(ctx, "foo", 0, 0).Err()) - require.NoError(t, rdb.Do(ctx, "getex", "foo", "pxat", time.Now().Add(10*time.Second).UnixMilli()).Err()) - util.BetweenValues(t, rdb.TTL(ctx, "foo").Val(), 5*time.Second, 10*time.Second) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "foo" + require.NoError(t, rdb.Del(ctx, k).Err()) + require.NoError(t, rdb.SetBit(ctx, k, 0, 0).Err()) + require.NoError(t, rdb.Do(ctx, "getex", k, "ex", 10).Err()) + util.BetweenValues(t, rdb.TTL(ctx, k).Val(), 5*time.Second, 10*time.Second) + + require.NoError(t, rdb.Del(ctx, k).Err()) + require.NoError(t, rdb.SetBit(ctx, k, 0, 0).Err()) + require.NoError(t, rdb.Do(ctx, "getex", k, "exat", time.Now().Add(10*time.Second).Unix()).Err()) + util.BetweenValues(t, rdb.TTL(ctx, k).Val(), 5*time.Second, 10*time.Second) + + require.NoError(t, rdb.Del(ctx, k).Err()) + require.NoError(t, rdb.SetBit(ctx, k, 0, 0).Err()) + require.NoError(t, rdb.Do(ctx, "getex", k, "px", 10*1000).Err()) + util.BetweenValues(t, rdb.TTL(ctx, k).Val(), 5*time.Second, 10*time.Second) + + require.NoError(t, rdb.Del(ctx, k).Err()) + require.NoError(t, rdb.SetBit(ctx, k, 0, 0).Err()) + require.NoError(t, rdb.Do(ctx, "getex", k, "pxat", time.Now().Add(10*time.Second).UnixMilli()).Err()) + util.BetweenValues(t, rdb.TTL(ctx, k).Val(), 5*time.Second, 10*time.Second) }) t.Run("GETEX bitmap PERSIST option", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.SetBit(ctx, "foo", 0, 0).Err()) - require.EqualValues(t, -1, rdb.TTL(ctx, "foo").Val()) - require.NoError(t, rdb.Do(ctx, "getex", "foo", "persist").Err()) - require.EqualValues(t, -1, rdb.TTL(ctx, "foo").Val()) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "foo" + require.NoError(t, rdb.Del(ctx, k).Err()) + require.NoError(t, rdb.SetBit(ctx, k, 0, 0).Err()) + require.EqualValues(t, -1, rdb.TTL(ctx, k).Val()) + require.NoError(t, rdb.Do(ctx, "getex", k, "persist").Err()) + require.EqualValues(t, -1, rdb.TTL(ctx, k).Val()) - require.NoError(t, rdb.Expire(ctx, "foo", 10*time.Second).Err()) - util.BetweenValues(t, rdb.TTL(ctx, "foo").Val(), 5*time.Second, 10*time.Second) - require.NoError(t, rdb.Do(ctx, "getex", "foo", "persist").Err()) - require.EqualValues(t, -1, rdb.TTL(ctx, "foo").Val()) + require.NoError(t, rdb.Expire(ctx, k, 10*time.Second).Err()) + util.BetweenValues(t, rdb.TTL(ctx, k).Val(), 5*time.Second, 10*time.Second) + require.NoError(t, rdb.Do(ctx, "getex", k, "persist").Err()) + require.EqualValues(t, -1, rdb.TTL(ctx, k).Val()) }) t.Run("SETBIT/GETBIT/BITCOUNT/BITPOS boundary check (type bitmap)", func(t *testing.T) { - cmd := rdb.Del(ctx, "b0") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "b0" + cmd := rdb.Del(ctx, k) require.NoError(t, cmd.Err()) var maxOffset int64 = math.MaxUint32 - cmd = rdb.SetBit(ctx, "b0", maxOffset+1, 1) + cmd = rdb.SetBit(ctx, k, maxOffset+1, 1) util.ErrorRegexp(t, cmd.Err(), ".*out of range.*") - cmd = rdb.SetBit(ctx, "b0", maxOffset, 1) + cmd = rdb.SetBit(ctx, k, maxOffset, 1) require.NoError(t, cmd.Err()) - cmd = rdb.GetBit(ctx, "b0", maxOffset) + cmd = rdb.GetBit(ctx, k, maxOffset) require.NoError(t, cmd.Err()) require.EqualValues(t, 1, cmd.Val()) - cmd = rdb.BitCount(ctx, "b0", &redis.BitCount{Start: 0, End: maxOffset / 8}) + cmd = rdb.BitCount(ctx, k, &redis.BitCount{Start: 0, End: maxOffset / 8}) require.NoError(t, cmd.Err()) require.EqualValues(t, 1, cmd.Val()) - cmd = rdb.BitPos(ctx, "b0", 1) + cmd = rdb.BitPos(ctx, k, 1) require.NoError(t, cmd.Err()) require.EqualValues(t, maxOffset, cmd.Val()) }) t.Run("BITCOUNT BIT/BYTE option check(type bitmap bitmap_string)", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "foo").Err()) - require.NoError(t, rdb.Do(ctx, "SET", "foo", "hello").Err()) - cmd := rdb.Do(ctx, "BITCOUNT", "foo", 0, -1, "BIT") + t.Parallel() + p := util.KeyPrefix(t) + foo, bar := p+"foo", p+"bar" + require.NoError(t, rdb.Del(ctx, foo).Err()) + require.NoError(t, rdb.Do(ctx, "SET", foo, "hello").Err()) + cmd := rdb.Do(ctx, "BITCOUNT", foo, 0, -1, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 21, cmd.Val()) - require.NoError(t, rdb.Do(ctx, "SETBIT", "foo", 1024*8+2, 1).Err()) - require.NoError(t, rdb.Do(ctx, "SETBIT", "foo", 2*1024*8+1, 1).Err()) - cmd = rdb.Do(ctx, "BITCOUNT", "foo", 0, -1, "BIT") + require.NoError(t, rdb.Do(ctx, "SETBIT", foo, 1024*8+2, 1).Err()) + require.NoError(t, rdb.Do(ctx, "SETBIT", foo, 2*1024*8+1, 1).Err()) + cmd = rdb.Do(ctx, "BITCOUNT", foo, 0, -1, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 23, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "foo", 0, 1024*8+2, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", foo, 0, 1024*8+2, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 22, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "foo", 40, 1024*8+2, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", foo, 40, 1024*8+2, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 1, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "foo", 0, 0, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", foo, 0, 0, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 0, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "foo", 1024*8+2, 2*1024*8+1, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", foo, 1024*8+2, 2*1024*8+1, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 2, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "foo", -1, -1, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", foo, -1, -1, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 0, cmd.Val()) - require.NoError(t, rdb.Del(ctx, "foo").Err()) + require.NoError(t, rdb.Del(ctx, foo).Err()) - require.NoError(t, rdb.Del(ctx, "bar").Err()) - require.NoError(t, rdb.Do(ctx, "SETBIT", "bar", 0, 1).Err()) - require.NoError(t, rdb.Do(ctx, "SETBIT", "bar", 100, 1).Err()) - require.NoError(t, rdb.Do(ctx, "SETBIT", "bar", 1024*8+2, 1).Err()) - require.NoError(t, rdb.Do(ctx, "SETBIT", "bar", 2*1024*8+1, 1).Err()) - cmd = rdb.Do(ctx, "BITCOUNT", "bar", 0, 0, "BIT") + require.NoError(t, rdb.Del(ctx, bar).Err()) + require.NoError(t, rdb.Do(ctx, "SETBIT", bar, 0, 1).Err()) + require.NoError(t, rdb.Do(ctx, "SETBIT", bar, 100, 1).Err()) + require.NoError(t, rdb.Do(ctx, "SETBIT", bar, 1024*8+2, 1).Err()) + require.NoError(t, rdb.Do(ctx, "SETBIT", bar, 2*1024*8+1, 1).Err()) + cmd = rdb.Do(ctx, "BITCOUNT", bar, 0, 0, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 1, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "bar", 0, 100, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", bar, 0, 100, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 2, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "bar", 100, 1024*8+2, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", bar, 100, 1024*8+2, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 2, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "bar", 1024*8+2, 2*1024*8+2, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", bar, 1024*8+2, 2*1024*8+2, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 2, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "bar", 0, -1, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", bar, 0, -1, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 4, cmd.Val()) - cmd = rdb.Do(ctx, "BITCOUNT", "bar", -1, -1, "BIT") + cmd = rdb.Do(ctx, "BITCOUNT", bar, -1, -1, "BIT") require.NoError(t, cmd.Err()) require.EqualValues(t, 0, cmd.Val()) - require.NoError(t, rdb.Del(ctx, "bar").Err()) + require.NoError(t, rdb.Del(ctx, bar).Err()) }) t.Run("BITOP NOT (known string)", func(t *testing.T) { - Set2SetBit(t, rdb, ctx, "s", []byte("\xaa\x00\xff\x55")) - require.NoError(t, rdb.BitOpNot(ctx, "dest", "s").Err()) - require.EqualValues(t, []string{"\x55\xff\x00\xaa"}, GetBitmap(t, rdb, ctx, "dest")) + t.Parallel() + p := util.KeyPrefix(t) + s, dest := p+"s", p+"dest" + Set2SetBit(t, rdb, ctx, s, []byte("\xaa\x00\xff\x55")) + require.NoError(t, rdb.BitOpNot(ctx, dest, s).Err()) + require.EqualValues(t, []string{"\x55\xff\x00\xaa"}, GetBitmap(t, rdb, ctx, dest)) }) t.Run("BITOP where dest and target are the same key", func(t *testing.T) { - Set2SetBit(t, rdb, ctx, "s", []byte("\xaa\x00\xff\x55")) - require.NoError(t, rdb.BitOpNot(ctx, "s", "s").Err()) - require.EqualValues(t, []string{"\x55\xff\x00\xaa"}, GetBitmap(t, rdb, ctx, "s")) + t.Parallel() + p := util.KeyPrefix(t) + s := p + "s" + Set2SetBit(t, rdb, ctx, s, []byte("\xaa\x00\xff\x55")) + require.NoError(t, rdb.BitOpNot(ctx, s, s).Err()) + require.EqualValues(t, []string{"\x55\xff\x00\xaa"}, GetBitmap(t, rdb, ctx, s)) }) t.Run("BITOP AND|OR|XOR don't change the string with single input key", func(t *testing.T) { - Set2SetBit(t, rdb, ctx, "a", []byte("\x01\x02\xff")) - require.NoError(t, rdb.BitOpAnd(ctx, "res1", "a").Err()) - require.NoError(t, rdb.BitOpOr(ctx, "res2", "a").Err()) - require.NoError(t, rdb.BitOpXor(ctx, "res3", "a").Err()) - require.EqualValues(t, []string{"\x01\x02\xff", "\x01\x02\xff", "\x01\x02\xff"}, GetBitmap(t, rdb, ctx, "res1", "res2", "res3")) + t.Parallel() + p := util.KeyPrefix(t) + a, res1, res2, res3 := p+"a", p+"res1", p+"res2", p+"res3" + Set2SetBit(t, rdb, ctx, a, []byte("\x01\x02\xff")) + require.NoError(t, rdb.BitOpAnd(ctx, res1, a).Err()) + require.NoError(t, rdb.BitOpOr(ctx, res2, a).Err()) + require.NoError(t, rdb.BitOpXor(ctx, res3, a).Err()) + require.EqualValues(t, []string{"\x01\x02\xff", "\x01\x02\xff", "\x01\x02\xff"}, GetBitmap(t, rdb, ctx, res1, res2, res3)) }) t.Run("BITOP missing key is considered a stream of zero", func(t *testing.T) { - Set2SetBit(t, rdb, ctx, "a", []byte("\x01\x02\xff")) - require.NoError(t, rdb.BitOpAnd(ctx, "res1", "no-suck-key", "a").Err()) - require.NoError(t, rdb.BitOpOr(ctx, "res2", "no-suck-key", "a", "no-suck-key").Err()) - require.NoError(t, rdb.BitOpXor(ctx, "res3", "no-suck-key", "a").Err()) - require.EqualValues(t, []string{"\x00\x00\x00", "\x01\x02\xff", "\x01\x02\xff"}, GetBitmap(t, rdb, ctx, "res1", "res2", "res3")) + t.Parallel() + p := util.KeyPrefix(t) + a, res1, res2, res3 := p+"a", p+"res1", p+"res2", p+"res3" + missing := p + "no-suck-key" + Set2SetBit(t, rdb, ctx, a, []byte("\x01\x02\xff")) + require.NoError(t, rdb.BitOpAnd(ctx, res1, missing, a).Err()) + require.NoError(t, rdb.BitOpOr(ctx, res2, missing, a, missing).Err()) + require.NoError(t, rdb.BitOpXor(ctx, res3, missing, a).Err()) + require.EqualValues(t, []string{"\x00\x00\x00", "\x01\x02\xff", "\x01\x02\xff"}, GetBitmap(t, rdb, ctx, res1, res2, res3)) }) t.Run("BITOP shorter keys are zero-padded to the key with max length", func(t *testing.T) { - Set2SetBit(t, rdb, ctx, "a", []byte("\x01\x02\xff\xff")) - Set2SetBit(t, rdb, ctx, "b", []byte("\x01\x02\xff")) - require.NoError(t, rdb.BitOpAnd(ctx, "res1", "a", "b").Err()) - require.NoError(t, rdb.BitOpOr(ctx, "res2", "a", "b").Err()) - require.NoError(t, rdb.BitOpXor(ctx, "res3", "a", "b").Err()) - require.EqualValues(t, []string{"\x01\x02\xff\x00", "\x01\x02\xff\xff", "\x00\x00\x00\xff"}, GetBitmap(t, rdb, ctx, "res1", "res2", "res3")) + t.Parallel() + p := util.KeyPrefix(t) + a, b, res1, res2, res3 := p+"a", p+"b", p+"res1", p+"res2", p+"res3" + Set2SetBit(t, rdb, ctx, a, []byte("\x01\x02\xff\xff")) + Set2SetBit(t, rdb, ctx, b, []byte("\x01\x02\xff")) + require.NoError(t, rdb.BitOpAnd(ctx, res1, a, b).Err()) + require.NoError(t, rdb.BitOpOr(ctx, res2, a, b).Err()) + require.NoError(t, rdb.BitOpXor(ctx, res3, a, b).Err()) + require.EqualValues(t, []string{"\x01\x02\xff\x00", "\x01\x02\xff\xff", "\x00\x00\x00\xff"}, GetBitmap(t, rdb, ctx, res1, res2, res3)) }) for _, op := range []BITOP{AND, OR, XOR} { t.Run("BITOP fuzzing "+strconv.Itoa(int(op)), func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) for i := 0; i < 10; i++ { - require.NoError(t, rdb.FlushAll(ctx).Err()) numVec := util.RandomInt(10) + 1 var vec [][]byte var veckeys []string for j := 0; j < int(numVec); j++ { str := util.RandString(0, 1000, util.Binary) vec = append(vec, []byte(str)) - veckeys = append(veckeys, "vector_"+strconv.Itoa(j)) - Set2SetBit(t, rdb, ctx, "vector_"+strconv.Itoa(j), []byte(str)) + key := p + "vector_" + strconv.Itoa(j) + "_" + strconv.Itoa(i) + veckeys = append(veckeys, key) + Set2SetBit(t, rdb, ctx, key, []byte(str)) } + target := p + "target_" + strconv.Itoa(i) switch op { case AND: - require.NoError(t, rdb.BitOpAnd(ctx, "target", veckeys...).Err()) - require.EqualValues(t, SimulateBitOp(AND, vec...), rdb.Get(ctx, "target").Val()) + require.NoError(t, rdb.BitOpAnd(ctx, target, veckeys...).Err()) + require.EqualValues(t, SimulateBitOp(AND, vec...), rdb.Get(ctx, target).Val()) case OR: - require.NoError(t, rdb.BitOpOr(ctx, "target", veckeys...).Err()) - require.EqualValues(t, SimulateBitOp(OR, vec...), rdb.Get(ctx, "target").Val()) + require.NoError(t, rdb.BitOpOr(ctx, target, veckeys...).Err()) + require.EqualValues(t, SimulateBitOp(OR, vec...), rdb.Get(ctx, target).Val()) case XOR: - require.NoError(t, rdb.BitOpXor(ctx, "target", veckeys...).Err()) - require.EqualValues(t, SimulateBitOp(XOR, vec...), rdb.Get(ctx, "target").Val()) + require.NoError(t, rdb.BitOpXor(ctx, target, veckeys...).Err()) + require.EqualValues(t, SimulateBitOp(XOR, vec...), rdb.Get(ctx, target).Val()) } - } }) } t.Run("BITOP NOT fuzzing", func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) for i := 0; i < 10; i++ { - require.NoError(t, rdb.Del(ctx, "str").Err()) + s := p + "str_" + strconv.Itoa(i) + target := p + "target_" + strconv.Itoa(i) str := util.RandString(0, 1000, util.Binary) - Set2SetBit(t, rdb, ctx, "str", []byte(str)) - require.NoError(t, rdb.BitOpNot(ctx, "target", "str").Err()) - require.EqualValues(t, SimulateBitOp(NOT, []byte(str)), rdb.Get(ctx, "target").Val()) + Set2SetBit(t, rdb, ctx, s, []byte(str)) + require.NoError(t, rdb.BitOpNot(ctx, target, s).Err()) + require.EqualValues(t, SimulateBitOp(NOT, []byte(str)), rdb.Get(ctx, target).Val()) } }) t.Run("BITOP Boundary Check", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "str").Err()) + t.Parallel() + p := util.KeyPrefix(t) + s, target := p+"str", p+"target" str := util.RandStringWithSeed(0, 1000, util.Binary, 2701) - Set2SetBit(t, rdb, ctx, "str", []byte(str)) - require.NoError(t, rdb.BitOpNot(ctx, "target", "str").Err()) - require.EqualValues(t, SimulateBitOp(NOT, []byte(str)), rdb.Get(ctx, "target").Val()) + Set2SetBit(t, rdb, ctx, s, []byte(str)) + require.NoError(t, rdb.BitOpNot(ctx, target, s).Err()) + require.EqualValues(t, SimulateBitOp(NOT, []byte(str)), rdb.Get(ctx, target).Val()) }) t.Run("BITOP with non string source key", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "c").Err()) - Set2SetBit(t, rdb, ctx, "a", []byte("\xaa\x00\xff\x55")) - Set2SetBit(t, rdb, ctx, "b", []byte("\xaa\x00\xff\x55")) - require.NoError(t, rdb.LPush(ctx, "c", "foo").Err()) - util.ErrorRegexp(t, rdb.BitOpXor(ctx, "dest", "a", "b", "c", "d").Err(), ".*WRONGTYPE.*") + t.Parallel() + p := util.KeyPrefix(t) + a, b, c, dest, d := p+"a", p+"b", p+"c", p+"dest", p+"d" + require.NoError(t, rdb.Del(ctx, c).Err()) + Set2SetBit(t, rdb, ctx, a, []byte("\xaa\x00\xff\x55")) + Set2SetBit(t, rdb, ctx, b, []byte("\xaa\x00\xff\x55")) + require.NoError(t, rdb.LPush(ctx, c, "foo").Err()) + util.ErrorRegexp(t, rdb.BitOpXor(ctx, dest, a, b, c, d).Err(), ".*WRONGTYPE.*") }) t.Run("BITOP with empty string after non empty string (Redis issue #529)", func(t *testing.T) { - require.NoError(t, rdb.FlushDB(ctx).Err()) - Set2SetBit(t, rdb, ctx, "a", []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")) - require.EqualValues(t, 32, rdb.BitOpOr(ctx, "x", "a", "b").Val()) + t.Parallel() + p := util.KeyPrefix(t) + a, b, x := p+"a", p+"b", p+"x" + Set2SetBit(t, rdb, ctx, a, []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")) + require.EqualValues(t, 32, rdb.BitOpOr(ctx, x, a, b).Val()) }) t.Run("BITFIELD and BITFIELD_RO on string type", func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" str := "zhe ge ren hen lan, shen me dou mei you liu xia." - require.NoError(t, rdb.Set(ctx, "str", str, 0).Err()) + require.NoError(t, rdb.Set(ctx, k, str, 0).Err()) for _, command := range []string{"BITFIELD", "BITFIELD_RO"} { - res := rdb.Do(ctx, command, "str", "GET", "u8", "32", "GET", "u8", "40") + res := rdb.Do(ctx, command, k, "GET", "u8", "32", "GET", "u8", "40") require.NoError(t, res.Err()) require.EqualValues(t, []interface{}{int64(str[4]), int64(str[5])}, res.Val()) } - res := rdb.BitField(ctx, "str", "GET", "u8", "32", "SET", "u8", "32", 'r', "GET", "u8", "32") + res := rdb.BitField(ctx, k, "GET", "u8", "32", "SET", "u8", "32", 'r', "GET", "u8", "32") require.NoError(t, res.Err()) require.EqualValues(t, str[4], res.Val()[0]) require.EqualValues(t, str[4], res.Val()[1]) require.EqualValues(t, 'r', res.Val()[2]) - require.ErrorContains(t, rdb.Do(ctx, "BITFIELD_RO", "str", "GET", "u8", "32", "SET", "u8", "32", 'r', "GET", "u8", "32").Err(), "BITFIELD_RO only supports the GET subcommand") + require.ErrorContains(t, rdb.Do(ctx, "BITFIELD_RO", k, "GET", "u8", "32", "SET", "u8", "32", 'r', "GET", "u8", "32").Err(), "BITFIELD_RO only supports the GET subcommand") - res = rdb.BitField(ctx, "str", "INCRBY", "u8", "32", 2) + res = rdb.BitField(ctx, k, "INCRBY", "u8", "32", 2) require.NoError(t, res.Err()) require.EqualValues(t, 't', res.Val()[0]) - require.ErrorContains(t, rdb.Do(ctx, "BITFIELD_RO", "str", "INCRBY", "u8", "32", 2).Err(), "BITFIELD_RO only supports the GET subcommand") + require.ErrorContains(t, rdb.Do(ctx, "BITFIELD_RO", k, "INCRBY", "u8", "32", 2).Err(), "BITFIELD_RO only supports the GET subcommand") }) t.Run("BITPOS BIT option check", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "mykey", "\x00\xff\xf0", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "mykey", 1, 7, 15, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "mykey" + require.NoError(t, rdb.Set(ctx, k, "\x00\xff\xf0", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 1, 7, 15, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 8, cmd.Val()) }) - t.Run("BITPOS BIT not found check check", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "mykey", "\x00\xff\xf0", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "mykey", 0, 0, 5, "bit") + t.Run("BITPOS BIT not found check", func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) + k := p + "mykey" + require.NoError(t, rdb.Set(ctx, k, "\x00\xff\xf0", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 0, 5, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 0, cmd.Val()) }) - t.Run("BITPOS BIT not found check check", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "mykey", "\x00\xff\xf0", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "mykey", 0, 2, 3, "bit") + t.Run("BITPOS BIT not found check 2", func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) + k := p + "mykey" + require.NoError(t, rdb.Set(ctx, k, "\x00\xff\xf0", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 2, 3, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 2, cmd.Val()) }) @@ -403,54 +467,72 @@ func TestBitmap(t *testing.T) { /* Test cases adapted from redis test cases : https://github.com/redis/redis/blob/unstable/tests/unit/bitops.tcl */ t.Run("BITPOS bit=0 with empty key returns 0", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "str").Err()) - cmd := rdb.BitPosSpan(ctx, "str", 0, 0, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Del(ctx, k).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 0, cmd.Val()) }) t.Run("BITPOS bit=0 with string less than 1 word works", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\xff\xf0\x00", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 0, 0, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\xff\xf0\x00", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 12, cmd.Val()) }) t.Run("BITPOS bit=1 with string less than 1 word works", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\x00\x0f\x00", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 1, 0, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\x00\x0f\x00", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 1, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 12, cmd.Val()) }) t.Run("BITPOS bit=0 starting at unaligned address", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\xff\xf0\x00", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 0, 1, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\xff\xf0\x00", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 1, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 12, cmd.Val()) }) t.Run("BITPOS bit=1 starting at unaligned address", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\x00\x0f\xff", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 1, 1, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\x00\x0f\xff", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 1, 1, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 12, cmd.Val()) }) t.Run("BITPOS bit=0 unaligned+full word+reminder", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\xff\xff\xff", 0).Err()) - require.NoError(t, rdb.Append(ctx, "str", "\xff\xff\xff\xff\xff\xff\xff\xff").Err()) - require.NoError(t, rdb.Append(ctx, "str", "\xff\xff\xff\xff\xff\xff\xff\xff").Err()) - require.NoError(t, rdb.Append(ctx, "str", "\xff\xff\xff\xff\xff\xff\xff\xff").Err()) - require.NoError(t, rdb.Append(ctx, "str", "\x0f").Err()) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\xff\xff\xff", 0).Err()) + require.NoError(t, rdb.Append(ctx, k, "\xff\xff\xff\xff\xff\xff\xff\xff").Err()) + require.NoError(t, rdb.Append(ctx, k, "\xff\xff\xff\xff\xff\xff\xff\xff").Err()) + require.NoError(t, rdb.Append(ctx, k, "\xff\xff\xff\xff\xff\xff\xff\xff").Err()) + require.NoError(t, rdb.Append(ctx, k, "\x0f").Err()) // Test values 1, 9, 17, 25, 33, 41, 49, 57, 65 for i := 0; i < 9; i++ { if i == 6 { - cmd := rdb.BitPosSpan(ctx, "str", 0, 41, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 0, 41, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 216, cmd.Val()) } else { - cmd := rdb.BitPosSpan(ctx, "str", 0, int64(i*8)+1, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 0, int64(i*8)+1, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 216, cmd.Val()) } @@ -458,19 +540,22 @@ func TestBitmap(t *testing.T) { }) t.Run("BITPOS bit=1 unaligned+full word+reminder", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\x00\x00\x00", 0).Err()) - require.NoError(t, rdb.Append(ctx, "str", "\x00\x00\x00\x00\x00\x00\x00\x00").Err()) - require.NoError(t, rdb.Append(ctx, "str", "\x00\x00\x00\x00\x00\x00\x00\x00").Err()) - require.NoError(t, rdb.Append(ctx, "str", "\x00\x00\x00\x00\x00\x00\x00\x00").Err()) - require.NoError(t, rdb.Append(ctx, "str", "\xf0").Err()) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\x00\x00\x00", 0).Err()) + require.NoError(t, rdb.Append(ctx, k, "\x00\x00\x00\x00\x00\x00\x00\x00").Err()) + require.NoError(t, rdb.Append(ctx, k, "\x00\x00\x00\x00\x00\x00\x00\x00").Err()) + require.NoError(t, rdb.Append(ctx, k, "\x00\x00\x00\x00\x00\x00\x00\x00").Err()) + require.NoError(t, rdb.Append(ctx, k, "\xf0").Err()) // Test values 1, 9, 17, 25, 33, 41, 49, 57, 65 for i := 0; i < 9; i++ { if i == 6 { - cmd := rdb.BitPosSpan(ctx, "str", 1, 41, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 1, 41, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 216, cmd.Val()) } else { - cmd := rdb.BitPosSpan(ctx, "str", 1, int64(i*8)+1, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 1, int64(i*8)+1, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 216, cmd.Val()) } @@ -478,70 +563,85 @@ func TestBitmap(t *testing.T) { }) t.Run("BITPOS bit=1 returns -1 if string is all 0 bits", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "", 0).Err()) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "", 0).Err()) for i := 0; i < 20; i++ { - cmd := rdb.BitPosSpan(ctx, "str", 1, 0, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 1, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, -1, cmd.Val()) - require.NoError(t, rdb.Append(ctx, "str", "\x00").Err()) + require.NoError(t, rdb.Append(ctx, k, "\x00").Err()) } }) t.Run("BITPOS bit=0 works with intervals", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\x00\xff\x00", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 0, 0, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\x00\xff\x00", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 0, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 0, 8, -1, "bit") + cmd = rdb.BitPosSpan(ctx, k, 0, 8, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 16, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 0, 16, -1, "bit") + cmd = rdb.BitPosSpan(ctx, k, 0, 16, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 16, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 0, 16, 200, "bit") + cmd = rdb.BitPosSpan(ctx, k, 0, 16, 200, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 16, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 0, 8, 8, "bit") + cmd = rdb.BitPosSpan(ctx, k, 0, 8, 8, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, -1, cmd.Val()) }) t.Run("BITPOS bit=1 works with intervals", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\x00\xff\x00", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 1, 0, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\x00\xff\x00", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 1, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 8, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 1, 8, -1, "bit") + cmd = rdb.BitPosSpan(ctx, k, 1, 8, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 8, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 1, 16, -1, "bit") + cmd = rdb.BitPosSpan(ctx, k, 1, 16, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, -1, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 1, 16, 200, "bit") + cmd = rdb.BitPosSpan(ctx, k, 1, 16, 200, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, -1, cmd.Val()) - cmd = rdb.BitPosSpan(ctx, "str", 1, 8, 8, "bit") + cmd = rdb.BitPosSpan(ctx, k, 1, 8, 8, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, 8, cmd.Val()) }) t.Run("BITPOS bit=0 changes behavior if end is given", func(t *testing.T) { - require.NoError(t, rdb.Set(ctx, "str", "\xff\xff\xff", 0).Err()) - cmd := rdb.BitPosSpan(ctx, "str", 0, 0, -1, "bit") + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Set(ctx, k, "\xff\xff\xff", 0).Err()) + cmd := rdb.BitPosSpan(ctx, k, 0, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, -1, cmd.Val()) }) t.Run("BITPOS bit=1 fuzzy testing using SETBIT", func(t *testing.T) { - require.NoError(t, rdb.Del(ctx, "str").Err()) + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" + require.NoError(t, rdb.Del(ctx, k).Err()) var maxInt int64 = 524288 var firstOnePos int64 = -1 for j := 0; j < 1000; j++ { - cmd := rdb.BitPosSpan(ctx, "str", 1, 0, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 1, 0, -1, "bit") require.NoError(t, cmd.Err()) require.EqualValues(t, firstOnePos, cmd.Val()) pos := util.RandomInt(maxInt) - require.NoError(t, rdb.SetBit(ctx, "str", int64(pos), 1).Err()) + require.NoError(t, rdb.SetBit(ctx, k, int64(pos), 1).Err()) if firstOnePos == -1 || firstOnePos > pos { firstOnePos = pos } @@ -549,11 +649,14 @@ func TestBitmap(t *testing.T) { }) t.Run("BITPOS bit=0 fuzzy testing using SETBIT", func(t *testing.T) { + t.Parallel() + p := util.KeyPrefix(t) + k := p + "str" var maxInt int64 = 524288 firstZeroPos := maxInt - require.NoError(t, rdb.Set(ctx, "str", strings.Repeat("\xff", int(maxInt/8)), 0).Err()) + require.NoError(t, rdb.Set(ctx, k, strings.Repeat("\xff", int(maxInt/8)), 0).Err()) for j := 0; j < 1000; j++ { - cmd := rdb.BitPosSpan(ctx, "str", 0, 0, -1, "bit") + cmd := rdb.BitPosSpan(ctx, k, 0, 0, -1, "bit") require.NoError(t, cmd.Err()) if firstZeroPos == maxInt { require.EqualValues(t, -1, cmd.Val()) @@ -561,7 +664,7 @@ func TestBitmap(t *testing.T) { require.EqualValues(t, firstZeroPos, cmd.Val()) } pos := util.RandomInt(maxInt) - require.NoError(t, rdb.SetBit(ctx, "str", int64(pos), 0).Err()) + require.NoError(t, rdb.SetBit(ctx, k, int64(pos), 0).Err()) if firstZeroPos > pos { firstZeroPos = pos } diff --git a/tests/gocase/util/keys.go b/tests/gocase/util/keys.go new file mode 100644 index 00000000000..200949c69a9 --- /dev/null +++ b/tests/gocase/util/keys.go @@ -0,0 +1,26 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package util + +import "testing" + +func KeyPrefix(t testing.TB) string { + return t.Name() + "_" +} diff --git a/tests/gocase/util/server.go b/tests/gocase/util/server.go index ea8ee474264..9835748d502 100644 --- a/tests/gocase/util/server.go +++ b/tests/gocase/util/server.go @@ -292,7 +292,6 @@ func StartServerWithCLIOptions( }, } } - func findFreePort() (*net.TCPAddr, error) { addr, err := net.ResolveTCPAddr("tcp", "localhost:0") if err != nil {