Refactors time unit parsing and wildcard tests

Improves time unit parsing by using a more concise loop and clarifies variable types.

Refactors wildcard tests for better readability and consistency by using `string[]` for test inputs and `int` for index variables.

Author: niemyjski

src/Exceptionless.DateTimeExtensions/TimeUnit.cs

@@ -29,31 +29,31 @@ public static bool TryParse(string value, out TimeSpan? time)
     private static TimeSpan? ParseTime(string value)
     {
         // bail if we have any weird characters
-        for (int i = 0; i < value.Length; i++)
-            if (!Char.IsLetterOrDigit(value[i]) && value[i] != '-' && value[i] != '+' && !Char.IsWhiteSpace(value[i]))
+        foreach (char c in value)
+            if (!Char.IsLetterOrDigit(c) && c != '-' && c != '+' && !Char.IsWhiteSpace(c))
                 return null;
 
         // compare using the original value as uppercase M could mean months.
-        var normalized = value.Trim();
-        if (value.EndsWith("m") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out var minutes))
+        string normalized = value.Trim();
+        if (value.EndsWith("m") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int minutes))
             return new TimeSpan(0, minutes, 0);
 
-        if (normalized.EndsWith("h") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out var hours))
+        if (normalized.EndsWith("h") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int hours))
             return new TimeSpan(hours, 0, 0);
 
-        if (normalized.EndsWith("d") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out var days))
+        if (normalized.EndsWith("d") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int days))
             return new TimeSpan(days, 0, 0, 0);
 
-        if (normalized.EndsWith("nanos", StringComparison.OrdinalIgnoreCase) && Int32.TryParse(normalized.Substring(0, normalized.Length - 5), out var nanoseconds))
+        if (normalized.EndsWith("nanos", StringComparison.OrdinalIgnoreCase) && Int32.TryParse(normalized.Substring(0, normalized.Length - 5), out int nanoseconds))
             return new TimeSpan((int)Math.Round(nanoseconds / 100d));
 
-        if (normalized.EndsWith("micros", StringComparison.OrdinalIgnoreCase) && Int32.TryParse(normalized.Substring(0, normalized.Length - 6), out var microseconds))
+        if (normalized.EndsWith("micros", StringComparison.OrdinalIgnoreCase) && Int32.TryParse(normalized.Substring(0, normalized.Length - 6), out int microseconds))
             return new TimeSpan(microseconds * 10);
 
-        if (normalized.EndsWith("ms") && Int32.TryParse(normalized.Substring(0, normalized.Length - 2), out var milliseconds))
+        if (normalized.EndsWith("ms") && Int32.TryParse(normalized.Substring(0, normalized.Length - 2), out int milliseconds))
             return new TimeSpan(0, 0, 0, 0, milliseconds);
 
-        if (normalized.EndsWith("s") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out var seconds))
+        if (normalized.EndsWith("s") && Int32.TryParse(normalized.Substring(0, normalized.Length - 1), out int seconds))
             return new TimeSpan(0, 0, seconds);
 
         return null;

tests/Exceptionless.DateTimeExtensions.Tests/FormatParsers/PartParsers/WildcardPartParserTests.cs

@@ -71,9 +71,9 @@ public void RegexPatternTest()
         _logger.LogInformation("Regex pattern: {Pattern}", regex);
 
         // Test various inputs
-        var testInputs = new[] { "*", " * ", "  *  ", "blah", "2012", "**", "* *", "" };
+        string[] testInputs = new[] { "*", " * ", "  *  ", "blah", "2012", "**", "* *", "" };
 
-        foreach (var input in testInputs)
+        foreach (string input in testInputs)
         {
             var match = regex.Match(input);
             _logger.LogInformation("Input: '{Input}' -> Success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", input, match.Success, match.Value, match.Index, match.Length);
@@ -86,9 +86,9 @@ public void TestInTwoPartContext()
         var parser = new WildcardPartParser();
 
         // Test how it behaves in a two-part parsing context
-        var inputs = new[] { "* TO 2013", "2012 TO *", "[* TO 2013]", "{2012 TO *}" };
+        string[] inputs = new[] { "* TO 2013", "2012 TO *", "[* TO 2013]", "{2012 TO *}" };
 
-        foreach (var input in inputs)
+        foreach (string input in inputs)
         {
             _logger.LogInformation("Testing two-part context for: '{Input}'", input);
 
@@ -104,10 +104,10 @@ public void TestInTwoPartContext()
             }
 
             // Find TO and test parsing after it
-            var toIndex = input.IndexOf(" TO ", StringComparison.OrdinalIgnoreCase);
+            int toIndex = input.IndexOf(" TO ", StringComparison.OrdinalIgnoreCase);
             if (toIndex >= 0)
             {
-                var afterTo = toIndex + 4;
+                int afterTo = toIndex + 4;
                 match = parser.Regex.Match(input, afterTo);
                 _logger.LogInformation("  After TO at position {Position}: Success: {Success}, Value: '{Value}', Index: {Index}, Length: {Length}", afterTo, match.Success, match.Value, match.Index, match.Length);
             }