github.com/whatlly/hugo@v0.47.1/tpl/math/math_test.go (about) 1 // Copyright 2017 The Hugo Authors. All rights reserved. 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 // http://www.apache.org/licenses/LICENSE-2.0 7 // 8 // Unless required by applicable law or agreed to in writing, software 9 // distributed under the License is distributed on an "AS IS" BASIS, 10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 package math 15 16 import ( 17 "fmt" 18 "math" 19 "testing" 20 21 "github.com/stretchr/testify/assert" 22 "github.com/stretchr/testify/require" 23 ) 24 25 func TestBasicNSArithmetic(t *testing.T) { 26 t.Parallel() 27 28 ns := New() 29 30 for i, test := range []struct { 31 fn func(a, b interface{}) (interface{}, error) 32 a interface{} 33 b interface{} 34 expect interface{} 35 }{ 36 {ns.Add, 4, 2, int64(6)}, 37 {ns.Add, 1.0, "foo", false}, 38 {ns.Sub, 4, 2, int64(2)}, 39 {ns.Sub, 1.0, "foo", false}, 40 {ns.Mul, 4, 2, int64(8)}, 41 {ns.Mul, 1.0, "foo", false}, 42 {ns.Div, 4, 2, int64(2)}, 43 {ns.Div, 1.0, "foo", false}, 44 } { 45 errMsg := fmt.Sprintf("[%d] %v", i, test) 46 47 result, err := test.fn(test.a, test.b) 48 49 if b, ok := test.expect.(bool); ok && !b { 50 require.Error(t, err, errMsg) 51 continue 52 } 53 54 require.NoError(t, err, errMsg) 55 assert.Equal(t, test.expect, result, errMsg) 56 } 57 } 58 59 func TestCeil(t *testing.T) { 60 t.Parallel() 61 62 ns := New() 63 64 for i, test := range []struct { 65 x interface{} 66 expect interface{} 67 }{ 68 {0.1, 1.0}, 69 {0.5, 1.0}, 70 {1.1, 2.0}, 71 {1.5, 2.0}, 72 {-0.1, 0.0}, 73 {-0.5, 0.0}, 74 {-1.1, -1.0}, 75 {-1.5, -1.0}, 76 {"abc", false}, 77 } { 78 errMsg := fmt.Sprintf("[%d] %v", i, test) 79 80 result, err := ns.Ceil(test.x) 81 82 if b, ok := test.expect.(bool); ok && !b { 83 require.Error(t, err, errMsg) 84 continue 85 } 86 87 require.NoError(t, err, errMsg) 88 assert.Equal(t, test.expect, result, errMsg) 89 } 90 } 91 92 func TestFloor(t *testing.T) { 93 t.Parallel() 94 95 ns := New() 96 97 for i, test := range []struct { 98 x interface{} 99 expect interface{} 100 }{ 101 {0.1, 0.0}, 102 {0.5, 0.0}, 103 {1.1, 1.0}, 104 {1.5, 1.0}, 105 {-0.1, -1.0}, 106 {-0.5, -1.0}, 107 {-1.1, -2.0}, 108 {-1.5, -2.0}, 109 {"abc", false}, 110 } { 111 errMsg := fmt.Sprintf("[%d] %v", i, test) 112 113 result, err := ns.Floor(test.x) 114 115 if b, ok := test.expect.(bool); ok && !b { 116 require.Error(t, err, errMsg) 117 continue 118 } 119 120 require.NoError(t, err, errMsg) 121 assert.Equal(t, test.expect, result, errMsg) 122 } 123 } 124 125 func TestLog(t *testing.T) { 126 t.Parallel() 127 128 ns := New() 129 130 for i, test := range []struct { 131 a interface{} 132 expect interface{} 133 }{ 134 {1, float64(0)}, 135 {3, float64(1.0986)}, 136 {0, float64(math.Inf(-1))}, 137 {1.0, float64(0)}, 138 {3.1, float64(1.1314)}, 139 {"abc", false}, 140 } { 141 errMsg := fmt.Sprintf("[%d] %v", i, test) 142 143 result, err := ns.Log(test.a) 144 145 if b, ok := test.expect.(bool); ok && !b { 146 require.Error(t, err, errMsg) 147 continue 148 } 149 150 // we compare only 4 digits behind point if its a real float 151 // otherwise we usually get different float values on the last positions 152 if result != math.Inf(-1) { 153 result = float64(int(result*10000)) / 10000 154 } 155 156 require.NoError(t, err, errMsg) 157 assert.Equal(t, test.expect, result, errMsg) 158 } 159 } 160 161 func TestMod(t *testing.T) { 162 t.Parallel() 163 164 ns := New() 165 166 for i, test := range []struct { 167 a interface{} 168 b interface{} 169 expect interface{} 170 }{ 171 {3, 2, int64(1)}, 172 {3, 1, int64(0)}, 173 {3, 0, false}, 174 {0, 3, int64(0)}, 175 {3.1, 2, int64(1)}, 176 {3, 2.1, int64(1)}, 177 {3.1, 2.1, int64(1)}, 178 {int8(3), int8(2), int64(1)}, 179 {int16(3), int16(2), int64(1)}, 180 {int32(3), int32(2), int64(1)}, 181 {int64(3), int64(2), int64(1)}, 182 {"3", "2", int64(1)}, 183 {"3.1", "2", false}, 184 {"aaa", "0", false}, 185 {"3", "aaa", false}, 186 } { 187 errMsg := fmt.Sprintf("[%d] %v", i, test) 188 189 result, err := ns.Mod(test.a, test.b) 190 191 if b, ok := test.expect.(bool); ok && !b { 192 require.Error(t, err, errMsg) 193 continue 194 } 195 196 require.NoError(t, err, errMsg) 197 assert.Equal(t, test.expect, result, errMsg) 198 } 199 } 200 201 func TestModBool(t *testing.T) { 202 t.Parallel() 203 204 ns := New() 205 206 for i, test := range []struct { 207 a interface{} 208 b interface{} 209 expect interface{} 210 }{ 211 {3, 3, true}, 212 {3, 2, false}, 213 {3, 1, true}, 214 {3, 0, nil}, 215 {0, 3, true}, 216 {3.1, 2, false}, 217 {3, 2.1, false}, 218 {3.1, 2.1, false}, 219 {int8(3), int8(3), true}, 220 {int8(3), int8(2), false}, 221 {int16(3), int16(3), true}, 222 {int16(3), int16(2), false}, 223 {int32(3), int32(3), true}, 224 {int32(3), int32(2), false}, 225 {int64(3), int64(3), true}, 226 {int64(3), int64(2), false}, 227 {"3", "3", true}, 228 {"3", "2", false}, 229 {"3.1", "2", nil}, 230 {"aaa", "0", nil}, 231 {"3", "aaa", nil}, 232 } { 233 errMsg := fmt.Sprintf("[%d] %v", i, test) 234 235 result, err := ns.ModBool(test.a, test.b) 236 237 if test.expect == nil { 238 require.Error(t, err, errMsg) 239 continue 240 } 241 242 require.NoError(t, err, errMsg) 243 assert.Equal(t, test.expect, result, errMsg) 244 } 245 } 246 247 func TestRound(t *testing.T) { 248 t.Parallel() 249 250 ns := New() 251 252 for i, test := range []struct { 253 x interface{} 254 expect interface{} 255 }{ 256 {0.1, 0.0}, 257 {0.5, 1.0}, 258 {1.1, 1.0}, 259 {1.5, 2.0}, 260 {-0.1, -0.0}, 261 {-0.5, -1.0}, 262 {-1.1, -1.0}, 263 {-1.5, -2.0}, 264 {"abc", false}, 265 } { 266 errMsg := fmt.Sprintf("[%d] %v", i, test) 267 268 result, err := ns.Round(test.x) 269 270 if b, ok := test.expect.(bool); ok && !b { 271 require.Error(t, err, errMsg) 272 continue 273 } 274 275 require.NoError(t, err, errMsg) 276 assert.Equal(t, test.expect, result, errMsg) 277 } 278 }