blob: 5f1c7b4bbe04786479336a06f0f77b938f981de8 [file] [log] [blame]
/*
* 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 client
import (
"reflect"
"testing"
)
func createTablet(size int) (*Tablet, error) {
tablet, err := NewTablet("root.ln.TestDevice", []*MeasurementSchema{
&MeasurementSchema{
Measurement: "restart_count",
DataType: INT32,
Encoding: RLE,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
}, &MeasurementSchema{
Measurement: "price",
DataType: DOUBLE,
Encoding: GORILLA,
Compressor: SNAPPY,
}, &MeasurementSchema{
Measurement: "tick_count",
DataType: INT64,
Encoding: RLE,
Compressor: SNAPPY,
}, &MeasurementSchema{
Measurement: "temperature",
DataType: FLOAT,
Encoding: GORILLA,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
}, &MeasurementSchema{
Measurement: "description",
DataType: TEXT,
Encoding: PLAIN,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
},
&MeasurementSchema{
Measurement: "status",
DataType: BOOLEAN,
Encoding: RLE,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
},
}, size)
return tablet, err
}
func TestTablet_getDataTypes(t *testing.T) {
type fields struct {
deviceId string
measurementSchemas []*MeasurementSchema
timestamps []int64
values []interface{}
rowCount int
}
tests := []struct {
name string
fields fields
want []int32
}{
{
name: "",
fields: fields{
deviceId: "root.ln.device5",
measurementSchemas: []*MeasurementSchema{
&MeasurementSchema{
Measurement: "restart_count",
DataType: INT32,
Encoding: RLE,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
}, &MeasurementSchema{
Measurement: "price",
DataType: DOUBLE,
Encoding: GORILLA,
Compressor: SNAPPY,
}, &MeasurementSchema{
Measurement: "tick_count",
DataType: INT64,
Encoding: RLE,
Compressor: SNAPPY,
}, &MeasurementSchema{
Measurement: "temperature",
DataType: FLOAT,
Encoding: GORILLA,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
}, &MeasurementSchema{
Measurement: "description",
DataType: TEXT,
Encoding: PLAIN,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
},
&MeasurementSchema{
Measurement: "status",
DataType: BOOLEAN,
Encoding: RLE,
Compressor: SNAPPY,
Properties: map[string]string{
"owner": "Mark Liu",
},
},
},
timestamps: []int64{},
values: []interface{}{},
rowCount: 0,
},
want: []int32{int32(INT32), int32(DOUBLE), int32(INT64), int32(FLOAT), int32(TEXT), int32(BOOLEAN)},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tablet := &Tablet{
deviceId: tt.fields.deviceId,
measurementSchemas: tt.fields.measurementSchemas,
timestamps: tt.fields.timestamps,
values: tt.fields.values,
rowCount: tt.fields.rowCount,
}
if got := tablet.getDataTypes(); !reflect.DeepEqual(got, tt.want) {
t.Errorf("Tablet.getDataTypes() = %v, want %v", got, tt.want)
}
})
}
}
func TestTablet_SetTimestamp(t *testing.T) {
type args struct {
timestamp int64
rowIndex int
}
tests := []struct {
name string
args args
want int64
}{
{
name: "",
args: args{
timestamp: 1608268702769,
rowIndex: 0,
},
want: 1608268702769,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tablet, err := createTablet(1)
if err != nil {
t.Error(err)
}
tablet.SetTimestamp(tt.args.timestamp, tt.args.rowIndex)
if got := tablet.timestamps[0]; got != tt.want {
t.Errorf("Tablet.SetTimestamp(int64, int32) = %v, want %v", got, tt.want)
}
})
}
}
func TestTablet_SetValueAt(t *testing.T) {
type args struct {
value interface{}
columnIndex int
rowIndex int
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "nil",
args: args{
value: nil,
columnIndex: 0,
rowIndex: 0,
},
wantErr: true,
}, {
name: "columnIndex-1",
args: args{
value: 0,
columnIndex: -1,
rowIndex: 0,
},
wantErr: true,
}, {
name: "rowIndex-1",
args: args{
value: 0,
columnIndex: 0,
rowIndex: -1,
},
wantErr: true,
}, {
name: "rowIndex-65535",
args: args{
value: 0,
columnIndex: 0,
rowIndex: 65535,
},
wantErr: true,
}, {
name: "columnIndex-65535",
args: args{
value: 0,
columnIndex: 65535,
rowIndex: 0,
},
wantErr: true,
}, {
name: "restart_count",
args: args{
value: int32(0),
columnIndex: 0,
rowIndex: 0,
},
wantErr: false,
}, {
name: "price",
args: args{
value: float64(32.768),
columnIndex: 1,
rowIndex: 0,
},
wantErr: false,
}, {
name: "tick_count",
args: args{
value: int64(1608268702780),
columnIndex: 2,
rowIndex: 0,
},
wantErr: false,
}, {
name: "temperature",
args: args{
value: float32(36.5),
columnIndex: 3,
rowIndex: 0,
},
wantErr: false,
}, {
name: "description",
args: args{
value: "Hello world!",
columnIndex: 4,
rowIndex: 0,
},
wantErr: false,
}, {
name: "status",
args: args{
value: true,
columnIndex: 5,
rowIndex: 0,
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tablet, err := createTablet(1)
if err != nil {
t.Error(err)
}
if err := tablet.SetValueAt(tt.args.value, tt.args.columnIndex, tt.args.rowIndex); (err != nil) != tt.wantErr {
t.Errorf("Tablet.SetValueAt() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestTablet_GetValueAt(t *testing.T) {
type args struct {
columnIndex int
rowIndex int
}
tests := []struct {
name string
args args
want interface{}
wantErr bool
}{
{
name: "INT32",
args: args{
columnIndex: 0,
rowIndex: 0,
},
want: int32(256),
wantErr: false,
}, {
name: "FLOAT64",
args: args{
columnIndex: 1,
rowIndex: 0,
},
want: float64(32.768),
wantErr: false,
}, {
name: "INT64",
args: args{
columnIndex: 2,
rowIndex: 0,
},
want: int64(65535),
wantErr: false,
}, {
name: "FLOAT32",
args: args{
columnIndex: 3,
rowIndex: 0,
},
want: float32(36.5),
wantErr: false,
}, {
name: "STRING",
args: args{
columnIndex: 4,
rowIndex: 0,
},
want: "Hello World!",
wantErr: false,
}, {
name: "BOOLEAN",
args: args{
columnIndex: 5,
rowIndex: 0,
},
want: true,
wantErr: false,
},
}
if tablet, err := createTablet(1); err == nil {
tablet.SetValueAt(int32(256), 0, 0)
tablet.SetValueAt(float64(32.768), 1, 0)
tablet.SetValueAt(int64(65535), 2, 0)
tablet.SetValueAt(float32(36.5), 3, 0)
tablet.SetValueAt("Hello World!", 4, 0)
tablet.SetValueAt(true, 5, 0)
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := tablet.GetValueAt(tt.args.columnIndex, tt.args.rowIndex)
if (err != nil) != tt.wantErr {
t.Errorf("Tablet.GetValueAt() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Tablet.GetValueAt() = %v, want %v", got, tt.want)
}
})
}
}
}
func TestTablet_Sort(t *testing.T) {
tests := []struct {
name string
want [][]interface{}
wantErr bool
}{
{
name: "item-1",
want: [][]interface{}{
{int32(2), float64(2.0), int64(2), float32(2.0), "2", true},
{int32(1), float64(1.0), int64(1), float32(1.0), "1", true},
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tablet, _ := createTablet(2)
tablet.SetValueAt(int32(1), 0, 0)
tablet.SetValueAt(float64(1.0), 1, 0)
tablet.SetValueAt(int64(1), 2, 0)
tablet.SetValueAt(float32(1.0), 3, 0)
tablet.SetValueAt("1", 4, 0)
tablet.SetValueAt(true, 5, 0)
tablet.SetTimestamp(1, 0)
tablet.SetValueAt(int32(2), 0, 1)
tablet.SetValueAt(float64(2.0), 1, 1)
tablet.SetValueAt(int64(2), 2, 1)
tablet.SetValueAt(float32(2.0), 3, 1)
tablet.SetValueAt("2", 4, 1)
tablet.SetValueAt(true, 5, 1)
tablet.SetTimestamp(0, 1)
if err := tablet.Sort(); (err != nil) != tt.wantErr {
t.Errorf("Tablet.Sort() error = %v, wantErr %v", err, tt.wantErr)
}
for rowIndex, row := range tt.want {
for columnIndex, wantValue := range row {
value, _ := tablet.GetValueAt(columnIndex, rowIndex)
if !reflect.DeepEqual(value, wantValue) {
t.Errorf("Tablet.Sort() colum: %d, row: %d, value: %v != %v", columnIndex, rowIndex, value, wantValue)
}
}
}
})
}
}