125 lines
3.6 KiB
Go
125 lines
3.6 KiB
Go
// Copyright 2015 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 dump
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/pingcap/tidb/pkg/types"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestDumpBinaryTime(t *testing.T) {
|
|
typeCtx := types.DefaultStmtNoWarningContext
|
|
parsedTime, err := types.ParseTimestamp(typeCtx, "0000-00-00 00:00:00.000000")
|
|
require.NoError(t, err)
|
|
d := BinaryDateTime(nil, parsedTime)
|
|
require.Equal(t, []byte{0}, d)
|
|
|
|
parsedTime, err = types.ParseTimestamp(typeCtx.WithLocation(time.UTC), "1991-05-01 01:01:01.100001")
|
|
require.NoError(t, err)
|
|
d = BinaryDateTime(nil, parsedTime)
|
|
// 199 & 7 composed to uint16 1991 (litter-endian)
|
|
// 160 & 134 & 1 & 0 composed to uint32 1000001 (litter-endian)
|
|
require.Equal(t, []byte{11, 199, 7, 5, 1, 1, 1, 1, 161, 134, 1, 0}, d)
|
|
|
|
parsedTime, err = types.ParseDatetime(typeCtx, "0000-00-00 00:00:00.000000")
|
|
require.NoError(t, err)
|
|
d = BinaryDateTime(nil, parsedTime)
|
|
require.Equal(t, []byte{0}, d)
|
|
|
|
parsedTime, err = types.ParseDatetime(typeCtx, "1993-07-13 01:01:01.000000")
|
|
require.NoError(t, err)
|
|
d = BinaryDateTime(nil, parsedTime)
|
|
// 201 & 7 composed to uint16 1993 (litter-endian)
|
|
require.Equal(t, []byte{7, 201, 7, 7, 13, 1, 1, 1}, d)
|
|
|
|
parsedTime, err = types.ParseDate(typeCtx, "0000-00-00")
|
|
require.NoError(t, err)
|
|
d = BinaryDateTime(nil, parsedTime)
|
|
require.Equal(t, []byte{0}, d)
|
|
parsedTime, err = types.ParseDate(typeCtx, "1992-06-01")
|
|
require.NoError(t, err)
|
|
d = BinaryDateTime(nil, parsedTime)
|
|
// 200 & 7 composed to uint16 1992 (litter-endian)
|
|
require.Equal(t, []byte{4, 200, 7, 6, 1}, d)
|
|
|
|
parsedTime, err = types.ParseDate(typeCtx, "0000-00-00")
|
|
require.NoError(t, err)
|
|
d = BinaryDateTime(nil, parsedTime)
|
|
require.Equal(t, []byte{0}, d)
|
|
|
|
myDuration, _, err := types.ParseDuration(typeCtx, "0000-00-00 00:00:00.000000", 6)
|
|
require.NoError(t, err)
|
|
d = BinaryTime(myDuration.Duration)
|
|
require.Equal(t, []byte{0}, d)
|
|
|
|
d = BinaryTime(0)
|
|
require.Equal(t, []byte{0}, d)
|
|
|
|
d = BinaryTime(-1)
|
|
require.Equal(t, []byte{12, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, d)
|
|
|
|
d = BinaryTime(time.Nanosecond + 86400*1000*time.Microsecond)
|
|
require.Equal(t, []byte{12, 0, 0, 0, 0, 0, 0, 1, 26, 128, 26, 6, 0}, d)
|
|
}
|
|
|
|
func TestDumpLengthEncodedInt(t *testing.T) {
|
|
testCases := []struct {
|
|
num uint64
|
|
buffer []byte
|
|
}{
|
|
{
|
|
uint64(0),
|
|
[]byte{0x00},
|
|
},
|
|
{
|
|
uint64(513),
|
|
[]byte{'\xfc', '\x01', '\x02'},
|
|
},
|
|
{
|
|
uint64(197121),
|
|
[]byte{'\xfd', '\x01', '\x02', '\x03'},
|
|
},
|
|
{
|
|
uint64(578437695752307201),
|
|
[]byte{'\xfe', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08'},
|
|
},
|
|
}
|
|
for _, tc := range testCases {
|
|
b := LengthEncodedInt(nil, tc.num)
|
|
require.Equal(t, tc.buffer, b)
|
|
}
|
|
}
|
|
|
|
func TestDumpUint(t *testing.T) {
|
|
testCases := []uint64{
|
|
0,
|
|
1,
|
|
1<<64 - 1,
|
|
}
|
|
parseUint64 := func(b []byte) uint64 {
|
|
return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 |
|
|
uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 |
|
|
uint64(b[6])<<48 | uint64(b[7])<<56
|
|
}
|
|
for _, tc := range testCases {
|
|
b := Uint64(nil, tc)
|
|
require.Len(t, b, 8)
|
|
require.Equal(t, tc, parseUint64(b))
|
|
}
|
|
}
|