Arithmetic expression functions

src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs

@@ -11,7 +11,7 @@ namespace Altinn.App.Core.Internal.Expressions;
 /// <summary>
 /// Static class used to evaluate expressions. Holds the implementation for all expression functions.
 /// </summary>
-public static class ExpressionEvaluator
+public static partial class ExpressionEvaluator
 {
     /// <summary>
     /// Shortcut for evaluating a boolean expression on a given property on a <see cref="Models.Layout.Components.Base.BaseComponent" />
@@ -127,6 +127,10 @@ internal static async Task<ExpressionValue> EvaluateExpression_internal(
             ExpressionFunction.argv => Argv(args, positionalArguments),
             ExpressionFunction.gatewayAction => state.GetGatewayAction(),
             ExpressionFunction.language => state.GetLanguage(),
+            ExpressionFunction.plus => Plus(args),
+            ExpressionFunction.minus => Minus(args),
+            ExpressionFunction.multiply => Multiply(args),
+            ExpressionFunction.divide => Divide(args),
             ExpressionFunction.INVALID => throw new ExpressionEvaluatorTypeErrorException(
                 $"Function {expr.Args.FirstOrDefault()} not implemented in backend {expr}"
             ),
@@ -810,7 +814,7 @@ private static (double?, double?) PrepareNumericArgs(ExpressionValue[] args)
     {
         if (args.Length != 2)
         {
-            throw new ExpressionEvaluatorTypeErrorException("Invalid number of args for compare");
+            throw new ExpressionEvaluatorTypeErrorException("Invalid number of args");
         }
 
         var a = PrepareNumericArg(args[0]);
@@ -861,11 +865,12 @@ private static ExpressionValue IfImpl(ExpressionValue[] args)
         );
     }
 
-    private static readonly Regex _numberRegex = new Regex(@"^-?\d+(\.\d+)?$");
-
+    /// <summary>
+    /// Parses a number from a string representation.
+    /// </summary>
     internal static double? ParseNumber(string s, bool throwException = true)
     {
-        if (_numberRegex.IsMatch(s) && double.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var d))
+        if (NumberRegex().IsMatch(s) && double.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var d))
         {
             return d;
         }
@@ -888,6 +893,30 @@ private static bool LessThan(ExpressionValue[] args)
         return a < b; // Actual implementation
     }
 
+    private static double? Plus(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs(args);
+        return PerformArithmetic(a, b, (x, y) => x + y);
+    }
+
+    private static double? Minus(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs(args);
+        return PerformArithmetic(a, b, (x, y) => x - y);
+    }
+
+    private static double? Multiply(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs(args);
+        return PerformArithmetic(a, b, (x, y) => x * y);
+    }
+
+    private static double? Divide(ExpressionValue[] args)
+    {
+        var (a, b) = PrepareNumericArgs(args);
+        return PerformArithmetic(a, b, (x, y) => x / y);
+    }
+
     private static bool LessThanEq(ExpressionValue[] args)
     {
         var (a, b) = PrepareNumericArgs(args);
@@ -960,4 +989,41 @@ private static ExpressionValue Argv(ExpressionValue[] args, ExpressionValue[]? p
 
         return positionalArguments[index.Value];
     }
+
+    /// <summary>
+    /// Performs arithmetic operation using decimal precision to avoid floating point precision issues.
+    /// Converts doubles to decimal, performs the operation, and converts back to double.
+    /// </summary>
+    /// <param name="a">First operand</param>
+    /// <param name="b">Second operand</param>
+    /// <param name="operation">Function that performs the arithmetic operation on two decimals</param>
+    /// <returns>Result of the operation as double, or null if any operand is null</returns>
+    private static double? PerformArithmetic(double? a, double? b, Func<decimal, decimal, decimal> operation)
+    {
+        if (a.HasValue is false || b.HasValue is false)
+        {
+            return null;
+        }
+
+        try
+        {
+            var aDecimal = (decimal)a.Value;
+            var bDecimal = (decimal)b.Value;
+            var result = operation(aDecimal, bDecimal);
+            return (double)result;
+        }
+        catch (OverflowException)
+        {
+            throw new ExpressionEvaluatorTypeErrorException(
+                $"Arithmetic overflow: {a.Value} and {b.Value} or operation on them exceeds the supported range"
+            );
+        }
+        catch (DivideByZeroException)
+        {
+            throw new ExpressionEvaluatorTypeErrorException("The second argument is 0, cannot divide by 0");
+        }
+    }
+
+    [GeneratedRegex(@"^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$")]
+    private static partial Regex NumberRegex();
 }

src/Altinn.App.Core/Internal/Expressions/ExpressionValue.cs

@@ -141,9 +141,7 @@ public static ExpressionValue FromObject(object? value)
             uint numberValue => numberValue,
             long numberValue => numberValue,
             ulong numberValue => numberValue,
-            decimal numberValue =>
-                (double?)numberValue // expressions uses double which needs an explicit cast
-            ,
+            decimal numberValue => (double?)numberValue, // expressions uses double which needs an explicit cast
             DateTime dateTimeValue => JsonSerializer
                 .Serialize(dateTimeValue, _unsafeSerializerOptionsForSerializingDates)
                 .Trim(
@@ -560,7 +558,7 @@ public bool TryDeserialize(Type type, out object? result)
         try
         {
             var json = ToString();
-            result = JsonSerializer.Deserialize(json, type, _unsafeSerializerOptionsForSerializingDates);
+            result = JsonSerializer.Deserialize(json, type);
             return true;
         }
         catch (JsonException)

src/Altinn.App.Core/Models/Expressions/ExpressionFunction.cs

@@ -205,4 +205,24 @@ public enum ExpressionFunction
     /// If no translations exist for the current language, we will use the resources for "nb"
     /// </summary>
     text,
+
+    /// <summary>
+    /// Adding numbers. Must be numeric values.
+    /// </summary>
+    plus,
+
+    /// <summary>
+    /// Subtracting all preceding values from the first. Must be numeric values.
+    /// </summary>
+    minus,
+
+    /// <summary>
+    /// Multiplying numbers. Must be numeric values.
+    /// </summary>
+    multiply,
+
+    /// <summary>
+    /// Divide numbers. Must be numeric values.
+    /// </summary>
+    divide,
 }

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ExpressionTestCaseRoot.cs

@@ -10,6 +10,16 @@ namespace Altinn.App.Core.Tests.LayoutExpressions.CommonTests;
 
 public class ExpressionTestCaseRoot
 {
+    public ExpressionTestCaseRoot(TestCaseItem testCaseItem)
+    {
+        Name = testCaseItem.Name;
+        Expression = testCaseItem.Expression;
+        Expects = testCaseItem.Expects;
+        ExpectsFailure = testCaseItem.ExpectsFailure;
+    }
+
+    public ExpressionTestCaseRoot() { }
+
     [JsonIgnore]
     public string? Filename { get; set; }
 
@@ -42,6 +52,9 @@ public class ExpressionTestCaseRoot
 
     public class TestCaseItem
     {
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
         [JsonPropertyName("expression")]
         public required Expression Expression { get; set; }
 

test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/TestFunctions.cs

@@ -203,6 +203,26 @@ public TestFunctions(ITestOutputHelper output)
     [SharedTest("stringLength")]
     public async Task StringLength_Theory(string testName, string folder) => await RunTestCase(testName, folder);
 
+    [Theory]
+    [SharedTestCases("plus")]
+    public async Task Plus_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
+        await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
+
+    [Theory]
+    [SharedTestCases("minus")]
+    public async Task Minus_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
+        await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
+
+    [Theory]
+    [SharedTestCases("multiply")]
+    public async Task Multiply_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
+        await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
+
+    [Theory]
+    [SharedTestCases("divide")]
+    public async Task Divide_Theory(string testName, ExpressionTestCaseRoot.TestCaseItem testCaseItem) =>
+        await RunTestCase(testName, new ExpressionTestCaseRoot(testCaseItem));
+
     [Theory]
     [SharedTest("round")]
     public async Task Round_Theory(string testName, string folder) => await RunTestCase(testName, folder);
@@ -237,10 +257,15 @@ private static async Task<ExpressionTestCaseRoot> LoadTestCase(string file, stri
     private async Task RunTestCase(string testName, string folder)
     {
         var test = await LoadTestCase(testName, folder);
-        _output.WriteLine(test.Name);
+        await RunTestCase(testName, test);
+    }
+
+    private async Task RunTestCase(string testName, ExpressionTestCaseRoot test)
+    {
+        _output.WriteLine(testName);
         _output.WriteLine($"{test.Folder}{Path.DirectorySeparatorChar}{test.Filename}");
-        _output.WriteLine(test.RawJson);
-        _output.WriteLine(test.FullPath);
+        _output.WriteLine(test.RawJson ?? "");
+        _output.WriteLine(test.FullPath ?? "");
 
         IInstanceDataAccessor dataAccessor;
         List<DataType> dataTypes = new();
@@ -316,16 +341,16 @@ private async Task RunTestCase(string testName, string folder)
             componentModel = new LayoutModel([layout], null);
         }
 
-        var appRewourcesMock = new Mock<IAppResources>(MockBehavior.Strict);
+        var appResourcesMock = new Mock<IAppResources>(MockBehavior.Strict);
 
         var language = test.ProfileSettings?.Language ?? "nb";
-        appRewourcesMock
+        appResourcesMock
             .Setup(ar => ar.GetTexts(It.IsAny<string>(), It.IsAny<string>(), language))
             .ReturnsAsync(new TextResource() { Resources = test.TextResources ?? [] });
 
         var translationService = new TranslationService(
             new Core.Models.AppIdentifier("org", "app"),
-            appRewourcesMock.Object,
+            appResourcesMock.Object,
             FakeLoggerXunit.Get<TranslationService>(_output)
         );
 
@@ -385,6 +410,7 @@ private async Task RunTestCaseItem(
         object?[]? positionalArguments
     )
     {
+        _output.WriteLine(test.Name ?? "");
         if (test.ExpectsFailure is not null)
         {
             _output.WriteLine($"Expecting failure: {test.ExpectsFailure}");
@@ -422,7 +448,6 @@ private async Task RunTestCaseItem(
                 break;
             case JsonValueKind.True:
                 Assert.True(result as bool?);
-                result.Should().Be(true);
                 break;
             case JsonValueKind.False:
                 Assert.False(result as bool?);
@@ -457,7 +482,10 @@ public void Ensure_tests_For_All_Folders()
         var testMethods = this.GetType()
             .GetMethods()
             .Select(m =>
-                m.CustomAttributes.FirstOrDefault(ca => ca.AttributeType == typeof(SharedTestAttribute))
+                m.CustomAttributes.FirstOrDefault(ca =>
+                        ca.AttributeType == typeof(SharedTestAttribute)
+                        || ca.AttributeType == typeof(SharedTestCasesAttribute)
+                    )
                     ?.ConstructorArguments.FirstOrDefault()
                     .Value
             )
@@ -473,3 +501,7 @@ public class SharedTestAttribute(string folder)
     : FileNamesInFolderDataAttribute(
         Path.Join("LayoutExpressions", "CommonTests", "shared-tests", "functions", folder)
     ) { }
+
+// Can be used when you only want to run the tests listed in the testCases array in the json file
+public class SharedTestCasesAttribute(string folder)
+    : TestCasesAttribute(Path.Join("LayoutExpressions", "CommonTests", "shared-tests", "functions", folder)) { }