Fix filter in a collection of primitive values.

Author: ElizabethOkerio

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

@@ -13,6 +13,7 @@ namespace Microsoft.OData.UriParser
     using System.Text;
     using Microsoft.OData.Edm;
     using Microsoft.OData.Core;
+    using System.Collections.Generic;
 
     /// <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) && IsCollectionContentEmptyOrSpaces(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,76 @@ private static string NormalizeDateTimeCollectionItems(string bracketLiteralText
 
             return "[" + String.Join(",", items) + "]";
         }
+
+        private static bool IsCollectionContentEmptyOrSpaces(string bracketLiteralText)
+        {
+            if (string.IsNullOrWhiteSpace(bracketLiteralText) || bracketLiteralText.Length < 2)
+            {
+                return true;
+            }
+
+            string content = bracketLiteralText[1..^1].Trim();
+
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                return true;
+            }
+
+            bool isEmptyOrHasOnlySpaces = true;
+            bool isCharinsideQuotes = false;
+            char quoteChar = '\0';
+            Span<char> buffer = stackalloc char[content.Length];
+            int bufferIndex = 0;
+
+            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[..bufferIndex]).Trim().Trim('\'', '"');
+
+                        if (!string.IsNullOrWhiteSpace(item))
+                        {
+                            isEmptyOrHasOnlySpaces = false;
+                            break;
+                        }
+                        bufferIndex = 0;
+                    }
+                    else
+                    {
+                        buffer[bufferIndex++] = c;
+                    }
+                }
+            }
+
+            if (bufferIndex > 0)
+            {
+                string lastItem = new string(buffer[..bufferIndex]).Trim().Trim('\'', '"');
+
+                if (!string.IsNullOrWhiteSpace(lastItem))
+                {
+                    isEmptyOrHasOnlySpaces = false;
+                }
+            }
+
+            return isEmptyOrHasOnlySpaces;
+        }
     }
 }

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

@@ -2130,6 +2130,22 @@ 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)")]
+        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()
         {