Update tests

tests/src/python/test_qgsexpression.py

@@ -17,6 +17,8 @@
     QgsExpressionContext,
     QgsFeatureRequest,
     QgsFields,
+    QgsFeature,
+    QgsField,
 )
 from qgis.testing import unittest
 from qgis.utils import qgsfunction
@@ -29,10 +31,6 @@ def testfun(values, feature, parent):
         """ Function help """
         return f"Testing_{values[0]}"
 
-    @qgsfunction(args="auto", group='testing', register=False)
-    def autocount(value1, value2, value3, feature, parent):
-        pass
-
     @qgsfunction(args="auto", group='testing', register=False)
     def expandargs(value1, value2, value3, feature, parent):
         return value1, value2, value3
@@ -79,6 +77,30 @@ def raise_exception(feature, parent):
         # an undefined variable
         foo  # noqa: F821
 
+    @qgsfunction(group='testing', register=False)
+    def simple_sum(val1, val2):
+        return val1 + val2
+
+    @qgsfunction(group='testing', register=False)
+    def sum_vargs(val1, *args):
+        return val1 + sum(args)
+
+    @qgsfunction(group='testing', args=-1, register=False)
+    def func_params_as_list_legacy(values, feature, parent):
+        return values
+
+    @qgsfunction(group='testing', params_as_list=True, register=False)
+    def func_params_as_list(values):
+        return values
+
+    @qgsfunction(group='testing', register=False)
+    def func_params_no_list(values):
+        return values
+
+    @qgsfunction(group='testing', register=False)
+    def func_feature(*args, feature):
+        return (feature["a"] + sum(args)) * feature["b"]
+
     def tearDown(self):
         QgsExpression.unregisterFunction('testfun')
 
@@ -87,11 +109,6 @@ def testCanBeRegistered(self):
         index = QgsExpression.functionIndex('testfun')
         self.assertNotEqual(index, -1)
 
-    def testAutoCountsCorrectArgs(self):
-        function = self.autocount
-        args = function.params()
-        self.assertEqual(args, 3)
-
     def testHelpPythonFunction(self):
         """Test help about python function."""
         QgsExpression.registerFunction(self.help_with_variable)
@@ -112,8 +129,6 @@ def testHelpString(self):
 
     def testAutoArgsAreExpanded(self):
         function = self.expandargs
-        args = function.params()
-        self.assertEqual(args, 3)
         values = [1, 2, 3]
         exp = QgsExpression("")
         result = function.func(values, None, exp, None)
@@ -148,7 +163,6 @@ def testDecoratorPreservesAttributes(self):
         func = self.testfun
         self.assertEqual(func.name(), 'testfun')
         self.assertEqual(func.group(), 'testing')
-        self.assertEqual(func.params(), 1)
 
     def testCantReregister(self):
         QgsExpression.registerFunction(self.testfun)
@@ -312,7 +326,7 @@ def testExceptionDuringEvalReturnsTraceback(self):
         regex = (
             "name 'foo' is not defined:<pre>Traceback \\(most recent call last\\):\n"
             "  File \".*qgsfunction.py\", line [0-9]+, in func\n"
-            "    return self.function\\(\\*values\\)\n"
+            "    return self.function\\(\\*values, \\*\\*kwvalues\\)\n"
             "  File \".*test_qgsexpression.py\", line [0-9]+, in raise_exception\n"
             "    foo  # noqa: F821\n"
             "NameError: name \'foo\' is not defined"
@@ -328,6 +342,88 @@ def testBetween(self):
         e.setExpression("'b' between 'a' AND 'c'")
         self.assertTrue(e.isValid(), e.parserErrorString())
 
+    def testSimpleSum(self):
+
+        QgsExpression.registerFunction(self.simple_sum)
+
+        e = QgsExpression()
+        e.setExpression("simple_sum(4, 5)")
+        self.assertEqual(e.evaluate(), 9)
+
+        # Not enough parameters
+        e.setExpression("simple_sum(4)")
+        self.assertEqual(e.evaluate(), None)
+
+        # Too many parameters
+        e.setExpression("simple_sum(4, 7, 8)")
+        self.assertEqual(e.evaluate(), None)
+
+    def testSumVargs(self):
+
+        QgsExpression.registerFunction(self.sum_vargs)
+
+        e = QgsExpression()
+
+        # Not enough parameters
+        e.setExpression("sum_vargs()")
+        self.assertEqual(e.evaluate(), None)
+
+        e.setExpression("sum_vargs(4)")
+        self.assertEqual(e.evaluate(), 4)
+
+        e.setExpression("sum_vargs(4, 5)")
+        self.assertEqual(e.evaluate(), 9)
+
+        e.setExpression("sum_vargs(4, 5, 6, 7)")
+        self.assertEqual(e.evaluate(), 22)
+
+    def testListNoList(self):
+        QgsExpression.registerFunction(self.func_params_as_list_legacy)
+        QgsExpression.registerFunction(self.func_params_as_list)
+        QgsExpression.registerFunction(self.func_params_no_list)
+
+        e = QgsExpression()
+        e.setExpression("func_params_as_list_legacy('a', 'b', 'c')")
+        self.assertEqual(e.evaluate(), ["a", "b", "c"])
+
+        e.setExpression("func_params_as_list('a', 'b', 'c')")
+        self.assertEqual(e.evaluate(), ["a", "b", "c"])
+
+        e.setExpression("func_params_as_list('a')")
+        self.assertEqual(e.evaluate(), ["a"])
+
+        e.setExpression("func_params_no_list('a')")
+        self.assertEqual(e.evaluate(), "a")
+
+    def testFeature(self):
+        QgsExpression.registerFunction(self.func_feature)
+        context = QgsExpressionContext()
+        feature = QgsFeature(id=10)
+        fields = QgsFields()
+        fields.append(QgsField("a", QVariant.Int))
+        fields.append(QgsField("b", QVariant.String))
+
+        feature.setFields(fields)
+        feature["a"] = 4
+        feature["b"] = "world"
+
+        context.setFeature(feature)
+
+        e = QgsExpression()
+        e.setExpression("func_feature()")
+        self.assertEqual(e.evaluate(context), "worldworldworldworld")
+        e.setExpression("func_feature(-1, -1)")
+        self.assertEqual(e.evaluate(context), "worldworld")
+
+        feature["a"] = 2
+        feature["b"] = "_"
+
+        context.setFeature(feature)
+        e.setExpression("func_feature()")
+        self.assertEqual(e.evaluate(context), "__")
+        e.setExpression("func_feature(3)")
+        self.assertEqual(e.evaluate(context), "_____")
+
 
 if __name__ == "__main__":
     unittest.main()