mirror of https://github.com/milvus-io/milvus.git
716 lines
16 KiB
Go
716 lines
16 KiB
Go
package planparserv2
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
|
|
"github.com/milvus-io/milvus/pkg/v2/proto/planpb"
|
|
)
|
|
|
|
func Test_relationalCompatible(t *testing.T) {
|
|
type args struct {
|
|
t1 schemapb.DataType
|
|
t2 schemapb.DataType
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{
|
|
{
|
|
// both.
|
|
args: args{
|
|
t1: schemapb.DataType_VarChar,
|
|
t2: schemapb.DataType_VarChar,
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
// neither.
|
|
args: args{
|
|
t1: schemapb.DataType_Float,
|
|
t2: schemapb.DataType_Float,
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
// in-compatible.
|
|
args: args{
|
|
t1: schemapb.DataType_Float,
|
|
t2: schemapb.DataType_VarChar,
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
// in-compatible.
|
|
args: args{
|
|
t1: schemapb.DataType_VarChar,
|
|
t2: schemapb.DataType_Float,
|
|
},
|
|
want: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := relationalCompatible(tt.args.t1, tt.args.t2); got != tt.want {
|
|
t.Errorf("relationalCompatible() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsAlwaysTruePlan(t *testing.T) {
|
|
type args struct {
|
|
plan *planpb.PlanNode
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{
|
|
{
|
|
args: args{
|
|
plan: nil,
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
args: args{
|
|
plan: &planpb.PlanNode{
|
|
Node: &planpb.PlanNode_VectorAnns{
|
|
VectorAnns: &planpb.VectorANNS{
|
|
Predicates: alwaysTrueExpr(),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
plan: &planpb.PlanNode{
|
|
Node: &planpb.PlanNode_Predicates{
|
|
Predicates: alwaysTrueExpr(),
|
|
},
|
|
},
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
plan: &planpb.PlanNode{
|
|
Node: &planpb.PlanNode_Query{
|
|
Query: &planpb.QueryPlanNode{
|
|
Predicates: alwaysTrueExpr(),
|
|
IsCount: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
args: args{
|
|
plan: &planpb.PlanNode{
|
|
Node: &planpb.PlanNode_Query{
|
|
Query: &planpb.QueryPlanNode{
|
|
Predicates: alwaysTrueExpr(),
|
|
IsCount: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
want: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, IsAlwaysTruePlan(tt.args.plan), "IsAlwaysTruePlan(%v)", tt.args.plan)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_canBeExecuted(t *testing.T) {
|
|
type args struct {
|
|
e *ExprWithType
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{
|
|
{
|
|
args: args{
|
|
e: &ExprWithType{
|
|
dataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
args: args{
|
|
e: &ExprWithType{
|
|
dataType: schemapb.DataType_Bool,
|
|
nodeDependent: true,
|
|
},
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
args: args{
|
|
e: &ExprWithType{
|
|
dataType: schemapb.DataType_Bool,
|
|
nodeDependent: false,
|
|
},
|
|
},
|
|
want: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
assert.Equalf(t, tt.want, canBeExecuted(tt.args.e), "canBeExecuted(%v)", tt.args.e)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_convertEscapeSingle(t *testing.T) {
|
|
type testCases struct {
|
|
input string
|
|
expected string
|
|
}
|
|
normalCases := []testCases{
|
|
{`"\'"`, `'`},
|
|
{`"\\'"`, `\'`},
|
|
{`"\\\'"`, `\'`},
|
|
{`"\\\\'"`, `\\'`},
|
|
{`"\\\\\'"`, `\\'`},
|
|
{`'"'`, `"`},
|
|
{`'""'`, `""`},
|
|
{`'"""'`, `"""`},
|
|
{`'"\""'`, `"""`},
|
|
{`'a"b\"c\\"d'`, `a"b"c\"d`},
|
|
{`"a\"b\"c\\\"d"`, `a"b"c\"d`},
|
|
{`'A "test"'`, `A "test"`},
|
|
{`"A \"test\""`, `A "test"`},
|
|
{`'\"'`, `"`},
|
|
{`'\\"'`, `\"`},
|
|
{`'\\\"'`, `\"`},
|
|
{`'\\\\"'`, `\\"`},
|
|
{`'\\\\\"'`, `\\"`},
|
|
}
|
|
for _, c := range normalCases {
|
|
actual, err := convertEscapeSingle(c.input)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, c.expected, actual)
|
|
}
|
|
|
|
unNormalCases := []testCases{
|
|
{`"\423"`, ``},
|
|
{`'\378'`, ``},
|
|
}
|
|
for _, c := range unNormalCases {
|
|
actual, err := convertEscapeSingle(c.input)
|
|
assert.Error(t, err)
|
|
assert.Equal(t, c.expected, actual)
|
|
}
|
|
}
|
|
|
|
func Test_canBeComparedDataType(t *testing.T) {
|
|
type testCases struct {
|
|
left schemapb.DataType
|
|
right schemapb.DataType
|
|
expected bool
|
|
}
|
|
|
|
cases := []testCases{
|
|
{schemapb.DataType_Bool, schemapb.DataType_Bool, true},
|
|
{schemapb.DataType_Bool, schemapb.DataType_JSON, true},
|
|
{schemapb.DataType_Bool, schemapb.DataType_Int8, false},
|
|
{schemapb.DataType_Bool, schemapb.DataType_Int16, false},
|
|
{schemapb.DataType_Bool, schemapb.DataType_Int32, false},
|
|
{schemapb.DataType_Bool, schemapb.DataType_Int64, false},
|
|
{schemapb.DataType_Bool, schemapb.DataType_Float, false},
|
|
{schemapb.DataType_Bool, schemapb.DataType_Double, false},
|
|
{schemapb.DataType_Bool, schemapb.DataType_String, false},
|
|
{schemapb.DataType_Int8, schemapb.DataType_Int16, true},
|
|
{schemapb.DataType_Int16, schemapb.DataType_Int32, true},
|
|
{schemapb.DataType_Int32, schemapb.DataType_Int64, true},
|
|
{schemapb.DataType_Int64, schemapb.DataType_Float, true},
|
|
{schemapb.DataType_Float, schemapb.DataType_Double, true},
|
|
{schemapb.DataType_Double, schemapb.DataType_Int32, true},
|
|
{schemapb.DataType_Double, schemapb.DataType_String, false},
|
|
{schemapb.DataType_Int64, schemapb.DataType_String, false},
|
|
{schemapb.DataType_Int64, schemapb.DataType_JSON, true},
|
|
{schemapb.DataType_Double, schemapb.DataType_JSON, true},
|
|
{schemapb.DataType_String, schemapb.DataType_Double, false},
|
|
{schemapb.DataType_String, schemapb.DataType_Int64, false},
|
|
{schemapb.DataType_String, schemapb.DataType_JSON, true},
|
|
{schemapb.DataType_String, schemapb.DataType_String, true},
|
|
{schemapb.DataType_String, schemapb.DataType_VarChar, true},
|
|
{schemapb.DataType_VarChar, schemapb.DataType_VarChar, true},
|
|
{schemapb.DataType_VarChar, schemapb.DataType_JSON, true},
|
|
{schemapb.DataType_VarChar, schemapb.DataType_Int64, false},
|
|
{schemapb.DataType_Array, schemapb.DataType_Int64, false},
|
|
{schemapb.DataType_Array, schemapb.DataType_Array, false},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
assert.Equal(t, c.expected, canBeComparedDataType(c.left, c.right))
|
|
}
|
|
}
|
|
|
|
func Test_getArrayElementType(t *testing.T) {
|
|
t.Run("array element", func(t *testing.T) {
|
|
expr := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ValueExpr{
|
|
ValueExpr: &planpb.ValueExpr{
|
|
Value: &planpb.GenericValue{
|
|
Val: &planpb.GenericValue_ArrayVal{
|
|
ArrayVal: &planpb.Array{
|
|
Array: nil,
|
|
ElementType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Array,
|
|
nodeDependent: true,
|
|
}
|
|
|
|
assert.Equal(t, schemapb.DataType_Int64, getArrayElementType(expr))
|
|
})
|
|
|
|
t.Run("array field", func(t *testing.T) {
|
|
expr := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 101,
|
|
DataType: schemapb.DataType_Array,
|
|
IsPrimaryKey: false,
|
|
IsAutoID: false,
|
|
NestedPath: nil,
|
|
IsPartitionKey: false,
|
|
ElementType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Array,
|
|
nodeDependent: true,
|
|
}
|
|
|
|
assert.Equal(t, schemapb.DataType_Int64, getArrayElementType(expr))
|
|
})
|
|
|
|
t.Run("not array", func(t *testing.T) {
|
|
expr := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_String,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_String,
|
|
nodeDependent: true,
|
|
}
|
|
|
|
assert.Equal(t, schemapb.DataType_None, getArrayElementType(expr))
|
|
})
|
|
}
|
|
|
|
func Test_decodeUnicode(t *testing.T) {
|
|
s1 := "A[\"\\u5e74\\u4efd\"][\"\\u6708\\u4efd\"]"
|
|
|
|
assert.NotEqual(t, `A["年份"]["月份"]`, s1)
|
|
assert.Equal(t, `A["年份"]["月份"]`, decodeUnicode(s1))
|
|
}
|
|
|
|
func Test_handleCompare(t *testing.T) {
|
|
t.Run("normal field comparison", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 101,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
assert.NotNil(t, result.GetCompareExpr())
|
|
assert.Equal(t, planpb.OpType_GreaterThan, result.GetCompareExpr().GetOp())
|
|
})
|
|
|
|
t.Run("left field is JSON type", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 101,
|
|
DataType: schemapb.DataType_JSON,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_JSON,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.Error(t, err)
|
|
assert.Nil(t, result)
|
|
assert.Contains(t, err.Error(), "two column comparison with JSON type is not supported")
|
|
})
|
|
|
|
t.Run("right field is JSON type", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 101,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_JSON,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_JSON,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.Error(t, err)
|
|
assert.Nil(t, result)
|
|
assert.Contains(t, err.Error(), "two column comparison with JSON type is not supported")
|
|
})
|
|
|
|
t.Run("both fields are JSON type", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 101,
|
|
DataType: schemapb.DataType_JSON,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_JSON,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_JSON,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_JSON,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.Error(t, err)
|
|
assert.Nil(t, result)
|
|
assert.Contains(t, err.Error(), "two column comparison with JSON type is not supported")
|
|
})
|
|
|
|
t.Run("left field is nil", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ValueExpr{
|
|
ValueExpr: &planpb.ValueExpr{
|
|
Value: &planpb.GenericValue{
|
|
Val: &planpb.GenericValue_Int64Val{
|
|
Int64Val: 100,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.Error(t, err)
|
|
assert.Nil(t, result)
|
|
assert.Contains(t, err.Error(), "only comparison between two fields is supported")
|
|
})
|
|
|
|
t.Run("right field is nil", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 101,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ValueExpr{
|
|
ValueExpr: &planpb.ValueExpr{
|
|
Value: &planpb.GenericValue{
|
|
Val: &planpb.GenericValue_Int64Val{
|
|
Int64Val: 100,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.Error(t, err)
|
|
assert.Nil(t, result)
|
|
assert.Contains(t, err.Error(), "only comparison between two fields is supported")
|
|
})
|
|
|
|
t.Run("template expression", func(t *testing.T) {
|
|
left := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
IsTemplate: true,
|
|
Expr: &planpb.Expr_ValueExpr{
|
|
ValueExpr: &planpb.ValueExpr{
|
|
Value: &planpb.GenericValue{
|
|
Val: &planpb.GenericValue_Int64Val{
|
|
Int64Val: 100,
|
|
},
|
|
},
|
|
TemplateVariableName: "var1",
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
right := &ExprWithType{
|
|
expr: &planpb.Expr{
|
|
Expr: &planpb.Expr_ColumnExpr{
|
|
ColumnExpr: &planpb.ColumnExpr{
|
|
Info: &planpb.ColumnInfo{
|
|
FieldId: 102,
|
|
DataType: schemapb.DataType_Int64,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
dataType: schemapb.DataType_Int64,
|
|
}
|
|
|
|
result, err := handleCompare(planpb.OpType_GreaterThan, left, right)
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, result)
|
|
assert.NotNil(t, result.GetUnaryRangeExpr())
|
|
assert.Equal(t, planpb.OpType_GreaterThan, result.GetUnaryRangeExpr().GetOp())
|
|
assert.Equal(t, "var1", result.GetUnaryRangeExpr().GetTemplateVariableName())
|
|
})
|
|
}
|
|
|
|
func TestParseISO8601Duration(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
input string
|
|
expected *planpb.Interval
|
|
expectErr bool
|
|
}{
|
|
{
|
|
name: "Full duration",
|
|
input: "P1Y2M3DT4H5M6S",
|
|
expected: &planpb.Interval{
|
|
Years: 1,
|
|
Months: 2,
|
|
Days: 3,
|
|
Hours: 4,
|
|
Minutes: 5,
|
|
Seconds: 6,
|
|
},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Date part only",
|
|
input: "P3Y6M4D",
|
|
expected: &planpb.Interval{
|
|
Years: 3,
|
|
Months: 6,
|
|
Days: 4,
|
|
},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Time part only",
|
|
input: "PT10H30M15S",
|
|
expected: &planpb.Interval{
|
|
Hours: 10,
|
|
Minutes: 30,
|
|
Seconds: 15,
|
|
},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "handle 0",
|
|
input: "P0D",
|
|
expected: &planpb.Interval{
|
|
Days: 0,
|
|
},
|
|
},
|
|
{
|
|
name: "Ambiguous M for Month",
|
|
input: "P2M",
|
|
expected: &planpb.Interval{Months: 2},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Ambiguous M for Minute",
|
|
input: "PT2M",
|
|
expected: &planpb.Interval{Minutes: 2},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Mixed date and time with missing parts",
|
|
input: "P1DT12H",
|
|
expected: &planpb.Interval{Days: 1, Hours: 12},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Only P (valid empty duration)",
|
|
input: "P",
|
|
expected: &planpb.Interval{},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Only PT (valid empty time part)",
|
|
input: "PT",
|
|
expected: &planpb.Interval{},
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "Invalid format - no P prefix",
|
|
input: "1Y2M",
|
|
expected: nil,
|
|
expectErr: true,
|
|
},
|
|
{
|
|
name: "Invalid format - unknown character",
|
|
input: "P1Y2X",
|
|
expected: nil,
|
|
expectErr: true,
|
|
},
|
|
{
|
|
name: "Invalid format - time part without T",
|
|
input: "P1H",
|
|
expected: nil,
|
|
expectErr: true,
|
|
},
|
|
{
|
|
name: "Invalid format - empty string",
|
|
input: "",
|
|
expected: nil,
|
|
expectErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
actual, err := parseISODuration(tc.input)
|
|
if tc.expectErr {
|
|
if err == nil {
|
|
t.Errorf("expected an error but got none")
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("did not expect an error but got: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(actual, tc.expected) {
|
|
t.Errorf("result mismatch:\nexpected: %+v\nactual: %+v", tc.expected, actual)
|
|
}
|
|
})
|
|
}
|
|
}
|