161 lines
3.4 KiB
Go
161 lines
3.4 KiB
Go
// Copyright 2016 PingCAP, Inc.
|
|
//
|
|
// Licensed 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 kv
|
|
|
|
import (
|
|
"context"
|
|
"slices"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/pingcap/kvproto/pkg/kvrpcpb"
|
|
"github.com/pingcap/tidb/pkg/config/kerneltype"
|
|
"github.com/pingcap/tidb/pkg/keyspace"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestIncInt64(t *testing.T) {
|
|
mb := newMockMap()
|
|
key := Key("key")
|
|
v, err := IncInt64(mb, key, 1)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, int64(1), v)
|
|
|
|
v, err = IncInt64(mb, key, 10)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, int64(11), v)
|
|
|
|
err = mb.Set(key, []byte("not int"))
|
|
assert.Nil(t, err)
|
|
|
|
_, err = IncInt64(mb, key, 1)
|
|
assert.NotNil(t, err)
|
|
|
|
// test int overflow
|
|
maxUint32 := int64(^uint32(0))
|
|
err = mb.Set(key, []byte(strconv.FormatInt(maxUint32, 10)))
|
|
assert.Nil(t, err)
|
|
|
|
v, err = IncInt64(mb, key, 1)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, maxUint32+1, v)
|
|
}
|
|
|
|
func TestGetInt64(t *testing.T) {
|
|
mb := newMockMap()
|
|
key := Key("key")
|
|
v, err := GetInt64(context.TODO(), mb, key)
|
|
assert.Equal(t, int64(0), v)
|
|
assert.Nil(t, err)
|
|
|
|
_, err = IncInt64(mb, key, 15)
|
|
assert.Nil(t, err)
|
|
v, err = GetInt64(context.TODO(), mb, key)
|
|
assert.Equal(t, int64(15), v)
|
|
assert.Nil(t, err)
|
|
}
|
|
|
|
type mockMap struct {
|
|
index []Key
|
|
value [][]byte
|
|
}
|
|
|
|
var _ RetrieverMutator = &mockMap{}
|
|
|
|
func newMockMap() *mockMap {
|
|
return &mockMap{
|
|
index: make([]Key, 0),
|
|
value: make([][]byte, 0),
|
|
}
|
|
}
|
|
|
|
func (s *mockMap) SetDiskFullOpt(level kvrpcpb.DiskFullOpt) {
|
|
//TODO nothing.
|
|
}
|
|
|
|
func (s *mockMap) Iter(Key, Key) (Iterator, error) {
|
|
return nil, nil
|
|
}
|
|
func (s *mockMap) IterReverse(Key, Key) (Iterator, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (s *mockMap) Get(_ context.Context, k Key, _ ...GetOption) (ValueEntry, error) {
|
|
for i, key := range s.index {
|
|
if key.Cmp(k) == 0 {
|
|
return NewValueEntry(s.value[i], 0), nil
|
|
}
|
|
}
|
|
return ValueEntry{}, ErrNotExist
|
|
}
|
|
|
|
func (s *mockMap) Set(k Key, v []byte) error {
|
|
for i, key := range s.index {
|
|
if key.Cmp(k) == 0 {
|
|
s.value[i] = v
|
|
return nil
|
|
}
|
|
}
|
|
s.index = append(s.index, k)
|
|
s.value = append(s.value, v)
|
|
return nil
|
|
}
|
|
|
|
func (s *mockMap) Delete(k Key) error {
|
|
for i, key := range s.index {
|
|
if key.Cmp(k) == 0 {
|
|
s.index = slices.Delete(s.index, i, i+1)
|
|
s.value = slices.Delete(s.value, i, i+1)
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type keyspaceGetterStore struct {
|
|
Storage
|
|
ks string
|
|
}
|
|
|
|
func (s *keyspaceGetterStore) GetKeyspace() string {
|
|
return s.ks
|
|
}
|
|
|
|
func TestIsUserKS(t *testing.T) {
|
|
if kerneltype.IsClassic() {
|
|
store := &keyspaceGetterStore{}
|
|
assert.False(t, IsUserKS(store))
|
|
} else {
|
|
store := &keyspaceGetterStore{ks: "user"}
|
|
assert.True(t, IsUserKS(store))
|
|
|
|
store.ks = keyspace.System
|
|
assert.False(t, IsUserKS(store))
|
|
}
|
|
}
|
|
|
|
func TestIsSystemKS(t *testing.T) {
|
|
if kerneltype.IsClassic() {
|
|
store := &keyspaceGetterStore{}
|
|
assert.False(t, IsSystemKS(store))
|
|
} else {
|
|
store := &keyspaceGetterStore{ks: "user"}
|
|
assert.False(t, IsSystemKS(store))
|
|
|
|
store.ks = keyspace.System
|
|
assert.True(t, IsSystemKS(store))
|
|
}
|
|
}
|