Even more CultureInfo.InvarantCulture for the URC inspection and its tests

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseInspection/ExpressionFilterFactory.cs

@@ -2,55 +2,56 @@
 using Rubberduck.Parsing.Grammar;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 
 namespace Rubberduck.Inspections.Concrete.UnreachableCaseInspection{
 
     public static class ExpressionFilterFactory
     {
-        private static Dictionary<string, (long typeMin, long typeMax)> IntegralNumberExtents = new Dictionary<string, (long typeMin, long typeMax)>()
+        private static readonly Dictionary<string, (long typeMin, long typeMax)> IntegralNumberExtents = new Dictionary<string, (long typeMin, long typeMax)>()
         {
             [Tokens.LongLong] = (long.MinValue, long.MaxValue),
-            [Tokens.Long] = (Int32.MinValue, Int32.MaxValue),
-            [Tokens.Integer] = (Int16.MinValue, Int16.MaxValue),
-            [Tokens.Int] = (Int16.MinValue, Int16.MaxValue),
+            [Tokens.Long] = (int.MinValue, int.MaxValue),
+            [Tokens.Integer] = (short.MinValue, short.MaxValue),
+            [Tokens.Int] = (short.MinValue, short.MaxValue),
             [Tokens.Byte] = (byte.MinValue, byte.MaxValue)
         };
 
         public static IExpressionFilter Create(string valueType)
         {
             if (IntegralNumberExtents.Keys.Contains(valueType))
             {
-                var integralNumberFilter = new ExpressionFilterIntegral(valueType, long.Parse);
+                var integralNumberFilter = new ExpressionFilterIntegral(valueType, s => long.Parse(s, CultureInfo.InvariantCulture));
                 integralNumberFilter.SetExtents(IntegralNumberExtents[valueType].typeMin, IntegralNumberExtents[valueType].typeMax);
                 return integralNumberFilter;
             }
-            else if (valueType.Equals(Tokens.Double) || valueType.Equals(Tokens.Single))
+            if (valueType.Equals(Tokens.Double) || valueType.Equals(Tokens.Single))
             {
-                var floatingPointNumberFilter = new ExpressionFilter<double>(valueType, double.Parse);
+                var floatingPointNumberFilter = new ExpressionFilter<double>(valueType, s => double.Parse(s, CultureInfo.InvariantCulture));
                 if (valueType.Equals(Tokens.Single))
                 {
                     floatingPointNumberFilter.SetExtents(float.MinValue, float.MaxValue);
                 }
                 return floatingPointNumberFilter;
             }
-            else if (valueType.Equals(Tokens.Currency))
+            if (valueType.Equals(Tokens.Currency))
             {
                 var fixedPointNumberFilter = new ExpressionFilter<decimal>(valueType, VBACurrency.Parse);
                 fixedPointNumberFilter.SetExtents(VBACurrency.MinValue, VBACurrency.MaxValue);
                 return fixedPointNumberFilter;
             }
-            else if (valueType.Equals(Tokens.Boolean))
+            if (valueType.Equals(Tokens.Boolean))
             {
                 return new ExpressionFilterBoolean();
             }
 
-            else if (valueType.Equals(Tokens.Date))
+            if (valueType.Equals(Tokens.Date))
             {
                 return new ExpressionFilterDate();
             }
 
-            return new ExpressionFilter<string>(valueType, (a) => { return a; });
+            return new ExpressionFilter<string>(valueType, a => a);
         }
     }
 }

RubberduckTests/Inspections/UnreachableCase/ExpressionFilterUnitTests.cs

@@ -491,7 +491,7 @@ private IParseTreeValue CreateInspValueFrom(string valAndType)
             {
                 var args = RetrieveDelimitedElements(valAndType, VALUE_TYPE_DELIMITER);
                 var value = args[0];
-                string declaredType = args[1].Equals(string.Empty) ? null : args[1];
+                var declaredType = args[1].Equals(string.Empty) ? null : args[1];
                 if (declaredType is null)
                 {
                     return ValueFactory.Create(value);
@@ -533,12 +533,12 @@ private IEnumerable<IRangeClauseExpression> RangeClauseTokensToExpressions(IEnum
                 var operandDelimiters = clause.Where(ch => ch.Equals('_'));
                 if (operandDelimiters.Count() == 2)
                 {
-                    (IParseTreeValue lhs, IParseTreeValue rhs, string symbol) = GetBinaryOpValues(clause);
+                    var (lhs, rhs, symbol) = GetBinaryOpValues(clause);
                     expressionClause = CreateRangeClauseExpression((lhs, rhs, symbol));
                 }
                 else if (operandDelimiters.Count() <= 1)
                 {
-                    (IParseTreeValue operand, string symbol) = GetUnaryOpValues(clause);
+                    var (operand, symbol) = GetUnaryOpValues(clause);
                     if (symbol.Equals(LogicalOperators.NOT))
                     {
                         expressionClause = new UnaryExpression(operand, symbol);

RubberduckTests/Inspections/UnreachableCase/ParseTreeExpressionEvaluatorUnitTests.cs

@@ -2,6 +2,7 @@
 using Rubberduck.Inspections.Concrete.UnreachableCaseInspection;
 using Rubberduck.Parsing.Grammar;
 using System;
+using System.Globalization;
 
 namespace RubberduckTests.Inspections.UnreachableCase
 {
@@ -942,8 +943,8 @@ private IParseTreeValue CreateInspValueFrom(string valAndType, string conformTo
             {
                 var compareLength = expected.Length > 5 ? 5 : expected.Length;
                 var accuracy = Math.Pow(10, -1.0 * compareLength);
-                var lhs = double.Parse(result.Token.Substring(0, compareLength));
-                var rhs = double.Parse(expected.Substring(0, compareLength));
+                var lhs = double.Parse(result.Token.Substring(0, compareLength), CultureInfo.InvariantCulture);
+                var rhs = double.Parse(expected.Substring(0, compareLength), CultureInfo.InvariantCulture);
                 Assert.IsTrue(Math.Abs(lhs - rhs) <= accuracy, $"Actual={result.Token} Expected={expected}");
                 return (result,result);
             }

RubberduckTests/UnitTesting/EngineTests.cs

@@ -45,6 +45,7 @@ Public Sub TestMethod1()
                 int refreshes = 0;
                 engine.TestsRefreshed += (sender, args) => refreshes++;
                 parser.Parse(new CancellationTokenSource());
+                var status = state.Status;
                 if (!engine.CanRun)
                 {
                     Assert.Inconclusive("Parser Error");