You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
188 lines
6.3 KiB
188 lines
6.3 KiB
// Copyright 2020 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,
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package collate
|
|
|
|
import (
|
|
"testing"
|
|
|
|
. "github.com/pingcap/check"
|
|
"github.com/pingcap/tidb/util/testleak"
|
|
)
|
|
|
|
func TestT(t *testing.T) {
|
|
TestingT(t)
|
|
}
|
|
|
|
var (
|
|
_ = SerialSuites(&testCollateSuite{})
|
|
)
|
|
|
|
type testCollateSuite struct {
|
|
}
|
|
|
|
type compareTable struct {
|
|
Left string
|
|
Right string
|
|
Expect int
|
|
}
|
|
|
|
type keyTable struct {
|
|
Str string
|
|
Expect []byte
|
|
}
|
|
|
|
func testCompareTable(table []compareTable, collate string, c *C) {
|
|
for i, t := range table {
|
|
comment := Commentf("%d %v %v", i, t.Left, t.Right)
|
|
c.Assert(GetCollator(collate).Compare(t.Left, t.Right), Equals, t.Expect, comment)
|
|
}
|
|
}
|
|
|
|
func testKeyTable(table []keyTable, collate string, c *C) {
|
|
for i, t := range table {
|
|
comment := Commentf("%d %s", i, t.Str)
|
|
c.Assert(GetCollator(collate).Key(t.Str), DeepEquals, t.Expect, comment)
|
|
}
|
|
}
|
|
|
|
func (s *testCollateSuite) TestBinCollator(c *C) {
|
|
defer testleak.AfterTest(c)()
|
|
SetNewCollationEnabledForTest(false)
|
|
compareTable := []compareTable{
|
|
{"a", "b", -1},
|
|
{"a", "A", 1},
|
|
{"abc", "abc", 0},
|
|
{"abc", "ab", 1},
|
|
{"a", "a ", -1},
|
|
{"a ", "a ", -1},
|
|
{"a\t", "a", 1},
|
|
}
|
|
keyTable := []keyTable{
|
|
{"a", []byte{0x61}},
|
|
{"A", []byte{0x41}},
|
|
{"Foo © bar 𝌆 baz ☃ qux", []byte{0x46, 0x6f, 0x6f, 0x20, 0xc2, 0xa9, 0x20, 0x62, 0x61, 0x72, 0x20, 0xf0,
|
|
0x9d, 0x8c, 0x86, 0x20, 0x62, 0x61, 0x7a, 0x20, 0xe2, 0x98, 0x83, 0x20, 0x71, 0x75, 0x78}},
|
|
{"a ", []byte{0x61, 0x20}},
|
|
{"a", []byte{0x61}},
|
|
}
|
|
testCompareTable(compareTable, "utf8mb4_bin", c)
|
|
testKeyTable(keyTable, "utf8mb4_bin", c)
|
|
}
|
|
|
|
func (s *testCollateSuite) TestBinPaddingCollator(c *C) {
|
|
defer testleak.AfterTest(c)()
|
|
SetNewCollationEnabledForTest(true)
|
|
defer SetNewCollationEnabledForTest(false)
|
|
compareTable := []compareTable{
|
|
{"a", "b", -1},
|
|
{"a", "A", 1},
|
|
{"abc", "abc", 0},
|
|
{"abc", "ab", 1},
|
|
{"a", "a ", 0},
|
|
{"a ", "a ", 0},
|
|
{"a\t", "a", 1},
|
|
}
|
|
keyTable := []keyTable{
|
|
{"a", []byte{0x61}},
|
|
{"A", []byte{0x41}},
|
|
{"Foo © bar 𝌆 baz ☃ qux", []byte{0x46, 0x6f, 0x6f, 0x20, 0xc2, 0xa9, 0x20, 0x62, 0x61,
|
|
0x72, 0x20, 0xf0, 0x9d, 0x8c, 0x86, 0x20, 0x62, 0x61, 0x7a, 0x20, 0xe2, 0x98, 0x83, 0x20, 0x71, 0x75, 0x78}},
|
|
{"a ", []byte{0x61}},
|
|
{"a", []byte{0x61}},
|
|
}
|
|
testCompareTable(compareTable, "utf8mb4_bin", c)
|
|
testKeyTable(keyTable, "utf8mb4_bin", c)
|
|
}
|
|
|
|
func (s *testCollateSuite) TestGeneralCICollator(c *C) {
|
|
defer testleak.AfterTest(c)()
|
|
SetNewCollationEnabledForTest(true)
|
|
defer SetNewCollationEnabledForTest(false)
|
|
compareTable := []compareTable{
|
|
{"a", "b", -1},
|
|
{"a", "A", 0},
|
|
{"À", "A", 0},
|
|
{"abc", "abc", 0},
|
|
{"abc", "ab", 1},
|
|
{"😜", "😃", 0},
|
|
{"a ", "a ", 0},
|
|
{"a\t", "a", 1},
|
|
}
|
|
keyTable := []keyTable{
|
|
{"a", []byte{0x0, 0x41}},
|
|
{"A", []byte{0x0, 0x41}},
|
|
{"😃", []byte{0xff, 0xfd}},
|
|
{"Foo © bar 𝌆 baz ☃ qux", []byte{0x0, 0x46, 0x0, 0x4f, 0x0, 0x4f, 0x0, 0x20, 0x0, 0xa9, 0x0, 0x20, 0x0,
|
|
0x42, 0x0, 0x41, 0x0, 0x52, 0x0, 0x20, 0xff, 0xfd, 0x0, 0x20, 0x0, 0x42, 0x0, 0x41, 0x0, 0x5a, 0x0, 0x20, 0x26,
|
|
0x3, 0x0, 0x20, 0x0, 0x51, 0x0, 0x55, 0x0, 0x58}},
|
|
{string([]byte{0x88, 0xe6}), []byte{0xff, 0xfd, 0xff, 0xfd}},
|
|
{"a ", []byte{0x0, 0x41}},
|
|
{"a", []byte{0x0, 0x41}},
|
|
}
|
|
testCompareTable(compareTable, "utf8mb4_general_ci", c)
|
|
testKeyTable(keyTable, "utf8mb4_general_ci", c)
|
|
}
|
|
|
|
func (s *testCollateSuite) TestSetNewCollateEnabled(c *C) {
|
|
defer SetNewCollationEnabledForTest(false)
|
|
|
|
SetNewCollationEnabledForTest(true)
|
|
c.Assert(NewCollationEnabled(), Equals, true)
|
|
}
|
|
|
|
func (s *testCollateSuite) TestRewriteAndRestoreCollationID(c *C) {
|
|
SetNewCollationEnabledForTest(true)
|
|
c.Assert(RewriteNewCollationIDIfNeeded(5), Equals, int32(-5))
|
|
c.Assert(RewriteNewCollationIDIfNeeded(-5), Equals, int32(-5))
|
|
c.Assert(RestoreCollationIDIfNeeded(-5), Equals, int32(5))
|
|
c.Assert(RestoreCollationIDIfNeeded(5), Equals, int32(5))
|
|
|
|
SetNewCollationEnabledForTest(false)
|
|
c.Assert(RewriteNewCollationIDIfNeeded(5), Equals, int32(5))
|
|
c.Assert(RewriteNewCollationIDIfNeeded(-5), Equals, int32(-5))
|
|
c.Assert(RestoreCollationIDIfNeeded(5), Equals, int32(5))
|
|
c.Assert(RestoreCollationIDIfNeeded(-5), Equals, int32(-5))
|
|
}
|
|
|
|
func (s *testCollateSuite) TestGetCollator(c *C) {
|
|
defer testleak.AfterTest(c)()
|
|
SetNewCollationEnabledForTest(true)
|
|
defer SetNewCollationEnabledForTest(false)
|
|
c.Assert(GetCollator("binary"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollator("utf8mb4_bin"), FitsTypeOf, &binPaddingCollator{})
|
|
c.Assert(GetCollator("utf8_bin"), FitsTypeOf, &binPaddingCollator{})
|
|
c.Assert(GetCollator("utf8mb4_general_ci"), FitsTypeOf, &generalCICollator{})
|
|
c.Assert(GetCollator("utf8_general_ci"), FitsTypeOf, &generalCICollator{})
|
|
c.Assert(GetCollator("default_test"), FitsTypeOf, &binPaddingCollator{})
|
|
c.Assert(GetCollatorByID(63), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(46), FitsTypeOf, &binPaddingCollator{})
|
|
c.Assert(GetCollatorByID(83), FitsTypeOf, &binPaddingCollator{})
|
|
c.Assert(GetCollatorByID(45), FitsTypeOf, &generalCICollator{})
|
|
c.Assert(GetCollatorByID(33), FitsTypeOf, &generalCICollator{})
|
|
c.Assert(GetCollatorByID(9999), FitsTypeOf, &binPaddingCollator{})
|
|
|
|
SetNewCollationEnabledForTest(false)
|
|
c.Assert(GetCollator("binary"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollator("utf8mb4_bin"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollator("utf8_bin"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollator("utf8mb4_general_ci"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollator("utf8_general_ci"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollator("default_test"), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(63), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(46), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(83), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(45), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(33), FitsTypeOf, &binCollator{})
|
|
c.Assert(GetCollatorByID(9999), FitsTypeOf, &binCollator{})
|
|
}
|
|
|