added tests for supported unit systems (Ctor/As/ToUnit)

- fixed typo in unit system for Length
- Ctor_UnitSystem_ThrowsArgumentExceptionIfNotSupported
- Ctor_WithNullUnitSystem_ThrowsArgumentNullException
- As_UnitSystem_ThrowsArgumentExceptionIfNotSupported
- As_WithNullUnitSystem_ThrowsArgumentNullException
- To_UnitSystem_ThrowsArgumentExceptionIfNotSupported
- ToUnit_WithNullUnitSystem_ThrowsNullException

Author: lipchev

CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs

@@ -1,14 +1,18 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using CodeGen.JsonTypes;
 
 namespace CodeGen.Generators.UnitsNetGen
 {
     internal class UnitTestBaseClassGenerator : GeneratorBase
     {
+        private static string[] SupportedUnitSystems = {"SI", "CGS", "BI", "EE", "USC", "FPS", "Astronomical"};
+
         private readonly Quantity _quantity;
         private readonly Unit _baseUnit;
         private readonly string _unitEnumName;
+        private readonly Dictionary<string, Unit> _unitSystemUnits = new Dictionary<string, Unit>();
 
         public UnitTestBaseClassGenerator(Quantity quantity)
         {
@@ -17,6 +21,12 @@ public UnitTestBaseClassGenerator(Quantity quantity)
                         throw new ArgumentException($"No unit found with SingularName equal to BaseUnit [{_quantity.BaseUnit}]. This unit must be defined.",
                             nameof(quantity));
             _unitEnumName = $"{quantity.Name}Unit";
+            foreach (var unitSystemMapping in quantity.UnitSystems)
+            {
+                _unitSystemUnits.Add(unitSystemMapping.UnitSystem, quantity.Units.FirstOrDefault(u => u.SingularName == unitSystemMapping.BaseUnit) ??
+                                                 throw new ArgumentException($"No unit found with SingularName equal to the one defined for '{unitSystemMapping.UnitSystem}' [{unitSystemMapping.BaseUnit}]. This unit must be defined.",
+                                                     nameof(quantity)));
+            }
         }
 
         public override string Generate()
@@ -73,6 +83,31 @@ public void Ctor_WithNaNValue_ThrowsArgumentException()
         }}
 "); Writer.WL($@"
 
+        [Fact]
+        public void Ctor_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
+        {{");
+            foreach (var unit in _unitSystemUnits)
+            {
+                var asQuantityVariableName = $"{unit.Key.ToLowerInvariant()}Quantity";
+
+                Writer.WL($@"
+            var {asQuantityVariableName} = new {_quantity.Name}(1, UnitSystem.{unit.Key});
+            Assert.Equal(1, (double){asQuantityVariableName}.Value);
+            Assert.Equal({_unitEnumName}.{unit.Value.SingularName}, {asQuantityVariableName}.Unit);");
+                Writer.WL();
+            }
+            foreach (var unitSystem in SupportedUnitSystems.Where(x => !_unitSystemUnits.ContainsKey(x))) Writer.WL($@"
+            Assert.Throws<ArgumentException>(() => new {_quantity.Name}(1, UnitSystem.{unitSystem}));");
+            Writer.WL($@"
+        }}
+
+        [Fact]
+        public void Ctor_WithNullUnitSystem_ThrowsArgumentNullException()
+        {{
+            Assert.Throws<ArgumentNullException>(() => new {_quantity.Name}(1, null));");
+            Writer.WL($@"
+        }}
+
         [Fact]
         public void {_baseUnit.SingularName}To{_quantity.Name}Units()
         {{
@@ -115,6 +150,28 @@ public void As()
             Writer.WL($@"
         }}
 
+        [Fact]
+        public void As_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
+        {{
+            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            if(_unitSystemUnits.Any()) Writer.WL();
+            foreach (var unitSystem in _unitSystemUnits) Writer.WL($@"
+            AssertEx.EqualTolerance({unitSystem.Value.PluralName}InOne{_baseUnit.SingularName}, {baseUnitVariableName}.As(UnitSystem.{unitSystem.Key}), {unitSystem.Value.PluralName}Tolerance);");
+            if(_unitSystemUnits.Count < SupportedUnitSystems.Length) Writer.WL();
+            foreach (var unitSystem in SupportedUnitSystems.Where(x => !_unitSystemUnits.ContainsKey(x))) Writer.WL($@"
+            Assert.Throws<ArgumentException>(() => {baseUnitVariableName}.As(UnitSystem.{unitSystem}));");
+            Writer.WL($@"
+        }}
+
+        [Fact]
+        public void As_WithNullUnitSystem_ThrowsArgumentNullException()
+        {{
+            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            Writer.WL($@" 
+            Assert.Throws<ArgumentNullException>(() => {baseUnitVariableName}.As(null));");
+            Writer.WL($@"
+        }}
+
         [Fact]
         public void ToUnit()
         {{
@@ -123,7 +180,7 @@ public void ToUnit()
             {
                 var asQuantityVariableName = $"{unit.SingularName.ToLowerInvariant()}Quantity";
 
-                Writer.WL("");
+                Writer.WL();
                 Writer.WL($@"
             var {asQuantityVariableName} = {baseUnitVariableName}.ToUnit({_unitEnumName}.{unit.SingularName});
             AssertEx.EqualTolerance({unit.PluralName}InOne{_baseUnit.SingularName}, (double){asQuantityVariableName}.Value, {unit.PluralName}Tolerance);
@@ -132,6 +189,35 @@ public void ToUnit()
             Writer.WL($@"
         }}
 
+        [Fact]
+        public void To_UnitSystem_ThrowsArgumentExceptionIfNotSupported()
+        {{
+            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            foreach (var unit in _unitSystemUnits)
+            {
+                var asQuantityVariableName = $"{unit.Key.ToLowerInvariant()}Quantity";
+
+                Writer.WL();
+                Writer.WL($@"
+            var {asQuantityVariableName} = {baseUnitVariableName}.ToUnit(UnitSystem.{unit.Key});
+            AssertEx.EqualTolerance({unit.Value.PluralName}InOne{_baseUnit.SingularName}, (double){asQuantityVariableName}.Value, {unit.Value.PluralName}Tolerance);
+            Assert.Equal({_unitEnumName}.{unit.Value.SingularName}, {asQuantityVariableName}.Unit);");
+            }
+            if(_unitSystemUnits.Count < SupportedUnitSystems.Length) Writer.WL();
+            foreach (var unitSystem in SupportedUnitSystems.Where(x => !_unitSystemUnits.ContainsKey(x))) Writer.WL($@"
+            Assert.Throws<ArgumentException>(() => {baseUnitVariableName}.ToUnit(UnitSystem.{unitSystem}));");
+            Writer.WL($@"
+        }}
+
+        [Fact]
+        public void ToUnit_WithNullUnitSystem_ThrowsNullException()
+        {{
+            var {baseUnitVariableName} = {_quantity.Name}.From{_baseUnit.PluralName}(1);");
+            Writer.WL($@" 
+            Assert.Throws<ArgumentNullException>(() => {baseUnitVariableName}.ToUnit(null));");
+            Writer.WL($@"
+        }}
+
         [Fact]
         public void ConversionRoundTrip()
         {{
@@ -182,7 +268,7 @@ public void ArithmeticOperators()
             }
             else
             {
-                Writer.WL("");
+                Writer.WL();
             }
 
             Writer.WL($@"

Common/UnitDefinitions/Length.json

@@ -382,7 +382,7 @@
       "BaseUnit": "Foot"
     },
     {
-      "UnitSystem": "UCS",
+      "UnitSystem": "USC",
       "BaseUnit": "Yard"
     },
     {