Adding relevant unit tests for MvcRazorCodeParser property name trimming

src/Microsoft.AspNet.Mvc.Razor.Host/MvcRazorCodeParser.cs

@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System.Linq;
+using System.Diagnostics;
 using Microsoft.AspNet.Mvc.Razor.Host;
 using Microsoft.AspNet.Razor;
 using Microsoft.AspNet.Razor.Generator;
@@ -129,7 +129,7 @@ namespace Microsoft.AspNet.Mvc.Razor
                                .Substring(typeName.Length);
 
             // ';' is optional
-            propertyName = TrimSpacesAndChars(propertyName, ';');
+            propertyName = RemoveWhitespaceAndTrailingSemicolons(propertyName);
             Span.CodeGenerator = new InjectParameterGenerator(typeName.Trim(), propertyName);
 
             // Output the span and finish the block
@@ -143,52 +143,21 @@ namespace Microsoft.AspNet.Mvc.Razor
         }
 
         // Internal for unit testing
-        internal static string TrimSpacesAndChars(string value, params char[] chars)
+        internal static string RemoveWhitespaceAndTrailingSemicolons(string value)
         {
-            if (string.IsNullOrWhiteSpace(value))
+            Debug.Assert(value != null);
-            {
+            value = value.TrimStart();
-                return string.Empty;
-            }
 
-            if (chars == null || chars.Length == 0)
+            for (var index = value.Length - 1; index >= 0; index--)
             {
-                return value.Trim();
+                var currentChar = value[index];
-            }
+                if (!char.IsWhiteSpace(currentChar) && currentChar != ';')
-
-            var firstIndex = 0;
-            for (; firstIndex < value.Length; firstIndex++)
-            {
-                var currentChar = value[firstIndex];
-                if (!char.IsWhiteSpace(currentChar) && !chars.Any(compareChar => compareChar == currentChar))
                 {
-                    break;
+                    return value.Substring(0, index + 1);
                 }
             }
 
-            // We trimmed all the way
+            return string.Empty;
-            if (firstIndex == value.Length)
-            {
-                return string.Empty;
-            }
-
-            var lastIndex = value.Length - 1;
-            for (; lastIndex > firstIndex; lastIndex--)
-            {
-                var currentChar = value[lastIndex];
-                if (!char.IsWhiteSpace(currentChar) && !chars.Any(compareChar => compareChar == currentChar))
-                {
-                    break;
-                }
-            }
-
-            if (firstIndex == 0 && lastIndex == value.Length - 1)
-            {
-                return value;
-            }
-            else
-            {
-                return value.Substring(firstIndex, lastIndex - firstIndex + 1);
-            }
         }
     }
 }

test/Microsoft.AspNet.Mvc.Razor.Host.Test/MvcRazorParserTest.cs

@@ -177,87 +177,34 @@ namespace Microsoft.AspNet.Mvc.Razor
             }
         }
 
-        public static TheoryData TrimSpacesAndCharsData
-        {
-            get
-            {
-                // input, trimCharacters, expectedOutput
-                return new TheoryData<string, char[], string>
-                {
-                    { "abcd", new char[] {  }, "abcd" },
-                    { "  /.", new char[] { '/', '.' }, string.Empty },
-                    { string.Empty, new char[] {  }, string.Empty },
-                    { " ", new char[] {  }, string.Empty },
-                    { "  ", new char[] {  }, string.Empty },
-                    { "  / ", new char[] { '/' }, string.Empty },
-                    { "  \t ", new char[] { '/' }, string.Empty },
-                    { "   ", new char[] { '/' }, string.Empty },
-                    { "  ", new char[] { '/' }, string.Empty },
-                    { "/", new char[] { '/' }, string.Empty },
-                    { "//", new char[] { '/' }, string.Empty },
-                    { "//  ", new char[] { '/' }, string.Empty },
-                    { "/ ", new char[] { '/' }, string.Empty },
-                    { " a ", new char[] {  }, "a" },
-                    { " a", new char[] {  }, "a" },
-                    { "a ", new char[] {  }, "a" },
-                    { "  a  ", new char[] {  }, "a" },
-                    { " a \n\r", new char[] {  }, "a" },
-                    { "\t\r a ", new char[] {  }, "a" },
-                    { "\ta ", new char[] {  }, "a" },
-                    { " a a ", new char[] {  }, "a a" },
-                    { " a ", new char[] { '/' }, "a" },
-                    { " a", new char[] { '/' }, "a" },
-                    { "a ", new char[] { '/' }, "a" },
-                    { "  a  ", new char[] { '/' }, "a" },
-                    { " a \n\r", new char[] { '/' }, "a" },
-                    { "\t\r a ", new char[] { '/' }, "a" },
-                    { "\ta ", new char[] { '/' }, "a" },
-                    { " a a ", new char[] { '/' }, "a a" },
-                    { " a ", new char[] { '/', ' ' }, "a" },
-                    { " a", new char[] { '/', ' ' }, "a" },
-                    { "a ", new char[] { '/', ' ' }, "a" },
-                    { "  a  ", new char[] { '/', ' ' }, "a" },
-                    { " a \n\r", new char[] { '/', ' ' }, "a" },
-                    { "\t\r a ", new char[] { '/', ' ' }, "a" },
-                    { "\ta ", new char[] { '/', ' ' }, "a" },
-                    { " a a ", new char[] { '/', ' ' }, "a a" },
-                    { "/ a ", new char[] { '/' }, "a" },
-                    { " / a", new char[] { '/' }, "a" },
-                    { "a / /", new char[] { '/' }, "a" },
-                    { "  a  // //", new char[] { '/' }, "a" },
-                    { " a \n\r//", new char[] { '/' }, "a" },
-                    { "////\t\r a ", new char[] { '/' }, "a" },
-                    { "\ta /", new char[] { '/' }, "a" },
-                    { " a/ a ", new char[] { '/' }, "a/ a" },
-                    { "/ a ", new char[] { '/', ' ' }, "a" },
-                    { " / a", new char[] { '/', ' ' }, "a" },
-                    { "a / /", new char[] { '/', ' ' }, "a" },
-                    { "  a  // //", new char[] { '/', ' ' }, "a" },
-                    { " a \n\r//", new char[] { '/', ' ' }, "a" },
-                    { "////\t\r a ", new char[] { '/', ' ' }, "a" },
-                    { "\ta /", new char[] { '/', ' ' }, "a" },
-                    { " a/ a ", new char[] { '/', ' ' }, "a/ a" },
-                    { " a /.", new char[] { '/', '.' }, "a" },
-                    { " a", new char[] { '/', '.' }, "a" },
-                    { "/. ./a ", new char[] { '/', '.' }, "a" },
-                    { "  a  ", new char[] { '/', '.' }, "a" },
-                    { " a \n\r", new char[] { '/', '.' }, "a" },
-                    { "\t\r a ", new char[] { '/', '.' }, "a" },
-                    { "\ta ", new char[] { '/', '.' }, "a" },
-                    { "///..a/./a /. ./....", new char[] { '/', '.' }, "a/./a" },
-                };
-            }
-        }
-
         [Theory]
-        [MemberData(nameof(TrimSpacesAndCharsData))]
+        [InlineData("", "")]
-        public void TrimSpacesAndChars_GeneratesExpectedOutput(
+        [InlineData("   ;  ", "")]
-            string input,
+        [InlineData("    ", "")]
-            char[] trimCharacters,
+        [InlineData(";;", "")]
-            string expectedOutput)
+        [InlineData("a", "a")]
+        [InlineData("a;", "a")]
+        [InlineData("abcd", "abcd")]
+        [InlineData("abc;d", "abc;d")]
+        [InlineData("a bc d", "a bc d")]
+        [InlineData("a\t\tbc\td\t", "a\t\tbc\td")]
+        [InlineData("abc;", "abc")]
+        [InlineData("  abc;", "abc")]
+        [InlineData("\tabc;", "abc")]
+        [InlineData(";; abc;", ";; abc")]
+        [InlineData(";;\tabc;", ";;\tabc")]
+        [InlineData("\t;;abc;", ";;abc")]
+        [InlineData("abc;; ;", "abc")]
+        [InlineData("abc;;\t;", "abc")]
+        [InlineData("\tabc  \t;", "abc")]
+        [InlineData("abc;;\r\n;", "abc")]
+        [InlineData("abcd \n", "abcd")]
+        [InlineData("\r\n\r  \n\t  abcd \t \t \n  \r\n", "abcd")]
+        [InlineData("pqrs\r", "pqrs")]
+        public void RemoveWhitespaceAndTrailingSemicolons_ReturnsExpectedValues(string input, string expectedOutput)
         {
-            // Arrange & Act
+            // Arrange and Act
-            var output = MvcRazorCodeParser.TrimSpacesAndChars(input, trimCharacters);
+            var output = MvcRazorCodeParser.RemoveWhitespaceAndTrailingSemicolons(input);
 
             // Assert
             Assert.Equal(expectedOutput, output, StringComparer.Ordinal);