Adding method to convert quantity into another quantity (#457)

* Adding method to convert quantity into another quantity

* Renaming AsQuantity to ToUnit

Author: tmilnthorp

UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs

@@ -138,6 +138,64 @@ public void As()
             AssertEx.EqualTolerance(StandardGravityInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.StandardGravity), StandardGravityTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+
+            var centimeterpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.CentimeterPerSecondSquared);
+            AssertEx.EqualTolerance(CentimetersPerSecondSquaredInOneMeterPerSecondSquared, (double)centimeterpersecondsquaredQuantity.Value, CentimetersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.CentimeterPerSecondSquared, centimeterpersecondsquaredQuantity.Unit);
+
+            var decimeterpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.DecimeterPerSecondSquared);
+            AssertEx.EqualTolerance(DecimetersPerSecondSquaredInOneMeterPerSecondSquared, (double)decimeterpersecondsquaredQuantity.Value, DecimetersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.DecimeterPerSecondSquared, decimeterpersecondsquaredQuantity.Unit);
+
+            var footpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.FootPerSecondSquared);
+            AssertEx.EqualTolerance(FeetPerSecondSquaredInOneMeterPerSecondSquared, (double)footpersecondsquaredQuantity.Value, FeetPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.FootPerSecondSquared, footpersecondsquaredQuantity.Unit);
+
+            var inchpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.InchPerSecondSquared);
+            AssertEx.EqualTolerance(InchesPerSecondSquaredInOneMeterPerSecondSquared, (double)inchpersecondsquaredQuantity.Value, InchesPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.InchPerSecondSquared, inchpersecondsquaredQuantity.Unit);
+
+            var kilometerpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.KilometerPerSecondSquared);
+            AssertEx.EqualTolerance(KilometersPerSecondSquaredInOneMeterPerSecondSquared, (double)kilometerpersecondsquaredQuantity.Value, KilometersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.KilometerPerSecondSquared, kilometerpersecondsquaredQuantity.Unit);
+
+            var knotperhourQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.KnotPerHour);
+            AssertEx.EqualTolerance(KnotsPerHourInOneMeterPerSecondSquared, (double)knotperhourQuantity.Value, KnotsPerHourTolerance);
+            Assert.Equal(AccelerationUnit.KnotPerHour, knotperhourQuantity.Unit);
+
+            var knotperminuteQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.KnotPerMinute);
+            AssertEx.EqualTolerance(KnotsPerMinuteInOneMeterPerSecondSquared, (double)knotperminuteQuantity.Value, KnotsPerMinuteTolerance);
+            Assert.Equal(AccelerationUnit.KnotPerMinute, knotperminuteQuantity.Unit);
+
+            var knotpersecondQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.KnotPerSecond);
+            AssertEx.EqualTolerance(KnotsPerSecondInOneMeterPerSecondSquared, (double)knotpersecondQuantity.Value, KnotsPerSecondTolerance);
+            Assert.Equal(AccelerationUnit.KnotPerSecond, knotpersecondQuantity.Unit);
+
+            var meterpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.MeterPerSecondSquared);
+            AssertEx.EqualTolerance(MetersPerSecondSquaredInOneMeterPerSecondSquared, (double)meterpersecondsquaredQuantity.Value, MetersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.MeterPerSecondSquared, meterpersecondsquaredQuantity.Unit);
+
+            var micrometerpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.MicrometerPerSecondSquared);
+            AssertEx.EqualTolerance(MicrometersPerSecondSquaredInOneMeterPerSecondSquared, (double)micrometerpersecondsquaredQuantity.Value, MicrometersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.MicrometerPerSecondSquared, micrometerpersecondsquaredQuantity.Unit);
+
+            var millimeterpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.MillimeterPerSecondSquared);
+            AssertEx.EqualTolerance(MillimetersPerSecondSquaredInOneMeterPerSecondSquared, (double)millimeterpersecondsquaredQuantity.Value, MillimetersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.MillimeterPerSecondSquared, millimeterpersecondsquaredQuantity.Unit);
+
+            var nanometerpersecondsquaredQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.NanometerPerSecondSquared);
+            AssertEx.EqualTolerance(NanometersPerSecondSquaredInOneMeterPerSecondSquared, (double)nanometerpersecondsquaredQuantity.Value, NanometersPerSecondSquaredTolerance);
+            Assert.Equal(AccelerationUnit.NanometerPerSecondSquared, nanometerpersecondsquaredQuantity.Unit);
+
+            var standardgravityQuantity = meterpersecondsquared.ToUnit(AccelerationUnit.StandardGravity);
+            AssertEx.EqualTolerance(StandardGravityInOneMeterPerSecondSquared, (double)standardgravityQuantity.Value, StandardGravityTolerance);
+            Assert.Equal(AccelerationUnit.StandardGravity, standardgravityQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {

UnitsNet.Tests/GeneratedCode/AmountOfSubstanceTestsBase.g.cs

@@ -143,6 +143,68 @@ public void As()
             AssertEx.EqualTolerance(PoundMolesInOneMole, mole.As(AmountOfSubstanceUnit.PoundMole), PoundMolesTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var mole = AmountOfSubstance.FromMoles(1);
+
+            var centimoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Centimole);
+            AssertEx.EqualTolerance(CentimolesInOneMole, (double)centimoleQuantity.Value, CentimolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Centimole, centimoleQuantity.Unit);
+
+            var centipoundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.CentipoundMole);
+            AssertEx.EqualTolerance(CentipoundMolesInOneMole, (double)centipoundmoleQuantity.Value, CentipoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.CentipoundMole, centipoundmoleQuantity.Unit);
+
+            var decimoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Decimole);
+            AssertEx.EqualTolerance(DecimolesInOneMole, (double)decimoleQuantity.Value, DecimolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Decimole, decimoleQuantity.Unit);
+
+            var decipoundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.DecipoundMole);
+            AssertEx.EqualTolerance(DecipoundMolesInOneMole, (double)decipoundmoleQuantity.Value, DecipoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.DecipoundMole, decipoundmoleQuantity.Unit);
+
+            var kilomoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Kilomole);
+            AssertEx.EqualTolerance(KilomolesInOneMole, (double)kilomoleQuantity.Value, KilomolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Kilomole, kilomoleQuantity.Unit);
+
+            var kilopoundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.KilopoundMole);
+            AssertEx.EqualTolerance(KilopoundMolesInOneMole, (double)kilopoundmoleQuantity.Value, KilopoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.KilopoundMole, kilopoundmoleQuantity.Unit);
+
+            var micromoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Micromole);
+            AssertEx.EqualTolerance(MicromolesInOneMole, (double)micromoleQuantity.Value, MicromolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Micromole, micromoleQuantity.Unit);
+
+            var micropoundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.MicropoundMole);
+            AssertEx.EqualTolerance(MicropoundMolesInOneMole, (double)micropoundmoleQuantity.Value, MicropoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.MicropoundMole, micropoundmoleQuantity.Unit);
+
+            var millimoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Millimole);
+            AssertEx.EqualTolerance(MillimolesInOneMole, (double)millimoleQuantity.Value, MillimolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Millimole, millimoleQuantity.Unit);
+
+            var millipoundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.MillipoundMole);
+            AssertEx.EqualTolerance(MillipoundMolesInOneMole, (double)millipoundmoleQuantity.Value, MillipoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.MillipoundMole, millipoundmoleQuantity.Unit);
+
+            var moleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Mole);
+            AssertEx.EqualTolerance(MolesInOneMole, (double)moleQuantity.Value, MolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Mole, moleQuantity.Unit);
+
+            var nanomoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.Nanomole);
+            AssertEx.EqualTolerance(NanomolesInOneMole, (double)nanomoleQuantity.Value, NanomolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.Nanomole, nanomoleQuantity.Unit);
+
+            var nanopoundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.NanopoundMole);
+            AssertEx.EqualTolerance(NanopoundMolesInOneMole, (double)nanopoundmoleQuantity.Value, NanopoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.NanopoundMole, nanopoundmoleQuantity.Unit);
+
+            var poundmoleQuantity = mole.ToUnit(AmountOfSubstanceUnit.PoundMole);
+            AssertEx.EqualTolerance(PoundMolesInOneMole, (double)poundmoleQuantity.Value, PoundMolesTolerance);
+            Assert.Equal(AmountOfSubstanceUnit.PoundMole, poundmoleQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {

UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs

@@ -93,6 +93,28 @@ public void As()
             AssertEx.EqualTolerance(DecibelVoltsInOneDecibelVolt, decibelvolt.As(AmplitudeRatioUnit.DecibelVolt), DecibelVoltsTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var decibelvolt = AmplitudeRatio.FromDecibelVolts(1);
+
+            var decibelmicrovoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelMicrovolt);
+            AssertEx.EqualTolerance(DecibelMicrovoltsInOneDecibelVolt, (double)decibelmicrovoltQuantity.Value, DecibelMicrovoltsTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelMicrovolt, decibelmicrovoltQuantity.Unit);
+
+            var decibelmillivoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelMillivolt);
+            AssertEx.EqualTolerance(DecibelMillivoltsInOneDecibelVolt, (double)decibelmillivoltQuantity.Value, DecibelMillivoltsTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelMillivolt, decibelmillivoltQuantity.Unit);
+
+            var decibelunloadedQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelUnloaded);
+            AssertEx.EqualTolerance(DecibelsUnloadedInOneDecibelVolt, (double)decibelunloadedQuantity.Value, DecibelsUnloadedTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelUnloaded, decibelunloadedQuantity.Unit);
+
+            var decibelvoltQuantity = decibelvolt.ToUnit(AmplitudeRatioUnit.DecibelVolt);
+            AssertEx.EqualTolerance(DecibelVoltsInOneDecibelVolt, (double)decibelvoltQuantity.Value, DecibelVoltsTolerance);
+            Assert.Equal(AmplitudeRatioUnit.DecibelVolt, decibelvoltQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {

UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs

@@ -143,6 +143,68 @@ public void As()
             AssertEx.EqualTolerance(RevolutionsInOneDegree, degree.As(AngleUnit.Revolution), RevolutionsTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var degree = Angle.FromDegrees(1);
+
+            var arcminuteQuantity = degree.ToUnit(AngleUnit.Arcminute);
+            AssertEx.EqualTolerance(ArcminutesInOneDegree, (double)arcminuteQuantity.Value, ArcminutesTolerance);
+            Assert.Equal(AngleUnit.Arcminute, arcminuteQuantity.Unit);
+
+            var arcsecondQuantity = degree.ToUnit(AngleUnit.Arcsecond);
+            AssertEx.EqualTolerance(ArcsecondsInOneDegree, (double)arcsecondQuantity.Value, ArcsecondsTolerance);
+            Assert.Equal(AngleUnit.Arcsecond, arcsecondQuantity.Unit);
+
+            var centiradianQuantity = degree.ToUnit(AngleUnit.Centiradian);
+            AssertEx.EqualTolerance(CentiradiansInOneDegree, (double)centiradianQuantity.Value, CentiradiansTolerance);
+            Assert.Equal(AngleUnit.Centiradian, centiradianQuantity.Unit);
+
+            var deciradianQuantity = degree.ToUnit(AngleUnit.Deciradian);
+            AssertEx.EqualTolerance(DeciradiansInOneDegree, (double)deciradianQuantity.Value, DeciradiansTolerance);
+            Assert.Equal(AngleUnit.Deciradian, deciradianQuantity.Unit);
+
+            var degreeQuantity = degree.ToUnit(AngleUnit.Degree);
+            AssertEx.EqualTolerance(DegreesInOneDegree, (double)degreeQuantity.Value, DegreesTolerance);
+            Assert.Equal(AngleUnit.Degree, degreeQuantity.Unit);
+
+            var gradianQuantity = degree.ToUnit(AngleUnit.Gradian);
+            AssertEx.EqualTolerance(GradiansInOneDegree, (double)gradianQuantity.Value, GradiansTolerance);
+            Assert.Equal(AngleUnit.Gradian, gradianQuantity.Unit);
+
+            var microdegreeQuantity = degree.ToUnit(AngleUnit.Microdegree);
+            AssertEx.EqualTolerance(MicrodegreesInOneDegree, (double)microdegreeQuantity.Value, MicrodegreesTolerance);
+            Assert.Equal(AngleUnit.Microdegree, microdegreeQuantity.Unit);
+
+            var microradianQuantity = degree.ToUnit(AngleUnit.Microradian);
+            AssertEx.EqualTolerance(MicroradiansInOneDegree, (double)microradianQuantity.Value, MicroradiansTolerance);
+            Assert.Equal(AngleUnit.Microradian, microradianQuantity.Unit);
+
+            var millidegreeQuantity = degree.ToUnit(AngleUnit.Millidegree);
+            AssertEx.EqualTolerance(MillidegreesInOneDegree, (double)millidegreeQuantity.Value, MillidegreesTolerance);
+            Assert.Equal(AngleUnit.Millidegree, millidegreeQuantity.Unit);
+
+            var milliradianQuantity = degree.ToUnit(AngleUnit.Milliradian);
+            AssertEx.EqualTolerance(MilliradiansInOneDegree, (double)milliradianQuantity.Value, MilliradiansTolerance);
+            Assert.Equal(AngleUnit.Milliradian, milliradianQuantity.Unit);
+
+            var nanodegreeQuantity = degree.ToUnit(AngleUnit.Nanodegree);
+            AssertEx.EqualTolerance(NanodegreesInOneDegree, (double)nanodegreeQuantity.Value, NanodegreesTolerance);
+            Assert.Equal(AngleUnit.Nanodegree, nanodegreeQuantity.Unit);
+
+            var nanoradianQuantity = degree.ToUnit(AngleUnit.Nanoradian);
+            AssertEx.EqualTolerance(NanoradiansInOneDegree, (double)nanoradianQuantity.Value, NanoradiansTolerance);
+            Assert.Equal(AngleUnit.Nanoradian, nanoradianQuantity.Unit);
+
+            var radianQuantity = degree.ToUnit(AngleUnit.Radian);
+            AssertEx.EqualTolerance(RadiansInOneDegree, (double)radianQuantity.Value, RadiansTolerance);
+            Assert.Equal(AngleUnit.Radian, radianQuantity.Unit);
+
+            var revolutionQuantity = degree.ToUnit(AngleUnit.Revolution);
+            AssertEx.EqualTolerance(RevolutionsInOneDegree, (double)revolutionQuantity.Value, RevolutionsTolerance);
+            Assert.Equal(AngleUnit.Revolution, revolutionQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {

UnitsNet.Tests/GeneratedCode/ApparentEnergyTestsBase.g.cs

@@ -88,6 +88,24 @@ public void As()
             AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, voltamperehour.As(ApparentEnergyUnit.VoltampereHour), VoltampereHoursTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var voltamperehour = ApparentEnergy.FromVoltampereHours(1);
+
+            var kilovoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.KilovoltampereHour);
+            AssertEx.EqualTolerance(KilovoltampereHoursInOneVoltampereHour, (double)kilovoltamperehourQuantity.Value, KilovoltampereHoursTolerance);
+            Assert.Equal(ApparentEnergyUnit.KilovoltampereHour, kilovoltamperehourQuantity.Unit);
+
+            var megavoltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.MegavoltampereHour);
+            AssertEx.EqualTolerance(MegavoltampereHoursInOneVoltampereHour, (double)megavoltamperehourQuantity.Value, MegavoltampereHoursTolerance);
+            Assert.Equal(ApparentEnergyUnit.MegavoltampereHour, megavoltamperehourQuantity.Unit);
+
+            var voltamperehourQuantity = voltamperehour.ToUnit(ApparentEnergyUnit.VoltampereHour);
+            AssertEx.EqualTolerance(VoltampereHoursInOneVoltampereHour, (double)voltamperehourQuantity.Value, VoltampereHoursTolerance);
+            Assert.Equal(ApparentEnergyUnit.VoltampereHour, voltamperehourQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {

UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs

@@ -93,6 +93,28 @@ public void As()
             AssertEx.EqualTolerance(VoltamperesInOneVoltampere, voltampere.As(ApparentPowerUnit.Voltampere), VoltamperesTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var voltampere = ApparentPower.FromVoltamperes(1);
+
+            var gigavoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Gigavoltampere);
+            AssertEx.EqualTolerance(GigavoltamperesInOneVoltampere, (double)gigavoltampereQuantity.Value, GigavoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Gigavoltampere, gigavoltampereQuantity.Unit);
+
+            var kilovoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Kilovoltampere);
+            AssertEx.EqualTolerance(KilovoltamperesInOneVoltampere, (double)kilovoltampereQuantity.Value, KilovoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Kilovoltampere, kilovoltampereQuantity.Unit);
+
+            var megavoltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Megavoltampere);
+            AssertEx.EqualTolerance(MegavoltamperesInOneVoltampere, (double)megavoltampereQuantity.Value, MegavoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Megavoltampere, megavoltampereQuantity.Unit);
+
+            var voltampereQuantity = voltampere.ToUnit(ApparentPowerUnit.Voltampere);
+            AssertEx.EqualTolerance(VoltamperesInOneVoltampere, (double)voltampereQuantity.Value, VoltamperesTolerance);
+            Assert.Equal(ApparentPowerUnit.Voltampere, voltampereQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {

UnitsNet.Tests/GeneratedCode/AreaDensityTestsBase.g.cs

@@ -78,6 +78,16 @@ public void As()
             AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, kilogrampersquaremeter.As(AreaDensityUnit.KilogramPerSquareMeter), KilogramsPerSquareMeterTolerance);
         }
 
+        [Fact]
+        public void ToUnit()
+        {
+            var kilogrampersquaremeter = AreaDensity.FromKilogramsPerSquareMeter(1);
+
+            var kilogrampersquaremeterQuantity = kilogrampersquaremeter.ToUnit(AreaDensityUnit.KilogramPerSquareMeter);
+            AssertEx.EqualTolerance(KilogramsPerSquareMeterInOneKilogramPerSquareMeter, (double)kilogrampersquaremeterQuantity.Value, KilogramsPerSquareMeterTolerance);
+            Assert.Equal(AreaDensityUnit.KilogramPerSquareMeter, kilogrampersquaremeterQuantity.Unit);
+        }
+
         [Fact]
         public void ConversionRoundTrip()
         {