Fix $filter in (collectionofdynamicprimitivevalues) (#3190)

* Fix filter in a collection of primitive values.

* update changes

* update changes

* update changes

* update changes

* update changes

Author: ElizabethOkerio

src/Microsoft.OData.Core/UriParser/Binders/InBinder.cs

@@ -7,12 +7,13 @@
 namespace Microsoft.OData.UriParser
 {
     using System;
+    using System.Buffers;
     using System.Diagnostics;
     using System.Globalization;
     using System.Linq;
     using System.Text;
-    using Microsoft.OData.Edm;
     using Microsoft.OData.Core;
+    using Microsoft.OData.Edm;
 
     /// <summary>
     /// Class that knows how to bind the In operator.
@@ -129,7 +130,7 @@ private CollectionNode GetCollectionOperandFromToken(QueryToken queryToken, IEdm
                     Debug.Assert(expectedType.IsCollection());
                     string expectedTypeFullName = expectedType.Definition.AsElementType().FullTypeName();
 
-                    if (expectedTypeFullName.Equals("Edm.String", StringComparison.Ordinal) || expectedTypeFullName.Equals("Edm.Untyped", StringComparison.Ordinal))
+                    if (expectedTypeFullName.Equals("Edm.String", StringComparison.Ordinal) || (expectedTypeFullName.Equals("Edm.Untyped", StringComparison.Ordinal) && IsCollectionEmptyOrWhiteSpace(bracketLiteralText)))
                     {
                         // For collection of strings, need to convert single-quoted string to double-quoted string,
                         // and also, per ABNF, a single quote within a string literal is "encoded" as two consecutive single quotes in either
@@ -423,5 +424,78 @@ private static string NormalizeDateTimeCollectionItems(string bracketLiteralText
 
             return "[" + String.Join(",", items) + "]";
         }
+
+        private static bool IsCollectionEmptyOrWhiteSpace(string bracketLiteralText)
+        {
+            string content = bracketLiteralText[1..^1].Trim();
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                return true;
+            }
+
+            bool isEmptyOrWhiteSpace = true;
+            bool isCharInsideQuotes = false;
+            char quoteChar = '\0';
+            char[] buffer = ArrayPool<char>.Shared.Rent(content.Length);
+            int bufferIndex = 0;
+
+            try
+            {
+                for (int i = 0; i < content.Length; i++)
+                {
+                    char c = content[i];
+
+                    if (isCharInsideQuotes)
+                    {
+                        if (c == quoteChar)
+                        {
+                            isCharInsideQuotes = false;
+                        }
+                        buffer[bufferIndex++] = c;
+                    }
+                    else
+                    {
+                        if (c == '"' || c == '\'')
+                        {
+                            isCharInsideQuotes = true;
+                            quoteChar = c;
+                            buffer[bufferIndex++] = c;
+                        }
+                        else if (c == ',')
+                        {
+                            string item = new string(buffer, 0, bufferIndex).Trim().Trim('\'', '"');
+
+                            if (!string.IsNullOrWhiteSpace(item))
+                            {
+                                isEmptyOrWhiteSpace = false;
+                                break;
+                            }
+                            bufferIndex = 0;
+                        }
+                        else
+                        {
+                            buffer[bufferIndex++] = c;
+                        }
+                    }
+                }
+
+                if (bufferIndex > 0)
+                {
+                    string lastItem = new string(buffer, 0, bufferIndex).Trim().Trim('\'', '"');
+
+                    if (!string.IsNullOrWhiteSpace(lastItem))
+                    {
+                        isEmptyOrWhiteSpace = false;
+                    }
+                }
+            }
+            finally
+            {
+                ArrayPool<char>.Shared.Return(buffer);
+            }
+
+            return isEmptyOrWhiteSpace;
+        }
     }
 }

test/UnitTests/Microsoft.OData.Core.Tests/ScenarioTests/UriParser/FilterAndOrderByFunctionalTests.cs

@@ -2130,6 +2130,27 @@ public void FilterWithInOperationWithParensCollection()
             Assert.Equal("(1,2,3)", Assert.IsType<CollectionConstantNode>(inNode.Right).LiteralText);
         }
 
+        [Theory]
+        [InlineData("TestInt", "(1,2,3)")]
+        [InlineData("TestDouble", "(1.1,2.2,3.3)")]
+        [InlineData("TestBool", "(true,false)")]
+        [InlineData("TestString", "('a','b','c')")]
+        [InlineData("TestDecimal", "(1.1,2.2,3.3)")]
+        [InlineData("TestIntInSquareBrackets", "[1,2,3]")]
+        [InlineData("TestDoubleInSquareBrackets", "[1.1,2.2,3.3]")]
+        [InlineData("TestBoolInSquareBrackets", "[true,false]")]
+        [InlineData("TestStringInSquareBrackets", "['a','b','c']")]
+        [InlineData("TestDecimalInSquareBrackets", "[1.1,2.2,3.3]")]
+        public void FilterWithInOperationWithParensCollectionConsistingOfDynamicPrimitiveProperties(string propertyName, string values)
+        {
+            string filterExpression = $"{propertyName} in {values}";
+            FilterClause filter = ParseFilter(filterExpression, HardCodedTestModel.TestModel, HardCodedTestModel.GetOpenEmployeeType());
+
+            var inNode = Assert.IsType<InNode>(filter.Expression);
+            Assert.IsType<SingleValueOpenPropertyAccessNode>(inNode.Left);
+            Assert.Equal(values, Assert.IsType<CollectionConstantNode>(inNode.Right).LiteralText);
+        }
+
         [Fact]
         public void FilterWithInOperationWithParensCollectionAndLogicalNotOperator()
         {