github.com/hasnat/dolt/go@v0.0.0-20210628190320-9eb5d843fbb7/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  	"testing"
    19  	"time"
    20  
    21  	"github.com/stretchr/testify/assert"
    22  	"github.com/stretchr/testify/require"
    23  
    24  	"github.com/dolthub/dolt/go/store/types"
    25  )
    26  
    27  func getMustBool(t *testing.T) func(bool, error) bool {
    28  	return func(b bool, e error) bool {
    29  		require.NoError(t, e)
    30  		return b
    31  	}
    32  }
    33  
    34  var jan11990 = time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)
    35  
    36  func TestCompareNomsValues(t *testing.T) {
    37  	tests := []struct {
    38  		name string
    39  		v1   types.Value
    40  		v2   types.Value
    41  		gt   bool
    42  		gte  bool
    43  		lt   bool
    44  		lte  bool
    45  		eq   bool
    46  	}{
    47  		{
    48  			name: "int 1 and int 1",
    49  			v1:   types.Int(1),
    50  			v2:   types.Int(1),
    51  			gt:   false,
    52  			gte:  true,
    53  			lt:   false,
    54  			lte:  true,
    55  			eq:   true,
    56  		},
    57  		{
    58  			name: "int -1 and int -1",
    59  			v1:   types.Int(-1),
    60  			v2:   types.Int(1),
    61  			gt:   false,
    62  			gte:  false,
    63  			lt:   true,
    64  			lte:  true,
    65  			eq:   false,
    66  		},
    67  		{
    68  			name: "int 0 int -5",
    69  			v1:   types.Int(0),
    70  			v2:   types.Int(-5),
    71  			gt:   true,
    72  			gte:  true,
    73  			lt:   false,
    74  			lte:  false,
    75  			eq:   false,
    76  		},
    77  	}
    78  
    79  	eqOp := EqualsOp{}
    80  	gtOp := GreaterOp{}
    81  	gteOp := GreaterEqualOp{}
    82  	ltOp := LessOp{}
    83  	lteOp := LessEqualOp{}
    84  
    85  	for _, test := range tests {
    86  		t.Run(test.name, func(t *testing.T) {
    87  			mustBool := getMustBool(t)
    88  			resEq := mustBool(eqOp.CompareNomsValues(test.v1, test.v2))
    89  			resGt := mustBool(gtOp.CompareNomsValues(test.v1, test.v2))
    90  			resGte := mustBool(gteOp.CompareNomsValues(test.v1, test.v2))
    91  			resLt := mustBool(ltOp.CompareNomsValues(test.v1, test.v2))
    92  			resLte := mustBool(lteOp.CompareNomsValues(test.v1, test.v2))
    93  
    94  			assert.True(t, resEq == test.eq, "equals failure. Expected: %t Actual %t", test.lte, resLte)
    95  			assert.True(t, resGt == test.gt, "greater failure. Expected: %t Actual %t", test.lte, resLte)
    96  			assert.True(t, resGte == test.gte, "greater equals failure. Expected: %t Actual %t", test.lte, resLte)
    97  			assert.True(t, resLt == test.lt, "less than failure. Expected: %t Actual %t", test.lte, resLte)
    98  			assert.True(t, resLte == test.lte, "less than equals failure. Expected: %t Actual %t", test.lte, resLte)
    99  		})
   100  	}
   101  }
   102  
   103  func assertOnUnexpectedErr(t *testing.T, expectErr bool, err error) {
   104  	if expectErr {
   105  		assert.Error(t, err)
   106  	} else {
   107  		assert.NoError(t, err)
   108  	}
   109  }
   110  
   111  func TestCompareToNull(t *testing.T) {
   112  	tests := []struct {
   113  		name string
   114  		v    types.Value
   115  		gt   bool
   116  		gte  bool
   117  		lt   bool
   118  		lte  bool
   119  		eq   bool
   120  	}{
   121  		{
   122  			name: "nil not equal to nil",
   123  			v:    types.NullValue,
   124  			gt:   false,
   125  			gte:  false,
   126  			lt:   false,
   127  			lte:  false,
   128  			eq:   false,
   129  		},
   130  		{
   131  			name: "not nil",
   132  			v:    types.Int(5),
   133  			gt:   false,
   134  			gte:  false,
   135  			lt:   false,
   136  			lte:  false,
   137  			eq:   false,
   138  		},
   139  	}
   140  
   141  	eqOp := EqualsOp{}
   142  	gtOp := GreaterOp{}
   143  	gteOp := GreaterEqualOp{}
   144  	ltOp := LessOp{}
   145  	lteOp := LessEqualOp{}
   146  
   147  	for _, test := range tests {
   148  		t.Run(test.name, func(t *testing.T) {
   149  			mustBool := getMustBool(t)
   150  			resEq := mustBool(eqOp.CompareToNil(test.v))
   151  			resGt := mustBool(gtOp.CompareToNil(test.v))
   152  			resGte := mustBool(gteOp.CompareToNil(test.v))
   153  			resLt := mustBool(ltOp.CompareToNil(test.v))
   154  			resLte := mustBool(lteOp.CompareToNil(test.v))
   155  
   156  			assert.True(t, resEq == test.eq, "equals failure. Expected: %t Actual %t", test.lte, resLte)
   157  			assert.True(t, resGt == test.gt, "greater failure. Expected: %t Actual %t", test.lte, resLte)
   158  			assert.True(t, resGte == test.gte, "greater equals failure. Expected: %t Actual %t", test.lte, resLte)
   159  			assert.True(t, resLt == test.lt, "less than failure. Expected: %t Actual %t", test.lte, resLte)
   160  			assert.True(t, resLte == test.lte, "less than equals failure. Expected: %t Actual %t", test.lte, resLte)
   161  		})
   162  	}
   163  }