Ensure that all base quantity units are BaseUnits (#1488)

lipchev · web-flow · commit 7556b7c313e2 · 2025-01-19T11:58:23.000+01:00
Ensure that all base quantity units are `BaseUnits`:
- introduced a test for each of the base quantities (`Length`, `Mass`
etc.) that ensures that all of their units have valid `BaseUnits`
definition
- fixed some incorrect `BaseUnits` definitions:
`Acceleration.StandardGravity` and `Temperature.MillidegreeCelsius`
- added missing `BaseUnits` definitions: `Length`, `Temperature` and
`TemperatureChangeRate` (removing 3 out of its 4 `[Skip]`-ed tests)
diff --git a/Common/UnitDefinitions/Acceleration.json b/Common/UnitDefinitions/Acceleration.json
@@ -131,10 +131,6 @@
     {
       "SingularName": "StandardGravity",
       "PluralName": "StandardGravity",
-      "BaseUnits": {
-        "L": "Meter",
-        "T": "Second"
-      },
       "FromUnitToBaseFunc": "{x} * 9.80665",
       "FromBaseToUnitFunc": "{x} / 9.80665",
       "Prefixes": [ "Milli"],
diff --git a/Common/UnitDefinitions/Length.json b/Common/UnitDefinitions/Length.json
@@ -337,6 +337,9 @@
     {
       "SingularName": "AstronomicalUnit",
       "PluralName": "AstronomicalUnits",
+      "BaseUnits": {
+        "L": "AstronomicalUnit"
+      },
       "FromUnitToBaseFunc": "{x} * 1.4959787070e11",
       "FromBaseToUnitFunc": "{x} / 1.4959787070e11",
       "XmlDocSummary": "One Astronomical Unit is the distance from the solar system Star, the sun, to planet Earth.",
@@ -351,6 +354,9 @@
     {
       "SingularName": "Parsec",
       "PluralName": "Parsecs",
+      "BaseUnits": {
+        "L": "Parsec"
+      },
       "FromUnitToBaseFunc": "{x} * 3.08567758128e16",
       "FromBaseToUnitFunc": "{x} / 3.08567758128e16",
       "XmlDocSummary": "A parsec is defined as the distance at which one astronomical unit (AU) subtends an angle of one arcsecond.",
@@ -366,6 +372,9 @@
     {
       "SingularName": "LightYear",
       "PluralName": "LightYears",
+      "BaseUnits": {
+        "L": "LightYear"
+      },
       "FromUnitToBaseFunc": "{x} * 9.46073047258e15",
       "FromBaseToUnitFunc": "{x} / 9.46073047258e15",
       "XmlDocSummary": "A Light Year (ly) is the distance that light travel during an Earth year, ie 365 days.",
@@ -381,6 +390,9 @@
     {
       "SingularName": "SolarRadius",
       "PluralName": "SolarRadiuses",
+      "BaseUnits": {
+        "L": "SolarRadius"
+      },
       "FromUnitToBaseFunc": "{x} * 6.95700e8",
       "FromBaseToUnitFunc": "{x} / 6.95700e8",
       "XmlDocSummary": "Solar radius is a ratio unit to the radius of the solar system star, the sun.",
@@ -427,6 +439,9 @@
     {
       "SingularName": "DataMile",
       "PluralName": "DataMiles",
+      "BaseUnits": {
+        "L": "DataMile"
+      },
       "FromUnitToBaseFunc": "{x} * 1828.8",
       "FromBaseToUnitFunc": "{x} / 1828.8",
       "XmlDocSummary": "In radar-related subjects and in JTIDS, a data mile is a unit of distance equal to 6000 feet (1.8288 kilometres or 0.987 nautical miles).",
diff --git a/Common/UnitDefinitions/Temperature.json b/Common/UnitDefinitions/Temperature.json
@@ -41,7 +41,7 @@
       "SingularName": "MillidegreeCelsius",
       "PluralName": "MillidegreesCelsius",
       "BaseUnits": {
-        "Θ": "DegreeCelsius"
+        "Θ": "MillidegreeCelsius"
       },
       "FromUnitToBaseFunc": "{x} / 1000 + 273.15",
       "FromBaseToUnitFunc": "({x} - 273.15) * 1000",
@@ -145,6 +145,9 @@
     {
       "SingularName": "SolarTemperature",
       "PluralName": "SolarTemperatures",
+      "BaseUnits": {
+        "Θ": "SolarTemperature"
+      },
       "FromUnitToBaseFunc": "{x} * 5778",
       "FromBaseToUnitFunc": "{x} / 5778",
       "Localization": [
diff --git a/Common/UnitDefinitions/TemperatureChangeRate.json b/Common/UnitDefinitions/TemperatureChangeRate.json
@@ -43,6 +43,10 @@
     {
       "SingularName": "DegreeKelvinPerMinute",
       "PluralName": "DegreesKelvinPerMinute",
+      "BaseUnits": {
+        "Θ": "Kelvin",
+        "T": "Minute"
+      },
       "FromUnitToBaseFunc": "{x} / 60",
       "FromBaseToUnitFunc": "{x} * 60",
       "Prefixes": [],
@@ -56,6 +60,10 @@
     {
       "SingularName": "DegreeFahrenheitPerMinute",
       "PluralName": "DegreesFahrenheitPerMinute",
+      "BaseUnits": {
+        "Θ": "DegreeFahrenheit",
+        "T": "Minute"
+      },
       "FromUnitToBaseFunc": "{x} * 5 / 9 / 60",
       "FromBaseToUnitFunc": "{x} * 9 / 5 * 60",
       "Localization": [
@@ -68,6 +76,10 @@
     {
       "SingularName": "DegreeFahrenheitPerSecond",
       "PluralName": "DegreesFahrenheitPerSecond",
+      "BaseUnits": {
+        "Θ": "DegreeFahrenheit",
+        "T": "Second"
+      },
       "FromUnitToBaseFunc": "{x} * 5 / 9",
       "FromBaseToUnitFunc": "{x} * 9 / 5",
       "Localization": [
@@ -80,6 +92,10 @@
     {
       "SingularName": "DegreeKelvinPerSecond",
       "PluralName": "DegreesKelvinPerSecond",
+      "BaseUnits": {
+        "Θ": "Kelvin",
+        "T": "Second"
+      },
       "FromUnitToBaseFunc": "{x}",
       "FromBaseToUnitFunc": "{x}",
       "Prefixes": [],
@@ -93,6 +109,10 @@
     {
       "SingularName": "DegreeCelsiusPerHour",
       "PluralName": "DegreesCelsiusPerHour",
+      "BaseUnits": {
+        "Θ": "DegreeCelsius",
+        "T": "Hour"
+      },
       "FromUnitToBaseFunc": "{x} / 3600",
       "FromBaseToUnitFunc": "{x} * 3600",
       "Localization": [
@@ -105,6 +125,10 @@
     {
       "SingularName": "DegreeKelvinPerHour",
       "PluralName": "DegreesKelvinPerHour",
+      "BaseUnits": {
+        "Θ": "Kelvin",
+        "T": "Hour"
+      },
       "FromUnitToBaseFunc": "{x} / 3600",
       "FromBaseToUnitFunc": "{x} * 3600",
       "Prefixes": [],
@@ -118,6 +142,10 @@
     {
       "SingularName": "DegreeFahrenheitPerHour",
       "PluralName": "DegreesFahrenheitPerHour",
+      "BaseUnits": {
+        "Θ": "DegreeFahrenheit",
+        "T": "Hour"
+      },
       "FromUnitToBaseFunc": "{x} * 5 / 9 / 3600",
       "FromBaseToUnitFunc": "{x} * 9 / 5 * 3600",
       "Localization": [
diff --git a/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs b/UnitsNet.Tests/CustomCode/AmountOfSubstanceTests.cs
@@ -47,6 +47,12 @@ public class AmountOfSubstanceTests : AmountOfSubstanceTestsBase
         protected override double MegamolesInOneMole => 1e-6;
         protected override double PicomolesInOneMole => 1e12;
         protected override double FemtomolesInOneMole => 1e15;
+        
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(AmountOfSubstance.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(amount: unitInfo.Value), unitInfo.BaseUnits));
+        }
 
         [Fact]
         public void NumberOfParticlesInOneMoleEqualsAvogadroConstant()
diff --git a/UnitsNet.Tests/CustomCode/DurationTests.cs b/UnitsNet.Tests/CustomCode/DurationTests.cs
@@ -34,6 +34,12 @@ public class DurationTests : DurationTestsBase
         protected override double JulianYearsInOneSecond => 3.16880878140289e-08;
 
         protected override double SolsInOneSecond => 1.126440159375963e-5;
+        
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(Duration.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(time: unitInfo.Value), unitInfo.BaseUnits));
+        }
 
         [Fact]
         public static void ToTimeSpanShouldThrowExceptionOnValuesLargerThanTimeSpanMax()
diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs
@@ -28,6 +28,12 @@ public class ElectricCurrentTests : ElectricCurrentTestsBase
         protected override double KiloamperesInOneAmpere => 1e-3;
 
         protected override double MegaamperesInOneAmpere => 1e-6;
+        
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(ElectricCurrent.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(current: unitInfo.Value), unitInfo.BaseUnits));
+        }
 
         [Theory]
         [InlineData(1, 1, 1)]
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -88,38 +88,44 @@ public class LengthTests : LengthTestsBase
 
         protected override double KilofeetInOneMeter => 3.28083989501e-3;
 
-        [ Fact]
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(Length.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(unitInfo.Value), unitInfo.BaseUnits));
+        }
+
+        [Fact]
         public void AreaTimesLengthEqualsVolume()
         {
-            Volume volume = Area.FromSquareMeters(10)*Length.FromMeters(3);
+            Volume volume = Area.FromSquareMeters(10) * Length.FromMeters(3);
             Assert.Equal(volume, Volume.FromCubicMeters(30));
         }
 
         [Fact]
         public void ForceTimesLengthEqualsTorque()
         {
-            Torque torque = Force.FromNewtons(1)*Length.FromMeters(3);
+            Torque torque = Force.FromNewtons(1) * Length.FromMeters(3);
             Assert.Equal(torque, Torque.FromNewtonMeters(3));
         }
 
         [Fact]
         public void LengthTimesAreaEqualsVolume()
         {
-            Volume volume = Length.FromMeters(3)*Area.FromSquareMeters(9);
+            Volume volume = Length.FromMeters(3) * Area.FromSquareMeters(9);
             Assert.Equal(volume, Volume.FromCubicMeters(27));
         }
 
         [Fact]
         public void LengthTimesForceEqualsTorque()
         {
-            Torque torque = Length.FromMeters(3)*Force.FromNewtons(1);
+            Torque torque = Length.FromMeters(3) * Force.FromNewtons(1);
             Assert.Equal(torque, Torque.FromNewtonMeters(3));
         }
 
         [Fact]
         public void LengthTimesLengthEqualsArea()
         {
-            Area area = Length.FromMeters(10)*Length.FromMeters(2);
+            Area area = Length.FromMeters(10) * Length.FromMeters(2);
             Assert.Equal(area, Area.FromSquareMeters(20));
         }
 
@@ -167,7 +173,7 @@ public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnitWhichIsMeter()
         }
 
         [Fact]
-        public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit()
+        public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefaultUnit()
         {
             var value = Length.From(2, LengthUnit.Centimeter);
             string valueString = value.ToString(CultureInfo.InvariantCulture);
diff --git a/UnitsNet.Tests/CustomCode/LuminousIntensityTests.cs b/UnitsNet.Tests/CustomCode/LuminousIntensityTests.cs
@@ -22,12 +22,19 @@
 
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class LuminousIntensityTests : LuminousIntensityTestsBase
     {
         protected override bool SupportsSIUnitSystem => true;
         protected override double CandelaInOneCandela => 1;
+        
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(LuminousIntensity.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(luminousIntensity: unitInfo.Value), unitInfo.BaseUnits));
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -67,31 +67,37 @@ public class MassTests : MassTestsBase
 
         protected override double PicogramsInOneKilogram => 1E15;
         
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(Mass.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(mass: unitInfo.Value), unitInfo.BaseUnits));
+        }
+
         [Fact]
         public void AccelerationTimesMassEqualsForce()
         {
-            Force force = Acceleration.FromMetersPerSecondSquared(3)*Mass.FromKilograms(18);
+            Force force = Acceleration.FromMetersPerSecondSquared(3) * Mass.FromKilograms(18);
             Assert.Equal(force, Force.FromNewtons(54));
         }
 
         [Fact]
         public void MassDividedByDurationEqualsMassFlow()
         {
-            MassFlow massFlow = Mass.FromKilograms(18.0)/Duration.FromSeconds(6);
+            MassFlow massFlow = Mass.FromKilograms(18.0) / Duration.FromSeconds(6);
             Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
         }
 
         [Fact]
         public void MassDividedByTimeSpanEqualsMassFlow()
         {
-            MassFlow massFlow = Mass.FromKilograms(18.0)/TimeSpan.FromSeconds(6);
+            MassFlow massFlow = Mass.FromKilograms(18.0) / TimeSpan.FromSeconds(6);
             Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
         }
 
         [Fact]
         public void MassDividedByVolumeEqualsDensity()
         {
-            Density density = Mass.FromKilograms(18)/Volume.FromCubicMeters(3);
+            Density density = Mass.FromKilograms(18) / Volume.FromCubicMeters(3);
             Assert.Equal(density, Density.FromKilogramsPerCubicMeter(6));
         }
 
@@ -112,7 +118,7 @@ public void MassDividedByAreaDensityEqualsArea()
         [Fact]
         public void MassTimesAccelerationEqualsForce()
         {
-            Force force = Mass.FromKilograms(18)*Acceleration.FromMetersPerSecondSquared(3);
+            Force force = Mass.FromKilograms(18) * Acceleration.FromMetersPerSecondSquared(3);
             Assert.Equal(force, Force.FromNewtons(54));
         }
 
diff --git a/UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs b/UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs
@@ -43,30 +43,12 @@ public class TemperatureChangeRateTests : TemperatureChangeRateTestsBase
 
         protected override double DegreesCelsiusPerHourInOneDegreeCelsiusPerSecond => 3600;
         
-
-        [Fact(Skip = "Missing the KelvinPerSecond unit")]
-        public override void Ctor_SIUnitSystem_ReturnsQuantityWithSIUnits()
-        {
-            base.Ctor_SIUnitSystem_ReturnsQuantityWithSIUnits();
-        }
         
         [Fact(Skip = "See about changing the BaseUnit to KelvinPerSecond")]
         public override void BaseUnit_HasSIBase()
         {
             base.BaseUnit_HasSIBase();
         }
-        
-        [Fact(Skip = "Missing the KelvinPerSecond unit")]
-        public override void As_UnitSystem_SI_ReturnsQuantityInSIUnits()
-        {
-            base.As_UnitSystem_SI_ReturnsQuantityInSIUnits();
-        }
-        
-        [Fact(Skip = "Missing the KelvinPerSecond unit")]
-        public override void ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits()
-        {
-            base.ToUnit_UnitSystem_SI_ReturnsQuantityInSIUnits();
-        }
 
         [Fact]
         public void TemperatureChangeRateMultipliedWithTimeSpanEqualsTemperatureDelta()
diff --git a/UnitsNet.Tests/CustomCode/TemperatureTests.cs b/UnitsNet.Tests/CustomCode/TemperatureTests.cs
@@ -29,6 +29,12 @@ public class TemperatureTests : TemperatureTestsBase
         protected override double MillidegreesCelsiusInOneKelvin => -272150;
 
         protected override double SolarTemperaturesInOneKelvin => 1.73070266528210E-04;
+        
+        [Fact]
+        public void AllBaseQuantityUnitsAreBaseUnits()
+        {
+            Assert.All(Temperature.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(temperature: unitInfo.Value), unitInfo.BaseUnits));
+        }
 
         public static IEnumerable<object[]> DividedByTemperatureDeltaEqualsTemperatureData { get; } =
             new List<object[]>
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs

Original file line number	Diff line number	Diff line change
`@@ -88,38 +88,44 @@ public class LengthTests : LengthTestsBase`
`88`	`88`
`89`	`89`	`protected override double KilofeetInOneMeter => 3.28083989501e-3;`
`90`	`90`
`91`		`- [ Fact]`
	`91`	`+ [Fact]`
	`92`	`+ public void AllBaseQuantityUnitsAreBaseUnits()`
	`93`	`+ {`
	`94`	`+ Assert.All(Length.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(unitInfo.Value), unitInfo.BaseUnits));`
	`95`	`+ }`
	`96`	`+`
	`97`	`+ [Fact]`
`92`	`98`	`public void AreaTimesLengthEqualsVolume()`
`93`	`99`	`{`
`94`		`- Volume volume = Area.FromSquareMeters(10)*Length.FromMeters(3);`
	`100`	`+ Volume volume = Area.FromSquareMeters(10) * Length.FromMeters(3);`
`95`	`101`	`Assert.Equal(volume, Volume.FromCubicMeters(30));`
`96`	`102`	`}`
`97`	`103`
`98`	`104`	`[Fact]`
`99`	`105`	`public void ForceTimesLengthEqualsTorque()`
`100`	`106`	`{`
`101`		`- Torque torque = Force.FromNewtons(1)*Length.FromMeters(3);`
	`107`	`+ Torque torque = Force.FromNewtons(1) * Length.FromMeters(3);`
`102`	`108`	`Assert.Equal(torque, Torque.FromNewtonMeters(3));`
`103`	`109`	`}`
`104`	`110`
`105`	`111`	`[Fact]`
`106`	`112`	`public void LengthTimesAreaEqualsVolume()`
`107`	`113`	`{`
`108`		`- Volume volume = Length.FromMeters(3)*Area.FromSquareMeters(9);`
	`114`	`+ Volume volume = Length.FromMeters(3) * Area.FromSquareMeters(9);`
`109`	`115`	`Assert.Equal(volume, Volume.FromCubicMeters(27));`
`110`	`116`	`}`
`111`	`117`
`112`	`118`	`[Fact]`
`113`	`119`	`public void LengthTimesForceEqualsTorque()`
`114`	`120`	`{`
`115`		`- Torque torque = Length.FromMeters(3)*Force.FromNewtons(1);`
	`121`	`+ Torque torque = Length.FromMeters(3) * Force.FromNewtons(1);`
`116`	`122`	`Assert.Equal(torque, Torque.FromNewtonMeters(3));`
`117`	`123`	`}`
`118`	`124`
`119`	`125`	`[Fact]`
`120`	`126`	`public void LengthTimesLengthEqualsArea()`
`121`	`127`	`{`
`122`		`- Area area = Length.FromMeters(10)*Length.FromMeters(2);`
	`128`	`+ Area area = Length.FromMeters(10) * Length.FromMeters(2);`
`123`	`129`	`Assert.Equal(area, Area.FromSquareMeters(20));`
`124`	`130`	`}`
`125`	`131`
`@@ -167,7 +173,7 @@ public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnitWhichIsMeter()`
`167`	`173`	`}`
`168`	`174`
`169`	`175`	`[Fact]`
`170`		`- public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit()`
	`176`	`+ public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefaultUnit()`
`171`	`177`	`{`
`172`	`178`	`var value = Length.From(2, LengthUnit.Centimeter);`
`173`	`179`	`string valueString = value.ToString(CultureInfo.InvariantCulture);`
Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,19 @@`
`22`	`22`
`23`	`23`
`24`	`24`	`using System;`
	`25`	`+using Xunit;`
`25`	`26`
`26`	`27`	`namespace UnitsNet.Tests.CustomCode`
`27`	`28`	`{`
`28`	`29`	`public class LuminousIntensityTests : LuminousIntensityTestsBase`
`29`	`30`	`{`
`30`	`31`	`protected override bool SupportsSIUnitSystem => true;`
`31`	`32`	`protected override double CandelaInOneCandela => 1;`
	`33`	`+`
	`34`	`+ [Fact]`
	`35`	`+ public void AllBaseQuantityUnitsAreBaseUnits()`
	`36`	`+ {`
	`37`	`+ Assert.All(LuminousIntensity.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(luminousIntensity: unitInfo.Value), unitInfo.BaseUnits));`
	`38`	`+ }`
`32`	`39`	`}`
`33`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,31 +67,37 @@ public class MassTests : MassTestsBase`
`67`	`67`
`68`	`68`	`protected override double PicogramsInOneKilogram => 1E15;`
`69`	`69`
	`70`	`+ [Fact]`
	`71`	`+ public void AllBaseQuantityUnitsAreBaseUnits()`
	`72`	`+ {`
	`73`	`+ Assert.All(Mass.Info.UnitInfos, unitInfo => Assert.Equal(new BaseUnits(mass: unitInfo.Value), unitInfo.BaseUnits));`
	`74`	`+ }`
	`75`	`+`
`70`	`76`	`[Fact]`
`71`	`77`	`public void AccelerationTimesMassEqualsForce()`
`72`	`78`	`{`
`73`		`- Force force = Acceleration.FromMetersPerSecondSquared(3)*Mass.FromKilograms(18);`
	`79`	`+ Force force = Acceleration.FromMetersPerSecondSquared(3) * Mass.FromKilograms(18);`
`74`	`80`	`Assert.Equal(force, Force.FromNewtons(54));`
`75`	`81`	`}`
`76`	`82`
`77`	`83`	`[Fact]`
`78`	`84`	`public void MassDividedByDurationEqualsMassFlow()`
`79`	`85`	`{`
`80`		`- MassFlow massFlow = Mass.FromKilograms(18.0)/Duration.FromSeconds(6);`
	`86`	`+ MassFlow massFlow = Mass.FromKilograms(18.0) / Duration.FromSeconds(6);`
`81`	`87`	`Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(3.0));`
`82`	`88`	`}`
`83`	`89`
`84`	`90`	`[Fact]`
`85`	`91`	`public void MassDividedByTimeSpanEqualsMassFlow()`
`86`	`92`	`{`
`87`		`- MassFlow massFlow = Mass.FromKilograms(18.0)/TimeSpan.FromSeconds(6);`
	`93`	`+ MassFlow massFlow = Mass.FromKilograms(18.0) / TimeSpan.FromSeconds(6);`
`88`	`94`	`Assert.Equal(massFlow, MassFlow.FromKilogramsPerSecond(3.0));`
`89`	`95`	`}`
`90`	`96`
`91`	`97`	`[Fact]`
`92`	`98`	`public void MassDividedByVolumeEqualsDensity()`
`93`	`99`	`{`
`94`		`- Density density = Mass.FromKilograms(18)/Volume.FromCubicMeters(3);`
	`100`	`+ Density density = Mass.FromKilograms(18) / Volume.FromCubicMeters(3);`
`95`	`101`	`Assert.Equal(density, Density.FromKilogramsPerCubicMeter(6));`
`96`	`102`	`}`
`97`	`103`
`@@ -112,7 +118,7 @@ public void MassDividedByAreaDensityEqualsArea()`
`112`	`118`	`[Fact]`
`113`	`119`	`public void MassTimesAccelerationEqualsForce()`
`114`	`120`	`{`
`115`		`- Force force = Mass.FromKilograms(18)*Acceleration.FromMetersPerSecondSquared(3);`
	`121`	`+ Force force = Mass.FromKilograms(18) * Acceleration.FromMetersPerSecondSquared(3);`
`116`	`122`	`Assert.Equal(force, Force.FromNewtons(54));`
`117`	`123`	`}`
`118`	`124`