Bug/s884 (#2041)

* Added previous work and made bug fixes

* Remove cache attempt

* Fixed bugs in Sort,SumIFs and Left

* Added more xlookup tests

* Fixed AnchorArray when only returning one cell issue

* Cleanup and bugfix

* Minor bugfixes

* Cleaned up comments

* missed cleanup

---------

Co-authored-by: Mats Alm <897655+swmal@users.noreply.github.com>

Author: OssianEPPlus

src/EPPlus/FormulaParsing/Excel/Functions/MathFunctions/RangeCriteriaFunction.cs

@@ -17,6 +17,7 @@ Date               Author                       Change
 using OfficeOpenXml.FormulaParsing.ExcelUtilities;
 using OfficeOpenXml.FormulaParsing.FormulaExpressions;
 using OfficeOpenXml.FormulaParsing.LexicalAnalysis;
+using OfficeOpenXml.FormulaParsing.Ranges;
 using OfficeOpenXml.FormulaParsing.Utilities;
 using OfficeOpenXml.Sorting.Internal;
 using OfficeOpenXml.Utils;
@@ -159,15 +160,37 @@ protected List<int> GetMatchIndexes(RangeOrValue rangeOrValue, object searched,
                     for (var col = address.FromCol; col <= address.ToCol; col++)
                     {
                         var candidate = rangeInfo.GetValue(row, col);
-                        if (searched != null && Evaluate(candidate, searched, ctx, convertNumericString))
+
+                        if (searched != null)
                         {
-                            result.Add(internalIndex);
+                            if (searched is RangeOrValue critRange)
+                            {
+                                if (critRange.Range != null)
+                                {
+                                    foreach (var cell in critRange.Range)
+                                    {
+                                        if (Evaluate(candidate, cell.Value, ctx, convertNumericString))
+                                        {
+                                            result.Add(internalIndex);
+                                        }
+                                    }
+                                }
+                                else if(critRange.Value != null && Evaluate(candidate, critRange.Value, ctx, convertNumericString))
+                                {
+                                    result.Add(internalIndex);
+                                }
+                            }
+                            else if (Evaluate(candidate, searched, ctx, convertNumericString))
+                            {
+                                result.Add(internalIndex);
+                            }
                         }
+
                         internalIndex++;
                     }
                 }
             }
-            else if(Evaluate(rangeOrValue.Value, searched, ctx, convertNumericString))
+            else if (Evaluate(rangeOrValue.Value, searched, ctx, convertNumericString))
             {
                 result.Add(internalIndex);
             }
@@ -236,7 +259,15 @@ protected IEnumerable<int> GetMatchingIndicesFromArguments(int argStartIx, IList
                 {
                     argRanges.Add(new RangeOrValue { Value = arg.ResultValue });
                 }
-                criteria.Add(args[ix + 1].ResultValue);
+
+                if (args[ix + 1].Result is IRangeInfo critInfo)
+                {
+                    criteria.Add(new RangeOrValue { Range = critInfo });
+                }
+                else
+                {
+                    criteria.Add(new RangeOrValue { Value = args[ix + 1].ResultValue });
+                }
             }
             IEnumerable<int> matchIndexes = GetMatchIndexes(argRanges[0], criteria[0], null);
             var enumerable = matchIndexes as IList<int> ?? matchIndexes.ToList();

src/EPPlus/FormulaParsing/Excel/Functions/MathFunctions/SumIfs.cs

@@ -13,9 +13,7 @@ Date               Author                       Change
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using OfficeOpenXml.FormulaParsing.Excel.Functions.Metadata;
-using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
 using OfficeOpenXml.FormulaParsing.Excel.Operators;
 using OfficeOpenXml.FormulaParsing.ExcelUtilities;
 using OfficeOpenXml.FormulaParsing.FormulaExpressions;

src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/AnchorArray.cs

@@ -49,6 +49,12 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                         var ri = new RangeInfo(rangeAddress);
                         return new DynamicArrayCompileResult(ri, DataType.ExcelRange, rangeAddress);
                     }
+                    else if(string.IsNullOrEmpty(f?.ToString()) == false)
+                    {
+                        //Even if the formulas is just on one cell it should return the range
+                        var ri = new RangeInfo(address);
+                        return new DynamicArrayCompileResult(ri, DataType.ExcelRange, address);
+                    }
                 }
             }
             return CompileResult.GetDynamicArrayResultError(eErrorType.Ref);

src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/SortFunction.cs

@@ -81,11 +81,11 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 byCol = ArgToBool(arguments, 3, false);
             }
 
-            //Validate
-            var maxIndex = byCol ? range.Size.NumberOfCols : range.Size.NumberOfRows;
-            foreach(var sortIndex in sortIndexes)
+            //Validate (Excel allows the larger number of sort indicies despite them not being used)
+            var maxPotentialIndex = Math.Max(range.Size.NumberOfCols, range.Size.NumberOfRows);
+            foreach (var sortIndex in sortIndexes)
             {
-                if (sortIndex < 1 || sortIndex > maxIndex) return CreateResult(eErrorType.Value);
+                if (sortIndex < 1 || sortIndex > maxPotentialIndex) return CreateResult(eErrorType.Value);
             }
 
             if (sortOrder != -1 && sortOrder != 1) return CreateResult(eErrorType.Value);

src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/XLookup.cs

@@ -45,8 +45,6 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 _stopwatch = new Stopwatch();
                 _stopwatch.Start();
             }
-            var lookupValue = arguments[0].Value ?? 0;     //If Search value is null, we should search for 0 instead
-
             // lookup range
             if (!arguments[1].IsExcelRange) return CompileResult.GetDynamicArrayResultError(eErrorType.Value);
             var lookupRange = arguments[1].ValueAsRangeInfo;
@@ -81,7 +79,10 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 if (e4 != null) return CompileResult.GetErrorResult(e4.Type);
                 searchMode = XlookupUtil.GetSearchMode(sm);
             }
+
             int ix;
+            var lookupValue = arguments[0].Value ?? 0;     //If Search value is null, we should search for 0 instead
+
             if (searchMode == LookupSearchMode.BinarySearchAscending || searchMode == LookupSearchMode.BinarySearchDescending)
             {
                 var asc = searchMode == LookupSearchMode.BinarySearchAscending;
@@ -97,6 +98,7 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 _stopwatch.Stop();
                 context.Configuration.Logger.LogFunction("XLOOKUP", _stopwatch.ElapsedMilliseconds);
             }
+
             return BuildCompileResult(lookupDirection, returnArray, notFoundText, ix);
         }
 

src/EPPlus/FormulaParsing/Excel/Functions/Text/Left.cs

@@ -25,13 +25,26 @@ namespace OfficeOpenXml.FormulaParsing.Excel.Functions.Text
     internal class Left : ExcelFunction
     {
         public override ExcelFunctionArrayBehaviour ArrayBehaviour => ExcelFunctionArrayBehaviour.FirstArgCouldBeARange;
-        public override int ArgumentMinLength => 2;
+        //Num_Chars is optional
+        public override int ArgumentMinLength => 1;
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             var str = ArgToString(arguments, 0);
             if(str == null)
                 str = string.Empty;
-            var length = ArgToInt(arguments, 1, out ExcelErrorValue e1);
+
+            int length;
+            ExcelErrorValue e1 = null;
+
+            if (arguments.Count < 2)
+            {
+                length = 1;
+            }
+            else
+            {
+                length = ArgToInt(arguments, 1, out e1);
+            }
+
             if (e1 != null) return CompileResult.GetErrorResult(e1.Type);
             if (length < 0)
             {
@@ -41,7 +54,7 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 length = str.Length;
             if(context.Configuration.EnableUnicodeAwareStringOperations)
             {
-                return CreateResult(str.UnitcodeSubstring(length), DataType.String);
+                return CreateResult(str.UnicodeSubstring(length), DataType.String);
             }
             return CreateResult(str.Substring(0, length), DataType.String);
         }

src/EPPlus/FormulaParsing/FormulaExpressions/FunctionCompilers/CustomArrayBehaviourCompiler.cs

@@ -51,14 +51,19 @@ public override CompileResult Compile(IEnumerable<CompileResult> children, Parsi
                 if(cr.DataType == DataType.ExcelRange && Function.ArrayBehaviourConfig.CanBeArrayArg(ix))
                 {
                     var range = cr.Result as IRangeInfo;
-                    if(range.GetNCells() > 1)
-                    {
-                        rangeArgs[ix] = range;
-                    }
-                    else
-                    {
-                        otherArgs[ix] = CompileResultFactory.Create(range.GetOffset(0, 0));
-                    }
+                    rangeArgs[ix] = range;
+
+                    //OLD CODE left below in case otherArgs becomes a problem later. Range args when NCells == 1 is
+                    //neccesary in case of in memory range/dynamic array formulas with a single cell.
+
+                    //if (range.GetNCells() > 1)
+                    //{
+                    //    rangeArgs[ix] = range;
+                    //}
+                    //else
+                    //{
+                    //    otherArgs[ix] = CompileResultFactory.Create(range.GetOffset(0, 0));
+                    //}
                 }
                 else
                 {

src/EPPlus/Utils/RemoteCalls/HttpRemoteTask.cs

@@ -40,7 +40,7 @@ public override void DoWork()
             }
             finally
             {
-                ParsingContext.RemoteCallManager.TaskComplate(this);
+                ParsingContext.RemoteCallManager.TaskComplete(this);
             }
         }
     }

src/EPPlus/Utils/RemoteCalls/RemoteCallManager.cs

@@ -25,7 +25,7 @@ public void QueueTask(RemoteTask task)
             }
             ThreadPool.QueueUserWorkItem(_ => task.DoWork());
         }
-        public void TaskComplate(RemoteTask task)
+        public void TaskComplete(RemoteTask task)
         {
             _tasks.Remove(task);
         }

src/EPPlus/Utils/StringExtensions.cs

@@ -45,7 +45,7 @@ internal static bool ContainsOnlyCharacter(this string s, char theCharacter, boo
             return true;
         }
 
-        internal static string UnitcodeSubstring(this string s, int length)
+        internal static string UnicodeSubstring(this string s, int length)
         {
             return StringUtil.UnicodeSubstring(s, length);
         }