From 4d62a3edb9f45105855d1ad319ab663e9d26a8b0 Mon Sep 17 00:00:00 2001 From: Andres Taylor Date: Mon, 20 Apr 2020 09:38:47 +0200 Subject: [PATCH] Test cleanup Signed-off-by: Andres Taylor --- go/vt/vtgate/evalengine/arithmetic_test.go | 835 ++++++++++----------- 1 file changed, 391 insertions(+), 444 deletions(-) diff --git a/go/vt/vtgate/evalengine/arithmetic_test.go b/go/vt/vtgate/evalengine/arithmetic_test.go index 781e5d5de82..a23ee04a8c4 100644 --- a/go/vt/vtgate/evalengine/arithmetic_test.go +++ b/go/vt/vtgate/evalengine/arithmetic_test.go @@ -24,6 +24,8 @@ import ( "strconv" "testing" + "github.com/stretchr/testify/require" + "vitess.io/vitess/go/sqltypes" querypb "vitess.io/vitess/go/vt/proto/query" @@ -31,456 +33,401 @@ import ( "vitess.io/vitess/go/vt/vterrors" ) -func TestDivide(t *testing.T) { - tcases := []struct { - v1, v2 sqltypes.Value - out sqltypes.Value - err error - }{{ - //All Nulls - v1: sqltypes.NULL, - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // First value null. - v1: sqltypes.NULL, - v2: sqltypes.NewInt32(1), - out: sqltypes.NULL, - }, { - // Second value null. - v1: sqltypes.NewInt32(1), - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // Second arg 0 - v1: sqltypes.NewInt32(5), - v2: sqltypes.NewInt32(0), - out: sqltypes.NULL, - }, { - // Both arguments zero - v1: sqltypes.NewInt32(0), - v2: sqltypes.NewInt32(0), - out: sqltypes.NULL, - }, { - // case with negative value - v1: sqltypes.NewInt64(-1), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewFloat64(0.5000), - }, { - // float64 division by zero - v1: sqltypes.NewFloat64(2), - v2: sqltypes.NewFloat64(0), - out: sqltypes.NULL, - }, { - // Lower bound for int64 - v1: sqltypes.NewInt64(math.MinInt64), - v2: sqltypes.NewInt64(1), - out: sqltypes.NewFloat64(math.MinInt64), - }, { - // upper bound for uint64 - v1: sqltypes.NewUint64(math.MaxUint64), - v2: sqltypes.NewUint64(1), - out: sqltypes.NewFloat64(math.MaxUint64), - }, { - // testing for error in types - v1: sqltypes.TestValue(querypb.Type_INT64, "1.2"), - v2: sqltypes.NewInt64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseInt: parsing \"1.2\": invalid syntax"), - }, { - // testing for error in types - v1: sqltypes.NewInt64(2), - v2: sqltypes.TestValue(querypb.Type_INT64, "1.2"), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseInt: parsing \"1.2\": invalid syntax"), - }, { - // testing for uint/int - v1: sqltypes.NewUint64(4), - v2: sqltypes.NewInt64(5), - out: sqltypes.NewFloat64(0.8), - }, { - // testing for uint/uint - v1: sqltypes.NewUint64(1), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewFloat64(0.5), - }, { - // testing for float64/int64 - v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewFloat64(-0.6), - }, { - // testing for float64/uint64 - v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewFloat64(0.6), - }, { - // testing for overflow of float64 - v1: sqltypes.NewFloat64(math.MaxFloat64), - v2: sqltypes.NewFloat64(0.5), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT is out of range in 1.7976931348623157e+308 / 0.5"), - }} - - for _, tcase := range tcases { - got, err := Divide(tcase.v1, tcase.v2) - - if !vterrors.Equals(err, tcase.err) { - t.Errorf("%v %v %v", printValue(tcase.v1), printValue(tcase.v2), vterrors.Print(err)) - t.Errorf("Divide(%v, %v) error: %v, want %v", printValue(tcase.v1), printValue(tcase.v2), vterrors.Print(err), vterrors.Print(tcase.err)) - } - - if tcase.err != nil { - continue - } - - if !reflect.DeepEqual(got, tcase.out) { - t.Errorf("Divide(%v, %v): %v, want %v", printValue(tcase.v1), printValue(tcase.v2), printValue(got), printValue(tcase.out)) - } +func TestArithmetics(t *testing.T) { + type tcase struct { + v1, v2, out sqltypes.Value + err string } -} - -func TestMultiply(t *testing.T) { - tcases := []struct { - v1, v2 sqltypes.Value - out sqltypes.Value - err error + tests := []struct { + operator string + f func(a, b sqltypes.Value) (sqltypes.Value, error) + cases []tcase }{{ - //All Nulls - v1: sqltypes.NULL, - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // First value null. - v1: sqltypes.NewInt32(1), - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // Second value null. - v1: sqltypes.NULL, - v2: sqltypes.NewInt32(1), - out: sqltypes.NULL, - }, { - // case with negative value - v1: sqltypes.NewInt64(-1), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewInt64(2), - }, { - // testing for int64 overflow with min negative value - v1: sqltypes.NewInt64(math.MinInt64), - v2: sqltypes.NewInt64(1), - out: sqltypes.NewInt64(math.MinInt64), - }, { - // testing for error in types - v1: sqltypes.TestValue(querypb.Type_INT64, "1.2"), - v2: sqltypes.NewInt64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseInt: parsing \"1.2\": invalid syntax"), - }, { - // testing for error in types - v1: sqltypes.NewInt64(2), - v2: sqltypes.TestValue(querypb.Type_INT64, "1.2"), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseInt: parsing \"1.2\": invalid syntax"), - }, { - // testing for uint*int - v1: sqltypes.NewUint64(4), - v2: sqltypes.NewInt64(5), - out: sqltypes.NewUint64(20), - }, { - // testing for uint*uint - v1: sqltypes.NewUint64(1), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewUint64(2), - }, { - // testing for float64*int64 - v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewFloat64(-2.4), - }, { - // testing for float64*uint64 - v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewFloat64(2.4), - }, { - // testing for overflow of int64 - v1: sqltypes.NewInt64(math.MaxInt64), - v2: sqltypes.NewInt64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT value is out of range in 9223372036854775807 * 2"), - }, { - // testing for underflow of uint64*max.uint64 - v1: sqltypes.NewInt64(2), - v2: sqltypes.NewUint64(math.MaxUint64), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 18446744073709551615 * 2"), - }, { - v1: sqltypes.NewUint64(math.MaxUint64), - v2: sqltypes.NewUint64(1), - out: sqltypes.NewUint64(math.MaxUint64), - }, { - //Checking whether maxInt value can be passed as uint value - v1: sqltypes.NewUint64(math.MaxInt64), - v2: sqltypes.NewInt64(3), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 9223372036854775807 * 3"), + operator: "-", + f: Subtract, + cases: []tcase{{ + // All Nulls + v1: sqltypes.NULL, + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // First value null. + v1: sqltypes.NewInt32(1), + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // Second value null. + v1: sqltypes.NULL, + v2: sqltypes.NewInt32(1), + out: sqltypes.NULL, + }, { + // case with negative value + v1: sqltypes.NewInt64(-1), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewInt64(1), + }, { + // testing for int64 overflow with min negative value + v1: sqltypes.NewInt64(math.MinInt64), + v2: sqltypes.NewInt64(1), + err: "BIGINT value is out of range in -9223372036854775808 - 1", + }, { + v1: sqltypes.NewUint64(4), + v2: sqltypes.NewInt64(5), + err: "BIGINT UNSIGNED value is out of range in 4 - 5", + }, { + // testing uint - int + v1: sqltypes.NewUint64(7), + v2: sqltypes.NewInt64(5), + out: sqltypes.NewUint64(2), + }, { + v1: sqltypes.NewUint64(math.MaxUint64), + v2: sqltypes.NewInt64(0), + out: sqltypes.NewUint64(math.MaxUint64), + }, { + // testing for int64 overflow + v1: sqltypes.NewInt64(math.MinInt64), + v2: sqltypes.NewUint64(0), + err: "BIGINT UNSIGNED value is out of range in -9223372036854775808 - 0", + }, { + v1: sqltypes.TestValue(querypb.Type_VARCHAR, "c"), + v2: sqltypes.NewInt64(1), + out: sqltypes.NewInt64(-1), + }, { + v1: sqltypes.NewUint64(1), + v2: sqltypes.TestValue(querypb.Type_VARCHAR, "c"), + out: sqltypes.NewUint64(1), + }, { + // testing for error for parsing float value to uint64 + v1: sqltypes.TestValue(querypb.Type_UINT64, "1.2"), + v2: sqltypes.NewInt64(2), + err: "strconv.ParseUint: parsing \"1.2\": invalid syntax", + }, { + // testing for error for parsing float value to uint64 + v1: sqltypes.NewUint64(2), + v2: sqltypes.TestValue(querypb.Type_UINT64, "1.2"), + err: "strconv.ParseUint: parsing \"1.2\": invalid syntax", + }, { + // uint64 - uint64 + v1: sqltypes.NewUint64(8), + v2: sqltypes.NewUint64(4), + out: sqltypes.NewUint64(4), + }, { + // testing for float subtraction: float - int + v1: sqltypes.NewFloat64(1.2), + v2: sqltypes.NewInt64(2), + out: sqltypes.NewFloat64(-0.8), + }, { + // testing for float subtraction: float - uint + v1: sqltypes.NewFloat64(1.2), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewFloat64(-0.8), + }, { + v1: sqltypes.NewInt64(-1), + v2: sqltypes.NewUint64(2), + err: "BIGINT UNSIGNED value is out of range in -1 - 2", + }, { + v1: sqltypes.NewInt64(2), + v2: sqltypes.NewUint64(1), + out: sqltypes.NewUint64(1), + }, { + // testing int64 - float64 method + v1: sqltypes.NewInt64(-2), + v2: sqltypes.NewFloat64(1.0), + out: sqltypes.NewFloat64(-3.0), + }, { + // testing uint64 - float64 method + v1: sqltypes.NewUint64(1), + v2: sqltypes.NewFloat64(-2.0), + out: sqltypes.NewFloat64(3.0), + }, { + // testing uint - int to return uintplusint + v1: sqltypes.NewUint64(1), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewUint64(3), + }, { + // testing for float - float + v1: sqltypes.NewFloat64(1.2), + v2: sqltypes.NewFloat64(3.2), + out: sqltypes.NewFloat64(-2), + }, { + // testing uint - uint if v2 > v1 + v1: sqltypes.NewUint64(2), + v2: sqltypes.NewUint64(4), + err: "BIGINT UNSIGNED value is out of range in 2 - 4", + }, { + // testing uint - (- int) + v1: sqltypes.NewUint64(1), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewUint64(3), + }}, + }, { + operator: "+", + f: Add, + cases: []tcase{{ + // All Nulls + v1: sqltypes.NULL, + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // First value null. + v1: sqltypes.NewInt32(1), + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // Second value null. + v1: sqltypes.NULL, + v2: sqltypes.NewInt32(1), + out: sqltypes.NULL, + }, { + // case with negatives + v1: sqltypes.NewInt64(-1), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewInt64(-3), + }, { + // testing for overflow int64, result will be unsigned int + v1: sqltypes.NewInt64(math.MaxInt64), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewUint64(9223372036854775809), + }, { + v1: sqltypes.NewInt64(-2), + v2: sqltypes.NewUint64(1), + err: "BIGINT UNSIGNED value is out of range in 1 + -2", + }, { + v1: sqltypes.NewInt64(math.MaxInt64), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewInt64(9223372036854775805), + }, { + // Normal case + v1: sqltypes.NewUint64(1), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewUint64(3), + }, { + // testing for overflow uint64 + v1: sqltypes.NewUint64(math.MaxUint64), + v2: sqltypes.NewUint64(2), + err: "BIGINT UNSIGNED value is out of range in 18446744073709551615 + 2", + }, { + // int64 underflow + v1: sqltypes.NewInt64(math.MinInt64), + v2: sqltypes.NewInt64(-2), + err: "BIGINT value is out of range in -9223372036854775808 + -2", + }, { + // checking int64 max value can be returned + v1: sqltypes.NewInt64(math.MaxInt64), + v2: sqltypes.NewUint64(0), + out: sqltypes.NewUint64(9223372036854775807), + }, { + // testing whether uint64 max value can be returned + v1: sqltypes.NewUint64(math.MaxUint64), + v2: sqltypes.NewInt64(0), + out: sqltypes.NewUint64(math.MaxUint64), + }, { + v1: sqltypes.NewUint64(math.MaxInt64), + v2: sqltypes.NewInt64(1), + out: sqltypes.NewUint64(9223372036854775808), + }, { + v1: sqltypes.NewUint64(1), + v2: sqltypes.TestValue(querypb.Type_VARCHAR, "c"), + out: sqltypes.NewUint64(1), + }, { + v1: sqltypes.NewUint64(1), + v2: sqltypes.TestValue(querypb.Type_VARCHAR, "1.2"), + out: sqltypes.NewFloat64(2.2), + }, { + v1: sqltypes.TestValue(querypb.Type_INT64, "1.2"), + v2: sqltypes.NewInt64(2), + err: "strconv.ParseInt: parsing \"1.2\": invalid syntax", + }, { + v1: sqltypes.NewInt64(2), + v2: sqltypes.TestValue(querypb.Type_INT64, "1.2"), + err: "strconv.ParseInt: parsing \"1.2\": invalid syntax", + }, { + // testing for uint64 overflow with max uint64 + int value + v1: sqltypes.NewUint64(math.MaxUint64), + v2: sqltypes.NewInt64(2), + err: "BIGINT UNSIGNED value is out of range in 18446744073709551615 + 2", + }}, + }, { + operator: "/", + f: Divide, + cases: []tcase{{ + //All Nulls + v1: sqltypes.NULL, + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // First value null. + v1: sqltypes.NULL, + v2: sqltypes.NewInt32(1), + out: sqltypes.NULL, + }, { + // Second value null. + v1: sqltypes.NewInt32(1), + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // Second arg 0 + v1: sqltypes.NewInt32(5), + v2: sqltypes.NewInt32(0), + out: sqltypes.NULL, + }, { + // Both arguments zero + v1: sqltypes.NewInt32(0), + v2: sqltypes.NewInt32(0), + out: sqltypes.NULL, + }, { + // case with negative value + v1: sqltypes.NewInt64(-1), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewFloat64(0.5000), + }, { + // float64 division by zero + v1: sqltypes.NewFloat64(2), + v2: sqltypes.NewFloat64(0), + out: sqltypes.NULL, + }, { + // Lower bound for int64 + v1: sqltypes.NewInt64(math.MinInt64), + v2: sqltypes.NewInt64(1), + out: sqltypes.NewFloat64(math.MinInt64), + }, { + // upper bound for uint64 + v1: sqltypes.NewUint64(math.MaxUint64), + v2: sqltypes.NewUint64(1), + out: sqltypes.NewFloat64(math.MaxUint64), + }, { + // testing for error in types + v1: sqltypes.TestValue(querypb.Type_INT64, "1.2"), + v2: sqltypes.NewInt64(2), + err: "strconv.ParseInt: parsing \"1.2\": invalid syntax", + }, { + // testing for error in types + v1: sqltypes.NewInt64(2), + v2: sqltypes.TestValue(querypb.Type_INT64, "1.2"), + err: "strconv.ParseInt: parsing \"1.2\": invalid syntax", + }, { + // testing for uint/int + v1: sqltypes.NewUint64(4), + v2: sqltypes.NewInt64(5), + out: sqltypes.NewFloat64(0.8), + }, { + // testing for uint/uint + v1: sqltypes.NewUint64(1), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewFloat64(0.5), + }, { + // testing for float64/int64 + v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewFloat64(-0.6), + }, { + // testing for float64/uint64 + v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewFloat64(0.6), + }, { + // testing for overflow of float64 + v1: sqltypes.NewFloat64(math.MaxFloat64), + v2: sqltypes.NewFloat64(0.5), + err: "BIGINT is out of range in 1.7976931348623157e+308 / 0.5", + }}, + }, { + operator: "*", + f: Multiply, + cases: []tcase{{ + //All Nulls + v1: sqltypes.NULL, + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // First value null. + v1: sqltypes.NewInt32(1), + v2: sqltypes.NULL, + out: sqltypes.NULL, + }, { + // Second value null. + v1: sqltypes.NULL, + v2: sqltypes.NewInt32(1), + out: sqltypes.NULL, + }, { + // case with negative value + v1: sqltypes.NewInt64(-1), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewInt64(2), + }, { + // testing for int64 overflow with min negative value + v1: sqltypes.NewInt64(math.MinInt64), + v2: sqltypes.NewInt64(1), + out: sqltypes.NewInt64(math.MinInt64), + }, { + // testing for error in types + v1: sqltypes.TestValue(querypb.Type_INT64, "1.2"), + v2: sqltypes.NewInt64(2), + err: "strconv.ParseInt: parsing \"1.2\": invalid syntax", + }, { + // testing for error in types + v1: sqltypes.NewInt64(2), + v2: sqltypes.TestValue(querypb.Type_INT64, "1.2"), + err: "strconv.ParseInt: parsing \"1.2\": invalid syntax", + }, { + // testing for uint*int + v1: sqltypes.NewUint64(4), + v2: sqltypes.NewInt64(5), + out: sqltypes.NewUint64(20), + }, { + // testing for uint*uint + v1: sqltypes.NewUint64(1), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewUint64(2), + }, { + // testing for float64*int64 + v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), + v2: sqltypes.NewInt64(-2), + out: sqltypes.NewFloat64(-2.4), + }, { + // testing for float64*uint64 + v1: sqltypes.TestValue(querypb.Type_FLOAT64, "1.2"), + v2: sqltypes.NewUint64(2), + out: sqltypes.NewFloat64(2.4), + }, { + // testing for overflow of int64 + v1: sqltypes.NewInt64(math.MaxInt64), + v2: sqltypes.NewInt64(2), + err: "BIGINT value is out of range in 9223372036854775807 * 2", + }, { + // testing for underflow of uint64*max.uint64 + v1: sqltypes.NewInt64(2), + v2: sqltypes.NewUint64(math.MaxUint64), + err: "BIGINT UNSIGNED value is out of range in 18446744073709551615 * 2", + }, { + v1: sqltypes.NewUint64(math.MaxUint64), + v2: sqltypes.NewUint64(1), + out: sqltypes.NewUint64(math.MaxUint64), + }, { + //Checking whether maxInt value can be passed as uint value + v1: sqltypes.NewUint64(math.MaxInt64), + v2: sqltypes.NewInt64(3), + err: "BIGINT UNSIGNED value is out of range in 9223372036854775807 * 3", + }}, }} - for _, tcase := range tcases { - - got, err := Multiply(tcase.v1, tcase.v2) - - if !vterrors.Equals(err, tcase.err) { - t.Errorf("Multiply(%v, %v) error: %v, want %v", printValue(tcase.v1), printValue(tcase.v2), vterrors.Print(err), vterrors.Print(tcase.err)) - } - if tcase.err != nil { - continue - } - - if !reflect.DeepEqual(got, tcase.out) { - t.Errorf("Multiply(%v, %v): %v, want %v", printValue(tcase.v1), printValue(tcase.v2), printValue(got), printValue(tcase.out)) - } + for _, test := range tests { + t.Run(test.operator, func(t *testing.T) { + for _, tcase := range test.cases { + name := fmt.Sprintf("%s%s%s", tcase.v1.String(), test.operator, tcase.v2.String()) + t.Run(name, func(t *testing.T) { + got, err := test.f(tcase.v1, tcase.v2) + if tcase.err == "" { + require.NoError(t, err) + require.Equal(t, tcase.out, got) + } else { + require.EqualError(t, err, tcase.err) + } + }) + } + }) } - -} - -func TestSubtract(t *testing.T) { - tcases := []struct { - v1, v2 sqltypes.Value - out sqltypes.Value - err error - }{{ - // All Nulls - v1: sqltypes.NULL, - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // First value null. - v1: sqltypes.NewInt32(1), - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // Second value null. - v1: sqltypes.NULL, - v2: sqltypes.NewInt32(1), - out: sqltypes.NULL, - }, { - // case with negative value - v1: sqltypes.NewInt64(-1), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewInt64(1), - }, { - // testing for int64 overflow with min negative value - v1: sqltypes.NewInt64(math.MinInt64), - v2: sqltypes.NewInt64(1), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT value is out of range in -9223372036854775808 - 1"), - }, { - v1: sqltypes.NewUint64(4), - v2: sqltypes.NewInt64(5), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 4 - 5"), - }, { - // testing uint - int - v1: sqltypes.NewUint64(7), - v2: sqltypes.NewInt64(5), - out: sqltypes.NewUint64(2), - }, { - v1: sqltypes.NewUint64(math.MaxUint64), - v2: sqltypes.NewInt64(0), - out: sqltypes.NewUint64(math.MaxUint64), - }, { - // testing for int64 overflow - v1: sqltypes.NewInt64(math.MinInt64), - v2: sqltypes.NewUint64(0), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in -9223372036854775808 - 0"), - }, { - v1: sqltypes.TestValue(querypb.Type_VARCHAR, "c"), - v2: sqltypes.NewInt64(1), - out: sqltypes.NewInt64(-1), - }, { - v1: sqltypes.NewUint64(1), - v2: sqltypes.TestValue(querypb.Type_VARCHAR, "c"), - out: sqltypes.NewUint64(1), - }, { - // testing for error for parsing float value to uint64 - v1: sqltypes.TestValue(querypb.Type_UINT64, "1.2"), - v2: sqltypes.NewInt64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseUint: parsing \"1.2\": invalid syntax"), - }, { - // testing for error for parsing float value to uint64 - v1: sqltypes.NewUint64(2), - v2: sqltypes.TestValue(querypb.Type_UINT64, "1.2"), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseUint: parsing \"1.2\": invalid syntax"), - }, { - // uint64 - uint64 - v1: sqltypes.NewUint64(8), - v2: sqltypes.NewUint64(4), - out: sqltypes.NewUint64(4), - }, { - // testing for float subtraction: float - int - v1: sqltypes.NewFloat64(1.2), - v2: sqltypes.NewInt64(2), - out: sqltypes.NewFloat64(-0.8), - }, { - // testing for float subtraction: float - uint - v1: sqltypes.NewFloat64(1.2), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewFloat64(-0.8), - }, { - v1: sqltypes.NewInt64(-1), - v2: sqltypes.NewUint64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in -1 - 2"), - }, { - v1: sqltypes.NewInt64(2), - v2: sqltypes.NewUint64(1), - out: sqltypes.NewUint64(1), - }, { - // testing int64 - float64 method - v1: sqltypes.NewInt64(-2), - v2: sqltypes.NewFloat64(1.0), - out: sqltypes.NewFloat64(-3.0), - }, { - // testing uint64 - float64 method - v1: sqltypes.NewUint64(1), - v2: sqltypes.NewFloat64(-2.0), - out: sqltypes.NewFloat64(3.0), - }, { - // testing uint - int to return uintplusint - v1: sqltypes.NewUint64(1), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewUint64(3), - }, { - // testing for float - float - v1: sqltypes.NewFloat64(1.2), - v2: sqltypes.NewFloat64(3.2), - out: sqltypes.NewFloat64(-2), - }, { - // testing uint - uint if v2 > v1 - v1: sqltypes.NewUint64(2), - v2: sqltypes.NewUint64(4), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 2 - 4"), - }, { - // testing uint - (- int) - v1: sqltypes.NewUint64(1), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewUint64(3), - }} - - for _, tcase := range tcases { - - got, err := Subtract(tcase.v1, tcase.v2) - - if !vterrors.Equals(err, tcase.err) { - t.Errorf("Subtract(%v, %v) error: %v, want %v", printValue(tcase.v1), printValue(tcase.v2), vterrors.Print(err), vterrors.Print(tcase.err)) - } - if tcase.err != nil { - continue - } - - if !reflect.DeepEqual(got, tcase.out) { - t.Errorf("Subtract(%v, %v): %v, want %v", printValue(tcase.v1), printValue(tcase.v2), printValue(got), printValue(tcase.out)) - } - } - -} - -func TestAdd(t *testing.T) { - tcases := []struct { - v1, v2 sqltypes.Value - out sqltypes.Value - err error - }{{ - // All Nulls - v1: sqltypes.NULL, - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // First value null. - v1: sqltypes.NewInt32(1), - v2: sqltypes.NULL, - out: sqltypes.NULL, - }, { - // Second value null. - v1: sqltypes.NULL, - v2: sqltypes.NewInt32(1), - out: sqltypes.NULL, - }, { - // case with negatives - v1: sqltypes.NewInt64(-1), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewInt64(-3), - }, { - // testing for overflow int64, result will be unsigned int - v1: sqltypes.NewInt64(math.MaxInt64), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewUint64(9223372036854775809), - }, { - v1: sqltypes.NewInt64(-2), - v2: sqltypes.NewUint64(1), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 1 + -2"), - }, { - v1: sqltypes.NewInt64(math.MaxInt64), - v2: sqltypes.NewInt64(-2), - out: sqltypes.NewInt64(9223372036854775805), - }, { - // Normal case - v1: sqltypes.NewUint64(1), - v2: sqltypes.NewUint64(2), - out: sqltypes.NewUint64(3), - }, { - // testing for overflow uint64 - v1: sqltypes.NewUint64(math.MaxUint64), - v2: sqltypes.NewUint64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 18446744073709551615 + 2"), - }, { - // int64 underflow - v1: sqltypes.NewInt64(math.MinInt64), - v2: sqltypes.NewInt64(-2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT value is out of range in -9223372036854775808 + -2"), - }, { - // checking int64 max value can be returned - v1: sqltypes.NewInt64(math.MaxInt64), - v2: sqltypes.NewUint64(0), - out: sqltypes.NewUint64(9223372036854775807), - }, { - // testing whether uint64 max value can be returned - v1: sqltypes.NewUint64(math.MaxUint64), - v2: sqltypes.NewInt64(0), - out: sqltypes.NewUint64(math.MaxUint64), - }, { - v1: sqltypes.NewUint64(math.MaxInt64), - v2: sqltypes.NewInt64(1), - out: sqltypes.NewUint64(9223372036854775808), - }, { - v1: sqltypes.NewUint64(1), - v2: sqltypes.TestValue(querypb.Type_VARCHAR, "c"), - out: sqltypes.NewUint64(1), - }, { - v1: sqltypes.NewUint64(1), - v2: sqltypes.TestValue(querypb.Type_VARCHAR, "1.2"), - out: sqltypes.NewFloat64(2.2), - }, { - v1: sqltypes.TestValue(querypb.Type_INT64, "1.2"), - v2: sqltypes.NewInt64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseInt: parsing \"1.2\": invalid syntax"), - }, { - v1: sqltypes.NewInt64(2), - v2: sqltypes.TestValue(querypb.Type_INT64, "1.2"), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "strconv.ParseInt: parsing \"1.2\": invalid syntax"), - }, { - // testing for uint64 overflow with max uint64 + int value - v1: sqltypes.NewUint64(math.MaxUint64), - v2: sqltypes.NewInt64(2), - err: vterrors.New(vtrpcpb.Code_INVALID_ARGUMENT, "BIGINT UNSIGNED value is out of range in 18446744073709551615 + 2"), - }} - - for _, tcase := range tcases { - - got, err := Add(tcase.v1, tcase.v2) - - if !vterrors.Equals(err, tcase.err) { - t.Errorf("Add(%v, %v) error: %v, want %v", printValue(tcase.v1), printValue(tcase.v2), vterrors.Print(err), vterrors.Print(tcase.err)) - } - if tcase.err != nil { - continue - } - - if !reflect.DeepEqual(got, tcase.out) { - t.Errorf("Add(%v, %v): %v, want %v", printValue(tcase.v1), printValue(tcase.v2), printValue(got), printValue(tcase.out)) - } - } - } func TestNullsafeAdd(t *testing.T) {