code.gitea.io/gitea@v1.22.3/modules/templates/eval/eval_test.go (about)

     1  // Copyright 2023 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package eval
     5  
     6  import (
     7  	"math"
     8  	"strings"
     9  	"testing"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func tokens(s string) (a []any) {
    15  	for _, v := range strings.Fields(s) {
    16  		a = append(a, v)
    17  	}
    18  	return a
    19  }
    20  
    21  func TestEval(t *testing.T) {
    22  	n, err := Expr(0, "/", 0.0)
    23  	assert.NoError(t, err)
    24  	assert.True(t, math.IsNaN(n.Value.(float64)))
    25  
    26  	_, err = Expr(nil)
    27  	assert.ErrorContains(t, err, "unsupported token type")
    28  	_, err = Expr([]string{})
    29  	assert.ErrorContains(t, err, "unsupported token type")
    30  	_, err = Expr(struct{}{})
    31  	assert.ErrorContains(t, err, "unsupported token type")
    32  
    33  	cases := []struct {
    34  		expr string
    35  		want any
    36  	}{
    37  		{"-1", int64(-1)},
    38  		{"1 + 2", int64(3)},
    39  		{"3 - 2 + 4", int64(5)},
    40  		{"1 + 2 * 3", int64(7)},
    41  		{"1 + ( 2 * 3 )", int64(7)},
    42  		{"( 1 + 2 ) * 3", int64(9)},
    43  		{"( 1 + 2.0 ) / 3", float64(1)},
    44  		{"sum( 1 , 2 , 3 , 4 )", int64(10)},
    45  		{"100 + sum( 1 , 2 + 3 , 0.0 ) / 2", float64(103)},
    46  		{"100 * 5 / ( 5 + 15 )", int64(25)},
    47  		{"9 == 5", int64(0)},
    48  		{"5 == 5", int64(1)},
    49  		{"9 != 5", int64(1)},
    50  		{"5 != 5", int64(0)},
    51  		{"9 > 5", int64(1)},
    52  		{"5 > 9", int64(0)},
    53  		{"5 >= 9", int64(0)},
    54  		{"9 >= 9", int64(1)},
    55  		{"9 < 5", int64(0)},
    56  		{"5 < 9", int64(1)},
    57  		{"9 <= 5", int64(0)},
    58  		{"5 <= 5", int64(1)},
    59  		{"1 and 2", int64(1)}, // Golang template definition: non-zero values are all truth
    60  		{"1 and 0", int64(0)},
    61  		{"0 and 0", int64(0)},
    62  		{"1 or 2", int64(1)},
    63  		{"1 or 0", int64(1)},
    64  		{"0 or 1", int64(1)},
    65  		{"0 or 0", int64(0)},
    66  		{"not 2 == 1", int64(1)},
    67  		{"not not ( 9 < 5 )", int64(0)},
    68  	}
    69  
    70  	for _, c := range cases {
    71  		n, err := Expr(tokens(c.expr)...)
    72  		if assert.NoError(t, err, "expr: %s", c.expr) {
    73  			assert.Equal(t, c.want, n.Value)
    74  		}
    75  	}
    76  
    77  	bads := []struct {
    78  		expr   string
    79  		errMsg string
    80  	}{
    81  		{"0 / 0", "integer divide by zero"},
    82  		{"1 +", "num stack is empty"},
    83  		{"+ 1", "num stack is empty"},
    84  		{"( 1", "incomplete sub-expression"},
    85  		{"1 )", "op stack is empty"}, // can not find the corresponding open bracket after the stack becomes empty
    86  		{"1 , 2", "expect 1 value as final result"},
    87  		{"( 1 , 2 )", "too many values in one bracket"},
    88  		{"1 a 2", "unknown operator"},
    89  	}
    90  	for _, c := range bads {
    91  		_, err = Expr(tokens(c.expr)...)
    92  		assert.ErrorContains(t, err, c.errMsg, "expr: %s", c.expr)
    93  	}
    94  }