github.com/dolthub/dolt/go@v0.40.5-0.20240520175717-68db7794bea6/libraries/doltcore/sqle/expreval/compare_ops_test.go (about)

     1  // Copyright 2020 Dolthub, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package expreval
    16  
    17  import (
    18  	"context"
    19  	"testing"
    20  	"time"
    21  
    22  	"github.com/stretchr/testify/assert"
    23  	"github.com/stretchr/testify/require"
    24  
    25  	"github.com/dolthub/dolt/go/store/types"
    26  )
    27  
    28  func getMustBool(t *testing.T) func(bool, error) bool {
    29  	return func(b bool, e error) bool {
    30  		require.NoError(t, e)
    31  		return b
    32  	}
    33  }
    34  
    35  var jan11990 = time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)
    36  
    37  func TestCompareNomsValues(t *testing.T) {
    38  	tests := []struct {
    39  		name string
    40  		v1   types.Value
    41  		v2   types.Value
    42  		gt   bool
    43  		gte  bool
    44  		lt   bool
    45  		lte  bool
    46  		eq   bool
    47  	}{
    48  		{
    49  			name: "int 1 and int 1",
    50  			v1:   types.Int(1),
    51  			v2:   types.Int(1),
    52  			gt:   false,
    53  			gte:  true,
    54  			lt:   false,
    55  			lte:  true,
    56  			eq:   true,
    57  		},
    58  		{
    59  			name: "int -1 and int -1",
    60  			v1:   types.Int(-1),
    61  			v2:   types.Int(1),
    62  			gt:   false,
    63  			gte:  false,
    64  			lt:   true,
    65  			lte:  true,
    66  			eq:   false,
    67  		},
    68  		{
    69  			name: "int 0 int -5",
    70  			v1:   types.Int(0),
    71  			v2:   types.Int(-5),
    72  			gt:   true,
    73  			gte:  true,
    74  			lt:   false,
    75  			lte:  false,
    76  			eq:   false,
    77  		},
    78  	}
    79  
    80  	vrw := types.NewMemoryValueStore()
    81  	eqOp := EqualsOp{}
    82  	gtOp := GreaterOp{vrw}
    83  	gteOp := GreaterEqualOp{vrw}
    84  	ltOp := LessOp{vrw}
    85  	lteOp := LessEqualOp{vrw}
    86  	ctx := context.Background()
    87  
    88  	for _, test := range tests {
    89  		t.Run(test.name, func(t *testing.T) {
    90  			mustBool := getMustBool(t)
    91  			resEq := mustBool(eqOp.CompareNomsValues(ctx, test.v1, test.v2))
    92  			resGt := mustBool(gtOp.CompareNomsValues(ctx, test.v1, test.v2))
    93  			resGte := mustBool(gteOp.CompareNomsValues(ctx, test.v1, test.v2))
    94  			resLt := mustBool(ltOp.CompareNomsValues(ctx, test.v1, test.v2))
    95  			resLte := mustBool(lteOp.CompareNomsValues(ctx, test.v1, test.v2))
    96  
    97  			assert.True(t, resEq == test.eq, "equals failure. Expected: %t Actual %t", test.lte, resLte)
    98  			assert.True(t, resGt == test.gt, "greater failure. Expected: %t Actual %t", test.lte, resLte)
    99  			assert.True(t, resGte == test.gte, "greater equals failure. Expected: %t Actual %t", test.lte, resLte)
   100  			assert.True(t, resLt == test.lt, "less than failure. Expected: %t Actual %t", test.lte, resLte)
   101  			assert.True(t, resLte == test.lte, "less than equals failure. Expected: %t Actual %t", test.lte, resLte)
   102  		})
   103  	}
   104  }
   105  
   106  func assertOnUnexpectedErr(t *testing.T, expectErr bool, err error) {
   107  	if expectErr {
   108  		assert.Error(t, err)
   109  	} else {
   110  		assert.NoError(t, err)
   111  	}
   112  }
   113  
   114  func TestCompareToNull(t *testing.T) {
   115  	tests := []struct {
   116  		name string
   117  		v    types.Value
   118  		gt   bool
   119  		gte  bool
   120  		lt   bool
   121  		lte  bool
   122  		eq   bool
   123  	}{
   124  		{
   125  			name: "nil not equal to nil",
   126  			v:    types.NullValue,
   127  			gt:   false,
   128  			gte:  false,
   129  			lt:   false,
   130  			lte:  false,
   131  			eq:   true,
   132  		},
   133  		{
   134  			name: "not nil",
   135  			v:    types.Int(5),
   136  			gt:   false,
   137  			gte:  false,
   138  			lt:   false,
   139  			lte:  false,
   140  			eq:   false,
   141  		},
   142  	}
   143  
   144  	eqOp := EqualsOp{}
   145  	gtOp := GreaterOp{}
   146  	gteOp := GreaterEqualOp{}
   147  	ltOp := LessOp{}
   148  	lteOp := LessEqualOp{}
   149  
   150  	for _, test := range tests {
   151  		t.Run(test.name, func(t *testing.T) {
   152  			mustBool := getMustBool(t)
   153  			resEq := mustBool(eqOp.CompareToNil(test.v))
   154  			resGt := mustBool(gtOp.CompareToNil(test.v))
   155  			resGte := mustBool(gteOp.CompareToNil(test.v))
   156  			resLt := mustBool(ltOp.CompareToNil(test.v))
   157  			resLte := mustBool(lteOp.CompareToNil(test.v))
   158  
   159  			assert.True(t, resEq == test.eq, "equals failure. Expected: %t Actual %t", test.lte, resLte)
   160  			assert.True(t, resGt == test.gt, "greater failure. Expected: %t Actual %t", test.lte, resLte)
   161  			assert.True(t, resGte == test.gte, "greater equals failure. Expected: %t Actual %t", test.lte, resLte)
   162  			assert.True(t, resLt == test.lt, "less than failure. Expected: %t Actual %t", test.lte, resLte)
   163  			assert.True(t, resLte == test.lte, "less than equals failure. Expected: %t Actual %t", test.lte, resLte)
   164  		})
   165  	}
   166  }