✅ Generate tests for parsing via each quantity type (#1086)

Author: angularsen

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -281,6 +281,84 @@ public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
             }}
         }}
 
+        [Fact]
+        public void Parse()
+        {{");
+            foreach(var unit in _quantity.Units.Where(u => string.IsNullOrEmpty(u.ObsoleteText)))
+            foreach(var localization in unit.Localization)
+            foreach(var abbreviation in localization.Abbreviations)
+            {
+                Writer.WL($@"
+            try
+            {{
+                var parsed = {_quantity.Name}.Parse(""1 {abbreviation}"", CultureInfo.GetCultureInfo(""{localization.Culture}""));
+                AssertEx.EqualTolerance(1, parsed.{unit.PluralName}, {unit.PluralName}Tolerance);
+                Assert.Equal({GetUnitFullName(unit)}, parsed.Unit);
+            }} catch (AmbiguousUnitParseException) {{ /* Some units have the same abbreviations */ }}
+");
+            }
+            Writer.WL($@"
+        }}
+
+        [Fact]
+        public void TryParse()
+        {{");
+            foreach(var unit in _quantity.Units.Where(u => string.IsNullOrEmpty(u.ObsoleteText)))
+            foreach(var localization in unit.Localization)
+            foreach(var abbreviation in localization.Abbreviations)
+            {
+                // Skip units with ambiguous abbreviations, since there is no exception to describe this is why TryParse failed.
+                if (IsAmbiguousAbbreviation(localization, abbreviation)) continue;
+
+                Writer.WL($@"
+            {{
+                Assert.True({_quantity.Name}.TryParse(""1 {abbreviation}"", CultureInfo.GetCultureInfo(""{localization.Culture}""), out var parsed));
+                AssertEx.EqualTolerance(1, parsed.{unit.PluralName}, {unit.PluralName}Tolerance);
+                Assert.Equal({GetUnitFullName(unit)}, parsed.Unit);
+            }}
+");
+            }
+            Writer.WL($@"
+        }}
+
+        [Fact]
+        public void ParseUnit()
+        {{");
+            foreach(var unit in _quantity.Units.Where(u => string.IsNullOrEmpty(u.ObsoleteText)))
+            foreach(var localization in unit.Localization)
+            foreach(var abbreviation in localization.Abbreviations)
+            {
+                Writer.WL($@"
+            try
+            {{
+                var parsedUnit = {_quantity.Name}.ParseUnit(""{abbreviation}"", CultureInfo.GetCultureInfo(""{localization.Culture}""));
+                Assert.Equal({GetUnitFullName(unit)}, parsedUnit);
+            }} catch (AmbiguousUnitParseException) {{ /* Some units have the same abbreviations */ }}
+");
+            }
+            Writer.WL($@"
+        }}
+
+        [Fact]
+        public void TryParseUnit()
+        {{");
+            foreach(var unit in _quantity.Units.Where(u => string.IsNullOrEmpty(u.ObsoleteText)))
+            foreach(var localization in unit.Localization)
+            foreach(var abbreviation in localization.Abbreviations)
+            {
+                // Skip units with ambiguous abbreviations, since there is no exception to describe this is why TryParse failed.
+                if (IsAmbiguousAbbreviation(localization, abbreviation)) continue;
+
+                Writer.WL($@"
+            {{
+                Assert.True({_quantity.Name}.TryParseUnit(""{abbreviation}"", CultureInfo.GetCultureInfo(""{localization.Culture}""), out var parsedUnit));
+                Assert.Equal({GetUnitFullName(unit)}, parsedUnit);
+            }}
+");
+            }
+            Writer.WL($@"
+        }}
+
         [Theory]
         [MemberData(nameof(UnitTypes))]
         public void ToUnit({_unitEnumName} unit)
@@ -766,5 +844,12 @@ public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
 }}");
             return Writer.ToString();
         }
+
+        private bool IsAmbiguousAbbreviation(Localization localization, string abbreviation)
+        {
+            return _quantity.Units.Count(u =>
+                u.Localization.SingleOrDefault(l => l.Culture == localization.Culture) is { } otherUnitLocalization &&
+                otherUnitLocalization.Abbreviations.Contains(abbreviation, StringComparer.OrdinalIgnoreCase)) > 1;
+        }
     }
 }

UnitsNet.Tests/CustomCode/PorousMediumPermeabilityTests.cs

@@ -37,50 +37,5 @@ public class PorousMediumPermeabilityTests : PorousMediumPermeabilityTestsBase
         protected override double SquareCentimetersInOneSquareMeter => 10000;
 
         protected override double SquareMetersInOneSquareMeter => 1;
-
-        [Theory]
-        [InlineData("2 D", 2, PorousMediumPermeabilityUnit.Darcy)]
-        [InlineData("2 mD", 2, PorousMediumPermeabilityUnit.Millidarcy)]
-        [InlineData("2 µD", 2, PorousMediumPermeabilityUnit.Microdarcy)]
-        [InlineData("2 m²", 2, PorousMediumPermeabilityUnit.SquareMeter)]
-        [InlineData("2 cm²", 2, PorousMediumPermeabilityUnit.SquareCentimeter)]
-        public void Parse(string input, double value, PorousMediumPermeabilityUnit unit)
-        {
-            var result = PorousMediumPermeability.Parse(input);
-            Assert.Equal(value, result.Value);
-            Assert.Equal(unit, result.Unit);
-        }
-
-        [Theory]
-        [InlineData("2 D", true)]
-        [InlineData("2 kD", false)]
-        public void TryParse(string input, bool successful)
-        {
-            PorousMediumPermeability unit;
-            var result = PorousMediumPermeability.TryParse(input, out unit);
-            Assert.Equal(successful, result);
-        }
-
-        [Theory]
-        [InlineData("D", PorousMediumPermeabilityUnit.Darcy)]
-        [InlineData("mD", PorousMediumPermeabilityUnit.Millidarcy)]
-        [InlineData("µD", PorousMediumPermeabilityUnit.Microdarcy)]
-        [InlineData("m²", PorousMediumPermeabilityUnit.SquareMeter)]
-        [InlineData("cm²", PorousMediumPermeabilityUnit.SquareCentimeter)]
-        public void ParseUnit(string input, PorousMediumPermeabilityUnit unit)
-        {
-            var result = PorousMediumPermeability.ParseUnit(input);
-            Assert.Equal(unit, result);
-        }
-
-        [Theory]
-        [InlineData("mD", true)]
-        [InlineData("kD", false)]
-        public void TryParseUnit(string input, bool successful)
-        {
-            PorousMediumPermeabilityUnit unit;
-            var result = PorousMediumPermeability.TryParseUnit(input, out unit);
-            Assert.Equal(successful, result);
-        }
     }
 }