github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/common/dtypeutils/dtypeutils_test.go (about) 1 /* 2 Copyright 2023. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package dtypeutils 18 19 import ( 20 "math" 21 "testing" 22 23 "github.com/stretchr/testify/assert" 24 ) 25 26 func Test_convertExpToType(t *testing.T) { 27 28 _, err := ConvertExpToType(float64(123.123), uint8(12)) 29 assert.NotNil(t, err, "test cannot convert 123.123 to uint") 30 31 val, err := ConvertExpToType(float64(10), uint8(12)) 32 assert.Nil(t, err) // can convert 123 to uint 33 assert.Equal(t, val, uint8(10), "test conversion of 123 to uint") 34 35 } 36 37 // TODO: test cases for all arithmetic functions 38 // TODO: test cases for regex & string searching 39 func Test_divide(t *testing.T) { 40 41 _, err := Divide(uint32(10), uint32(0)) 42 //errstrng := "cannot divide by zero" 43 //assert.EqualError(t, err, errstrng) 44 assert.NotNil(t, err) 45 46 val, err := Divide(float64(math.MaxFloat64-2), float64(0.5)) 47 assert.NotNil(t, err) 48 assert.Equal(t, val, float64(math.Inf(1))) 49 50 val, err = Divide(float64(math.MaxFloat64-2), float64(-0.5)) 51 assert.NotNil(t, err) 52 assert.Equal(t, val, float64(math.Inf(-1))) 53 54 val, err = Divide(int64(64), int64(4)) 55 assert.Nil(t, err) 56 assert.Equal(t, val, int64(16)) 57 58 } 59 60 func Test_modulo(t *testing.T) { 61 62 _, err := Modulo(int8(10), int8(0)) 63 assert.NotNil(t, err) 64 65 val, err := Modulo(uint8(25), uint8(2)) 66 assert.Nil(t, err) 67 assert.Equal(t, val, uint8(1)) 68 } 69 70 func Test_multiply(t *testing.T) { 71 72 val, err := Multiply(uint8(254), uint8(2)) 73 assert.Equal(t, uint16(508), val) 74 assert.Nil(t, err) 75 val, err = Multiply(uint16(65532), uint16(3)) 76 assert.Equal(t, uint32(196596), val) 77 assert.Nil(t, err) 78 val, err = Multiply(uint32(4294967295), uint32(2)) 79 assert.Equal(t, uint64(8589934590), val) 80 assert.Nil(t, err) 81 val, err = Multiply(uint64(18446744073709551615), uint64(2)) 82 assert.Equal(t, uint64(18446744073709551614), val) 83 assert.Nil(t, err) 84 val, err = Multiply(int8(127), int8(2)) 85 assert.Equal(t, int16(254), val) 86 assert.Nil(t, err) 87 val, err = Multiply(int8(-128), int8(2)) 88 assert.Equal(t, int16(-256), val) 89 assert.Nil(t, err) 90 val, err = Multiply(int16(32767), int16(3)) 91 assert.Equal(t, int32(98301), val) 92 assert.Nil(t, err) 93 val, err = Multiply(int16(-32768), int16(3)) 94 assert.Equal(t, int32(-98304), val) 95 assert.Nil(t, err) 96 val, err = Multiply(int32(2147483647), int32(3)) 97 assert.Equal(t, int64(6442450941), val) 98 assert.Nil(t, err) 99 val, err = Multiply(int32(-2147483648), int32(2)) 100 assert.Equal(t, int64(-4294967296), val) 101 assert.Nil(t, err) 102 val, err = Multiply(int64(9223372036854775807), int64(2)) 103 assert.Equal(t, int64(-2), val) 104 assert.NotNil(t, err) 105 val, err = Multiply(int64(-9223372036854775808), int64(3)) 106 assert.Equal(t, int64(-9223372036854775808), val) 107 assert.NotNil(t, err) 108 val, err = Multiply(float64(1.7e+308), float64(2)) 109 assert.Equal(t, float64(math.Inf(1)), val) 110 assert.NotNil(t, err) 111 val, err = Multiply(float64(-1.7e+308), float64(3)) 112 assert.Equal(t, (float64(math.Inf(-1))), val) 113 assert.NotNil(t, err) 114 val, err = Multiply(int8(10), int8(2)) 115 assert.Nil(t, err) 116 assert.Equal(t, val, int16(20)) 117 val, err = Multiply(uint8(255), uint8(0)) 118 assert.Nil(t, err) 119 assert.Equal(t, uint16(0), val) 120 val, err = Multiply(uint16(65535), uint16(0)) 121 assert.Nil(t, err) 122 assert.Equal(t, uint32(0), val) 123 val, err = Multiply(uint32(4294967295), uint32(0)) 124 assert.Nil(t, err) 125 assert.Equal(t, uint64(0), val) 126 val, err = Multiply(uint64(18446744073709551615), uint64(0)) 127 assert.Nil(t, err) 128 assert.Equal(t, uint64(0), val) 129 } 130 131 func Test_add(t *testing.T) { 132 val, err := Add(uint8(255), uint8(255)) 133 assert.Equal(t, uint8(254), val) 134 assert.NotNil(t, err) 135 val, err = Add(uint16(65535), uint16(255)) 136 assert.Equal(t, uint16(254), val) 137 assert.NotNil(t, err) 138 val, err = Add(uint32(4294967295), uint32(250)) 139 assert.Equal(t, uint32(249), val) 140 assert.NotNil(t, err) 141 val, err = Add(uint64(18446744073709551615), uint64(250)) 142 assert.Equal(t, uint64(249), val) 143 assert.NotNil(t, err) 144 val, err = Add(int8(127), int8(127)) 145 assert.Equal(t, int8(-2), val) 146 assert.NotNil(t, err) 147 val, err = Add(int8(-128), int8(-128)) 148 assert.Equal(t, int8(0), val) 149 assert.NotNil(t, err) 150 val, err = Add(int16(32767), int16(10)) 151 assert.Equal(t, int16(-32759), val) 152 assert.NotNil(t, err) 153 val, err = Add(int16(-32768), int16(-10)) 154 assert.Equal(t, int16(32758), val) 155 assert.NotNil(t, err) 156 val, err = Add(int32(2147483647), int32(1)) 157 assert.Equal(t, int32(-2147483648), val) 158 assert.NotNil(t, err) 159 val, err = Add(int32(-2147483648), int32(-10)) 160 assert.Equal(t, int32(2147483638), val) 161 assert.NotNil(t, err) 162 val, err = Add(int64(9223372036854775807), int64(1)) 163 assert.Equal(t, int64(-9223372036854775808), val) 164 assert.NotNil(t, err) 165 val, err = Add(int64(-9223372036854775808), int64(-1)) 166 assert.Equal(t, int64(9223372036854775807), val) 167 assert.NotNil(t, err) 168 val, err = Add(float64(1.7e+308), float64(1.7e+308)) 169 assert.Equal(t, float64(math.Inf(1)), val) 170 assert.NotNil(t, err) 171 val, err = Add(float64(-1.7e+308), float64(-1.7e+308)) 172 assert.Equal(t, float64(float64(math.Inf(-1))), val) 173 assert.NotNil(t, err) 174 val, err = Add(int8(10), int8(2)) 175 assert.Nil(t, err) 176 assert.Equal(t, val, int8(12)) 177 } 178 func Test_subtract(t *testing.T) { 179 val, err := Subtract(uint8(0), uint8(255)) 180 assert.Equal(t, uint8(1), val) 181 assert.NotNil(t, err) 182 val, err = Subtract(uint16(10), uint16(65535)) 183 assert.Equal(t, uint16(11), val) 184 assert.NotNil(t, err) 185 val, err = Subtract(uint32(25), uint32(4294967295)) 186 assert.Equal(t, uint32(26), val) 187 assert.NotNil(t, err) 188 val, err = Subtract(uint64(25), uint64(18446744073709551615)) 189 assert.Equal(t, uint64(26), val) 190 assert.NotNil(t, err) 191 val, err = Subtract(int8(127), int8(-10)) 192 assert.Equal(t, int8(-119), val) 193 assert.NotNil(t, err) 194 val, err = Subtract(int8(-128), int8(10)) 195 assert.Equal(t, int8(118), val) 196 assert.NotNil(t, err) 197 val, err = Subtract(int16(32767), int16(-10)) 198 assert.Equal(t, int16(-32759), val) 199 assert.NotNil(t, err) 200 val, err = Subtract(int16(-32768), int16(10)) 201 assert.Equal(t, int16(32758), val) 202 assert.NotNil(t, err) 203 val, err = Subtract(int32(2147483647), int32(-10)) 204 assert.Equal(t, int32(-2147483639), val) 205 assert.NotNil(t, err) 206 val, err = Subtract(int32(-2147483648), int32(10)) 207 assert.Equal(t, int32(2147483638), val) 208 assert.NotNil(t, err) 209 val, err = Subtract(int64(9223372036854775807), int64(-10)) 210 assert.Equal(t, int64(-9223372036854775799), val) 211 assert.NotNil(t, err) 212 val, err = Subtract(int64(-9223372036854775808), int64(10)) 213 assert.Equal(t, int64(9223372036854775798), val) 214 assert.NotNil(t, err) 215 val, err = Subtract(float64(1.7e+308), float64(-1.7e+308)) 216 assert.Equal(t, float64(float64(math.Inf(1))), val) 217 assert.NotNil(t, err) 218 val, err = Subtract(float64(-1.7e+308), float64(1.7e+308)) 219 assert.Equal(t, float64(float64(math.Inf(-1))), val) 220 assert.NotNil(t, err) 221 val, err = Subtract(int8(10), int8(2)) 222 assert.Nil(t, err) 223 assert.Equal(t, val, int8(8)) 224 }