From 054bd983ce5013b06ccad2a44052ff32cf7e846a Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Sun, 7 Feb 2016 14:30:05 +0100 Subject: [PATCH 1/8] Added ToStringDefaultUnit to enable custom units for ToString(). --- .../GeneratedCode/AccelerationTestsBase.g.cs | 94 ++++ .../AmplitudeRatioTestsBase.g.cs | 46 ++ .../GeneratedCode/AngleTestsBase.g.cs | 130 ++++++ .../GeneratedCode/AreaTestsBase.g.cs | 130 ++++++ .../GeneratedCode/DensityTestsBase.g.cs | 130 ++++++ .../GeneratedCode/DurationTestsBase.g.cs | 130 ++++++ .../ElectricCurrentTestsBase.g.cs | 82 ++++ .../ElectricPotentialTestsBase.g.cs | 70 +++ .../ElectricResistanceTestsBase.g.cs | 46 ++ .../GeneratedCode/EnergyTestsBase.g.cs | 166 +++++++ .../GeneratedCode/FlowTestsBase.g.cs | 82 ++++ .../ForceChangeRateTestsBase.g.cs | 22 + .../GeneratedCode/ForceTestsBase.g.cs | 106 +++++ .../GeneratedCode/FrequencyTestsBase.g.cs | 106 +++++ .../GeneratedCode/InformationTestsBase.g.cs | 322 ++++++++++++++ .../KinematicViscosityTestsBase.g.cs | 106 +++++ .../GeneratedCode/LengthTestsBase.g.cs | 178 ++++++++ .../GeneratedCode/LevelTestsBase.g.cs | 34 ++ .../GeneratedCode/MassFlowTestsBase.g.cs | 130 ++++++ .../GeneratedCode/MassTestsBase.g.cs | 214 +++++++++ .../GeneratedCode/PowerRatioTestsBase.g.cs | 34 ++ .../GeneratedCode/PowerTestsBase.g.cs | 202 +++++++++ .../PressureChangeRateTestsBase.g.cs | 58 +++ .../GeneratedCode/PressureTestsBase.g.cs | 406 ++++++++++++++++++ .../GeneratedCode/RatioTestsBase.g.cs | 82 ++++ .../RotationalSpeedTestsBase.g.cs | 106 +++++ .../SpecificEnergyTestsBase.g.cs | 106 +++++ .../SpecificWeightTestsBase.g.cs | 202 +++++++++ .../GeneratedCode/SpeedTestsBase.g.cs | 154 +++++++ .../TemperatureChangeRateTestsBase.g.cs | 118 +++++ .../GeneratedCode/TemperatureTestsBase.g.cs | 106 +++++ .../GeneratedCode/TorqueTestsBase.g.cs | 202 +++++++++ .../GeneratedCode/VitaminATestsBase.g.cs | 22 + .../GeneratedCode/VolumeTestsBase.g.cs | 286 ++++++++++++ .../UnitClasses/Acceleration.g.cs | 7 +- .../UnitClasses/AmplitudeRatio.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 7 +- .../GeneratedCode/UnitClasses/Density.g.cs | 7 +- .../GeneratedCode/UnitClasses/Duration.g.cs | 7 +- .../UnitClasses/ElectricCurrent.g.cs | 7 +- .../UnitClasses/ElectricPotential.g.cs | 7 +- .../UnitClasses/ElectricResistance.g.cs | 7 +- .../GeneratedCode/UnitClasses/Energy.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 7 +- .../UnitClasses/ForceChangeRate.g.cs | 7 +- .../GeneratedCode/UnitClasses/Frequency.g.cs | 7 +- .../UnitClasses/Information.g.cs | 7 +- .../UnitClasses/KinematicViscosity.g.cs | 7 +- .../GeneratedCode/UnitClasses/Length.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 7 +- .../GeneratedCode/UnitClasses/MassFlow.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 7 +- .../GeneratedCode/UnitClasses/PowerRatio.g.cs | 7 +- .../GeneratedCode/UnitClasses/Pressure.g.cs | 7 +- .../UnitClasses/PressureChangeRate.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 7 +- .../UnitClasses/RotationalSpeed.g.cs | 7 +- .../UnitClasses/SpecificEnergy.g.cs | 7 +- .../UnitClasses/SpecificWeight.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 7 +- .../UnitClasses/Temperature.g.cs | 7 +- .../UnitClasses/TemperatureChangeRate.g.cs | 7 +- .../GeneratedCode/UnitClasses/Torque.g.cs | 7 +- .../GeneratedCode/UnitClasses/VitaminA.g.cs | 7 +- .../GeneratedCode/UnitClasses/Volume.g.cs | 7 +- .../Include-GenerateUnitClassSourceCode.ps1 | 7 +- ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 24 ++ 70 files changed, 4642 insertions(+), 35 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index e55a0044a4..dc355038bf 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -199,5 +199,99 @@ public void EqualsReturnsFalseOnNull() Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); Assert.IsFalse(meterpersecondsquared.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); + string meterpersecondsquaredString = meterpersecondsquared.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 786dcee38d..c4f7fe5f29 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -179,5 +179,51 @@ public void EqualsReturnsFalseOnNull() AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); Assert.IsFalse(decibelvolt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); + string decibelvoltString = decibelvolt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelMicrovoltAsDefualtUnit() + { + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelMillivoltAsDefualtUnit() + { + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelVoltAsDefualtUnit() + { + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index d330008fcc..da49a60e5b 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Angle degree = Angle.FromDegrees(1); Assert.IsFalse(degree.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle degree = Angle.FromDegrees(1); + string degreeString = degree.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithArcminuteAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcminute; + Angle value = Angle.From(1, AngleUnit.Arcminute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithArcsecondAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; + Angle value = Angle.From(1, AngleUnit.Arcsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentiradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Centiradian; + Angle value = Angle.From(1, AngleUnit.Centiradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDeciradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Deciradian; + Angle value = Angle.From(1, AngleUnit.Deciradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle value = Angle.From(1, AngleUnit.Degree); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Gradian; + Angle value = Angle.From(1, AngleUnit.Gradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Microradian; + Angle value = Angle.From(1, AngleUnit.Microradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Milliradian; + Angle value = Angle.From(1, AngleUnit.Milliradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanoradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; + Angle value = Angle.From(1, AngleUnit.Nanoradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRadianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Radian; + Angle value = Angle.From(1, AngleUnit.Radian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index ada71764bf..9215120cd9 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Area squaremeter = Area.FromSquareMeters(1); Assert.IsFalse(squaremeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area squaremeter = Area.FromSquareMeters(1); + string squaremeterString = squaremeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareCentimeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; + Area value = Area.From(1, AreaUnit.SquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareDecimeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; + Area value = Area.From(1, AreaUnit.SquareDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareFootAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareFoot; + Area value = Area.From(1, AreaUnit.SquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareInchAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareInch; + Area value = Area.From(1, AreaUnit.SquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareKilometerAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; + Area value = Area.From(1, AreaUnit.SquareKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area value = Area.From(1, AreaUnit.SquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMicrometerAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; + Area value = Area.From(1, AreaUnit.SquareMicrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMileAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMile; + Area value = Area.From(1, AreaUnit.SquareMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMillimeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; + Area value = Area.From(1, AreaUnit.SquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareYardAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareYard; + Area value = Area.From(1, AreaUnit.SquareYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 87a39ad9c6..68b54cb471 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); + string kilogrampercubicmeterString = kilogrampercubicmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicCentimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMillimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicFootAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicInchAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicFootAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicInchAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; + Density value = Density.From(1, DensityUnit.PoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicCentimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMillimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 3b134a6b08..b148cc0940 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Duration second = Duration.FromSeconds(1); Assert.IsFalse(second.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration second = Duration.FromSeconds(1); + string secondString = second.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDayAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Day; + Duration value = Duration.From(1, DurationUnit.Day); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHourAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Hour; + Duration value = Duration.From(1, DurationUnit.Hour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrosecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Microsecond; + Duration value = Duration.From(1, DurationUnit.Microsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillisecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Millisecond; + Duration value = Duration.From(1, DurationUnit.Millisecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMinuteAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Minute; + Duration value = Duration.From(1, DurationUnit.Minute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMonthAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Month; + Duration value = Duration.From(1, DurationUnit.Month); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanosecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; + Duration value = Duration.From(1, DurationUnit.Nanosecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration value = Duration.From(1, DurationUnit.Second); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWeekAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Week; + Duration value = Duration.From(1, DurationUnit.Week); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithYearAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Year; + Duration value = Duration.From(1, DurationUnit.Year); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 52f03bd23f..264449f25d 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -193,5 +193,87 @@ public void EqualsReturnsFalseOnNull() ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); Assert.IsFalse(ampere.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); + string ampereString = ampere.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithAmpereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKiloampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegaampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanoampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 319f56cacc..c563008ac1 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -187,5 +187,75 @@ public void EqualsReturnsFalseOnNull() ElectricPotential volt = ElectricPotential.FromVolts(1); Assert.IsFalse(volt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential volt = ElectricPotential.FromVolts(1); + string voltString = volt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilovoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegavoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrovoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillivoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithVoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index a23d9028c1..8b926774db 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -175,5 +175,51 @@ public void EqualsReturnsFalseOnNull() ElectricResistance ohm = ElectricResistance.FromOhms(1); Assert.IsFalse(ohm.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance ohm = ElectricResistance.FromOhms(1); + string ohmString = ohm.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKiloohmAsDefualtUnit() + { + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegaohmAsDefualtUnit() + { + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithOhmAsDefualtUnit() + { + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index e23f86a521..baff65f537 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -235,5 +235,171 @@ public void EqualsReturnsFalseOnNull() Energy joule = Energy.FromJoules(1); Assert.IsFalse(joule.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy joule = Energy.FromJoules(1); + string jouleString = joule.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBritishThermalUnitAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; + Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCalorieAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Calorie; + Energy value = Energy.From(1, EnergyUnit.Calorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithElectronVoltAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; + Energy value = Energy.From(1, EnergyUnit.ElectronVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithErgAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Erg; + Energy value = Energy.From(1, EnergyUnit.Erg); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFootPoundAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.FootPound; + Energy value = Energy.From(1, EnergyUnit.FootPound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigawattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; + Energy value = Energy.From(1, EnergyUnit.GigawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithJouleAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy value = Energy.From(1, EnergyUnit.Joule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilocalorieAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; + Energy value = Energy.From(1, EnergyUnit.Kilocalorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilojouleAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; + Energy value = Energy.From(1, EnergyUnit.Kilojoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; + Energy value = Energy.From(1, EnergyUnit.KilowattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegajouleAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; + Energy value = Energy.From(1, EnergyUnit.Megajoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; + Energy value = Energy.From(1, EnergyUnit.MegawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.WattHour; + Energy value = Energy.From(1, EnergyUnit.WattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 8287346863..402e7fa9b0 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -193,5 +193,87 @@ public void EqualsReturnsFalseOnNull() Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); Assert.IsFalse(cubicmeterpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); + string cubicmeterpersecondString = cubicmeterpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicFootPerSecondAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerHourAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerSecondAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithLitersPerMinuteAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; + Flow value = Flow.From(1, FlowUnit.LitersPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillionUsGallonsPerDayAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; + Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsGallonsPerMinuteAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; + Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index c521f78f26..75abf80e3a 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -163,5 +163,27 @@ public void EqualsReturnsFalseOnNull() ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); Assert.IsFalse(newtonpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); + string newtonpersecondString = newtonpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSecondAsDefualtUnit() + { + ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); + ForceChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 94a60dbe77..3eba27b8b5 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() Force newton = Force.FromNewtons(1); Assert.IsFalse(newton.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Force.ToStringDefaultUnit = ForceUnit.Newton; + Force newton = Force.FromNewtons(1); + string newtonString = newton.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDynAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Dyn; + Force value = Force.From(1, ForceUnit.Dyn); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KilogramForce; + Force value = Force.From(1, ForceUnit.KilogramForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Kilonewton; + Force value = Force.From(1, ForceUnit.Kilonewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKiloPondAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KiloPond; + Force value = Force.From(1, ForceUnit.KiloPond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Newton; + Force value = Force.From(1, ForceUnit.Newton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundalAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Poundal; + Force value = Force.From(1, ForceUnit.Poundal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForceAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.PoundForce; + Force value = Force.From(1, ForceUnit.PoundForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.TonneForce; + Force value = Force.From(1, ForceUnit.TonneForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index c01b961863..b1e65ce6d0 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() Frequency hertz = Frequency.FromHertz(1); Assert.IsFalse(hertz.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency hertz = Frequency.FromHertz(1); + string hertzString = hertz.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCyclePerHourAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCyclePerMinuteAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigahertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency value = Frequency.From(1, FrequencyUnit.Hertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilohertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; + Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegahertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; + Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerahertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index f740691f61..55a94856e8 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -313,5 +313,327 @@ public void EqualsReturnsFalseOnNull() Information bit = Information.FromBits(1); Assert.IsFalse(bit.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Information.ToStringDefaultUnit = InformationUnit.Bit; + Information bit = Information.FromBits(1); + string bitString = bit.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Bit; + Information value = Information.From(1, InformationUnit.Bit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithByteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Byte; + Information value = Information.From(1, InformationUnit.Byte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabit; + Information value = Information.From(1, InformationUnit.Exabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabyte; + Information value = Information.From(1, InformationUnit.Exabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExbibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibit; + Information value = Information.From(1, InformationUnit.Exbibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExbibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibyte; + Information value = Information.From(1, InformationUnit.Exbibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGibibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibit; + Information value = Information.From(1, InformationUnit.Gibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGibibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibyte; + Information value = Information.From(1, InformationUnit.Gibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabit; + Information value = Information.From(1, InformationUnit.Gigabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabyte; + Information value = Information.From(1, InformationUnit.Gigabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKibibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibit; + Information value = Information.From(1, InformationUnit.Kibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKibibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibyte; + Information value = Information.From(1, InformationUnit.Kibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilobitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobit; + Information value = Information.From(1, InformationUnit.Kilobit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilobyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobyte; + Information value = Information.From(1, InformationUnit.Kilobyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMebibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibit; + Information value = Information.From(1, InformationUnit.Mebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMebibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibyte; + Information value = Information.From(1, InformationUnit.Mebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabit; + Information value = Information.From(1, InformationUnit.Megabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabyte; + Information value = Information.From(1, InformationUnit.Megabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPebibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibit; + Information value = Information.From(1, InformationUnit.Pebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPebibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibyte; + Information value = Information.From(1, InformationUnit.Pebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPetabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabit; + Information value = Information.From(1, InformationUnit.Petabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPetabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabyte; + Information value = Information.From(1, InformationUnit.Petabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTebibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibit; + Information value = Information.From(1, InformationUnit.Tebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTebibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibyte; + Information value = Information.From(1, InformationUnit.Tebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabit; + Information value = Information.From(1, InformationUnit.Terabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabyte; + Information value = Information.From(1, InformationUnit.Terabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index b22eb12e06..6bc405bf99 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); Assert.IsFalse(squaremeterpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); + string squaremeterpersecondString = squaremeterpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentistokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecistokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilostokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrostokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillistokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanostokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterPerSecondAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithStokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index a247b5798b..306d567680 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -241,5 +241,183 @@ public void EqualsReturnsFalseOnNull() Length meter = Length.FromMeters(1); Assert.IsFalse(meter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length meter = Length.FromMeters(1); + string meterString = meter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Centimeter; + Length value = Length.From(1, LengthUnit.Centimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Decimeter; + Length value = Length.From(1, LengthUnit.Decimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFootAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Foot; + Length value = Length.From(1, LengthUnit.Foot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithInchAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Inch; + Length value = Length.From(1, LengthUnit.Inch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Kilometer; + Length value = Length.From(1, LengthUnit.Kilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length value = Length.From(1, LengthUnit.Meter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroinchAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Microinch; + Length value = Length.From(1, LengthUnit.Microinch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrometerAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Micrometer; + Length value = Length.From(1, LengthUnit.Micrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mil; + Length value = Length.From(1, LengthUnit.Mil); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMileAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mile; + Length value = Length.From(1, LengthUnit.Mile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Millimeter; + Length value = Length.From(1, LengthUnit.Millimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanometerAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Nanometer; + Length value = Length.From(1, LengthUnit.Nanometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNauticalMileAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.NauticalMile; + Length value = Length.From(1, LengthUnit.NauticalMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithYardAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Yard; + Length value = Length.From(1, LengthUnit.Yard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index dac295d95d..3d77584013 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -173,5 +173,39 @@ public void EqualsReturnsFalseOnNull() Level decibel = Level.FromDecibels(1); Assert.IsFalse(decibel.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level decibel = Level.FromDecibels(1); + string decibelString = decibel.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelAsDefualtUnit() + { + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level value = Level.From(1, LevelUnit.Decibel); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNeperAsDefualtUnit() + { + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Neper; + Level value = Level.From(1, LevelUnit.Neper); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 583c7cf5dc..3f3d327b24 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); Assert.IsFalse(grampersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); + string grampersecondString = grampersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentigramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecagramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecigramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilligramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerDayAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; + MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 7775d245e0..417a214677 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -259,5 +259,219 @@ public void EqualsReturnsFalseOnNull() Mass kilogram = Mass.FromKilograms(1); Assert.IsFalse(kilogram.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass kilogram = Mass.FromKilograms(1); + string kilogramString = kilogram.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentigramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Centigram; + Mass value = Mass.From(1, MassUnit.Centigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecagramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decagram; + Mass value = Mass.From(1, MassUnit.Decagram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecigramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decigram; + Mass value = Mass.From(1, MassUnit.Decigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Gram; + Mass value = Mass.From(1, MassUnit.Gram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Hectogram; + Mass value = Mass.From(1, MassUnit.Hectogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass value = Mass.From(1, MassUnit.Kilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilotonneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilotonne; + Mass value = Mass.From(1, MassUnit.Kilotonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithLongTonAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.LongTon; + Mass value = Mass.From(1, MassUnit.LongTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegatonneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Megatonne; + Mass value = Mass.From(1, MassUnit.Megatonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Microgram; + Mass value = Mass.From(1, MassUnit.Microgram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilligramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Milligram; + Mass value = Mass.From(1, MassUnit.Milligram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Nanogram; + Mass value = Mass.From(1, MassUnit.Nanogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithOunceAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Ounce; + Mass value = Mass.From(1, MassUnit.Ounce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Pound; + Mass value = Mass.From(1, MassUnit.Pound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithShortTonAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.ShortTon; + Mass value = Mass.From(1, MassUnit.ShortTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithStoneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Stone; + Mass value = Mass.From(1, MassUnit.Stone); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Tonne; + Mass value = Mass.From(1, MassUnit.Tonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index 4c505d6c08..afc9c13bc4 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -173,5 +173,39 @@ public void EqualsReturnsFalseOnNull() PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); Assert.IsFalse(decibelwatt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); + string decibelwattString = decibelwatt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelMilliwattAsDefualtUnit() + { + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelWattAsDefualtUnit() + { + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 221ceaf04f..a6323103b1 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -253,5 +253,207 @@ public void EqualsReturnsFalseOnNull() Power watt = Power.FromWatts(1); Assert.IsFalse(watt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Power.ToStringDefaultUnit = PowerUnit.Watt; + Power watt = Power.FromWatts(1); + string wattString = watt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBoilerHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; + Power value = Power.From(1, PowerUnit.BoilerHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithElectricalHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; + Power value = Power.From(1, PowerUnit.ElectricalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFemtowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Femtowatt; + Power value = Power.From(1, PowerUnit.Femtowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Gigawatt; + Power value = Power.From(1, PowerUnit.Gigawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHydraulicHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; + Power value = Power.From(1, PowerUnit.HydraulicHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Kilowatt; + Power value = Power.From(1, PowerUnit.Kilowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMechanicalHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; + Power value = Power.From(1, PowerUnit.MechanicalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Megawatt; + Power value = Power.From(1, PowerUnit.Megawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMetricHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; + Power value = Power.From(1, PowerUnit.MetricHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Microwatt; + Power value = Power.From(1, PowerUnit.Microwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliwattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Milliwatt; + Power value = Power.From(1, PowerUnit.Milliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Nanowatt; + Power value = Power.From(1, PowerUnit.Nanowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPetawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Petawatt; + Power value = Power.From(1, PowerUnit.Petawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPicowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Picowatt; + Power value = Power.From(1, PowerUnit.Picowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Terawatt; + Power value = Power.From(1, PowerUnit.Terawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Watt; + Power value = Power.From(1, PowerUnit.Watt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index f9200bb56a..317f0af622 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -181,5 +181,63 @@ public void EqualsReturnsFalseOnNull() PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); Assert.IsFalse(pascalpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); + string pascalpersecondString = pascalpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithAtmospherePerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopascalPerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegapascalPerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPascalPerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index cf3b489a71..93222d94bd 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -355,5 +355,411 @@ public void EqualsReturnsFalseOnNull() Pressure pascal = Pressure.FromPascals(1); Assert.IsFalse(pascal.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure pascal = Pressure.FromPascals(1); + string pascalString = pascal.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithAtmosphereAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; + Pressure value = Pressure.From(1, PressureUnit.Atmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Bar; + Pressure value = Pressure.From(1, PressureUnit.Bar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentibarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Centibar; + Pressure value = Pressure.From(1, PressureUnit.Centibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecapascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; + Pressure value = Pressure.From(1, PressureUnit.Decapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decibar; + Pressure value = Pressure.From(1, PressureUnit.Decibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigapascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; + Pressure value = Pressure.From(1, PressureUnit.Gigapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectopascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; + Pressure value = Pressure.From(1, PressureUnit.Hectopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilobarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; + Pressure value = Pressure.From(1, PressureUnit.Kilobar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; + Pressure value = Pressure.From(1, PressureUnit.Kilopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareFootAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareInchAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegabarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megabar; + Pressure value = Pressure.From(1, PressureUnit.Megabar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegapascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; + Pressure value = Pressure.From(1, PressureUnit.Megapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicropascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; + Pressure value = Pressure.From(1, PressureUnit.Micropascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillibarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Millibar; + Pressure value = Pressure.From(1, PressureUnit.Millibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure value = Pressure.From(1, PressureUnit.Pascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareFootAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareInchAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPsiAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Psi; + Pressure value = Pressure.From(1, PressureUnit.Psi); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTechnicalAtmosphereAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; + Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTorrAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Torr; + Pressure value = Pressure.From(1, PressureUnit.Torr); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 212682834e..27c96ca539 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -193,5 +193,87 @@ public void EqualsReturnsFalseOnNull() Ratio decimalfraction = Ratio.FromDecimalFractions(1); Assert.IsFalse(decimalfraction.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio decimalfraction = Ratio.FromDecimalFractions(1); + string decimalfractionString = decimalfraction.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimalFractionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerBillionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerMillionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerThousandAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; + Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerTrillionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPercentAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.Percent; + Ratio value = Ratio.From(1, RatioUnit.Percent); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 552412d898..0794eaa618 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.IsFalse(radianpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + string radianpersecondString = radianpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentiradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDeciradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanoradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerMinuteAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 7a5ba37b27..0f81a0d72c 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); Assert.IsFalse(jouleperkilogram.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); + string jouleperkilogramString = jouleperkilogram.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCaloriePerGramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithJoulePerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilocaloriePerGramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilojoulePerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourPerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegajoulePerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourPerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWattHourPerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 52535a75d2..4f63508749 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -253,5 +253,207 @@ public void EqualsReturnsFalseOnNull() SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); Assert.IsFalse(newtonpercubicmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); + string newtonpercubicmeterString = newtonpercubicmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicFootAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicInchAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicFootAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicInchAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index c87c6c8bb8..77ff0ec620 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -229,5 +229,159 @@ public void EqualsReturnsFalseOnNull() Speed meterpersecond = Speed.FromMetersPerSecond(1); Assert.IsFalse(meterpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed meterpersecond = Speed.FromMetersPerSecond(1); + string meterpersecondString = meterpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFootPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; + Speed value = Speed.From(1, SpeedUnit.FootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerHourAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; + Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKnotAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.Knot; + Speed value = Speed.From(1, SpeedUnit.Knot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterPerHourAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; + Speed value = Speed.From(1, SpeedUnit.MeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilePerHourAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; + Speed value = Speed.From(1, SpeedUnit.MilePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index e5b1a8daf6..c826d257db 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -211,5 +211,123 @@ public void EqualsReturnsFalseOnNull() TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); + string degreecelsiuspersecondString = degreecelsiuspersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentidegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecadegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecidegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillidegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 874ea01916..2ef8499deb 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() Temperature kelvin = Temperature.FromKelvins(1); Assert.IsFalse(kelvin.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature kelvin = Temperature.FromKelvins(1); + string kelvinString = kelvin.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeDelisleAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeFahrenheitAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeNewtonAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeRankineAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeReaumurAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeRoemerAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKelvinAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 8b7469ba75..e4dfc47607 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -253,5 +253,207 @@ public void EqualsReturnsFalseOnNull() Torque newtonmeter = Torque.FromNewtonMeters(1); Assert.IsFalse(newtonmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque newtonmeter = Torque.FromNewtonMeters(1); + string newtonmeterString = newtonmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceFootAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceInchAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForceFootAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForceInchAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; + Torque value = Torque.From(1, TorqueUnit.PoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index f6c0f92814..bb33c97f20 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -163,5 +163,27 @@ public void EqualsReturnsFalseOnNull() VitaminA internationalunit = VitaminA.FromInternationalUnits(1); Assert.IsFalse(internationalunit.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA internationalunit = VitaminA.FromInternationalUnits(1); + string internationalunitString = internationalunit.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithInternationalUnitAsDefualtUnit() + { + VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); + VitaminA.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 97a0f13a8b..a51007a15f 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -295,5 +295,291 @@ public void EqualsReturnsFalseOnNull() Volume cubicmeter = Volume.FromCubicMeters(1); Assert.IsFalse(cubicmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume cubicmeter = Volume.FromCubicMeters(1); + string cubicmeterString = cubicmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentiliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; + Volume value = Volume.From(1, VolumeUnit.Centiliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicCentimeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; + Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicDecimeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; + Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicFootAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; + Volume value = Volume.From(1, VolumeUnit.CubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicInchAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; + Volume value = Volume.From(1, VolumeUnit.CubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicKilometerAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; + Volume value = Volume.From(1, VolumeUnit.CubicKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume value = Volume.From(1, VolumeUnit.CubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMileAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; + Volume value = Volume.From(1, VolumeUnit.CubicMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMillimeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; + Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicYardAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; + Volume value = Volume.From(1, VolumeUnit.CubicYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDeciliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; + Volume value = Volume.From(1, VolumeUnit.Deciliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectoliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; + Volume value = Volume.From(1, VolumeUnit.Hectoliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithImperialGallonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; + Volume value = Volume.From(1, VolumeUnit.ImperialGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithImperialOunceAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; + Volume value = Volume.From(1, VolumeUnit.ImperialOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithLiterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Liter; + Volume value = Volume.From(1, VolumeUnit.Liter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMetricCupAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; + Volume value = Volume.From(1, VolumeUnit.MetricCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; + Volume value = Volume.From(1, VolumeUnit.Milliliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTablespoonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; + Volume value = Volume.From(1, VolumeUnit.Tablespoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTeaspoonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; + Volume value = Volume.From(1, VolumeUnit.Teaspoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsCustomaryCupAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; + Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsGallonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; + Volume value = Volume.From(1, VolumeUnit.UsGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsLegalCupAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; + Volume value = Volume.From(1, VolumeUnit.UsLegalCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsOunceAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; + Volume value = Volume.From(1, VolumeUnit.UsOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index 2e97a8bb1d..06cb9a0466 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -473,13 +473,18 @@ public static AccelerationUnit ParseUnit(string str, IFormatProvider formatProvi #endregion + /// + /// Set the default unit used by ToString(). Default is MeterPerSecondSquared + /// + public static AccelerationUnit ToStringDefaultUnit { get; set; } = AccelerationUnit.MeterPerSecondSquared; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AccelerationUnit.MeterPerSecondSquared); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index af61d1867c..3345a69d0e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -401,13 +401,18 @@ public static AmplitudeRatioUnit ParseUnit(string str, IFormatProvider formatPro #endregion + /// + /// Set the default unit used by ToString(). Default is DecibelVolt + /// + public static AmplitudeRatioUnit ToStringDefaultUnit { get; set; } = AmplitudeRatioUnit.DecibelVolt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AmplitudeRatioUnit.DecibelVolt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index e47a9faa7c..77cff19645 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -533,13 +533,18 @@ public static AngleUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Degree + /// + public static AngleUnit ToStringDefaultUnit { get; set; } = AngleUnit.Degree; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AngleUnit.Degree); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index 726318e673..5e08fe1eae 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -533,13 +533,18 @@ public static AreaUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion + /// + /// Set the default unit used by ToString(). Default is SquareMeter + /// + public static AreaUnit ToStringDefaultUnit { get; set; } = AreaUnit.SquareMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AreaUnit.SquareMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 839f6c968f..69041d5b2c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -533,13 +533,18 @@ public static DensityUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is KilogramPerCubicMeter + /// + public static DensityUnit ToStringDefaultUnit { get; set; } = DensityUnit.KilogramPerCubicMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(DensityUnit.KilogramPerCubicMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index bf8c463258..ca0fe56f2e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -533,13 +533,18 @@ public static DurationUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is Second + /// + public static DurationUnit ToStringDefaultUnit { get; set; } = DurationUnit.Second; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(DurationUnit.Second); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index f7125fafa8..a619d6e0f1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -453,13 +453,18 @@ public static ElectricCurrentUnit ParseUnit(string str, IFormatProvider formatPr #endregion + /// + /// Set the default unit used by ToString(). Default is Ampere + /// + public static ElectricCurrentUnit ToStringDefaultUnit { get; set; } = ElectricCurrentUnit.Ampere; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ElectricCurrentUnit.Ampere); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index a722ba2583..d13104076a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -433,13 +433,18 @@ public static ElectricPotentialUnit ParseUnit(string str, IFormatProvider format #endregion + /// + /// Set the default unit used by ToString(). Default is Volt + /// + public static ElectricPotentialUnit ToStringDefaultUnit { get; set; } = ElectricPotentialUnit.Volt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ElectricPotentialUnit.Volt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index ea491f99d8..7eefaddba2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -393,13 +393,18 @@ public static ElectricResistanceUnit ParseUnit(string str, IFormatProvider forma #endregion + /// + /// Set the default unit used by ToString(). Default is Ohm + /// + public static ElectricResistanceUnit ToStringDefaultUnit { get; set; } = ElectricResistanceUnit.Ohm; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ElectricResistanceUnit.Ohm); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index c8ae39b475..83f057350d 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -593,13 +593,18 @@ public static EnergyUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is Joule + /// + public static EnergyUnit ToStringDefaultUnit { get; set; } = EnergyUnit.Joule; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(EnergyUnit.Joule); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index 42b467469c..d06971cdad 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -453,13 +453,18 @@ public static FlowUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion + /// + /// Set the default unit used by ToString(). Default is CubicMeterPerSecond + /// + public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(FlowUnit.CubicMeterPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index 5c2c200dd4..42df19cd1a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -493,13 +493,18 @@ public static ForceUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Newton + /// + public static ForceUnit ToStringDefaultUnit { get; set; } = ForceUnit.Newton; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ForceUnit.Newton); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 1aea4c3271..3e2a1c5407 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -353,13 +353,18 @@ public static ForceChangeRateUnit ParseUnit(string str, IFormatProvider formatPr #endregion + /// + /// Set the default unit used by ToString(). Default is NewtonPerSecond + /// + public static ForceChangeRateUnit ToStringDefaultUnit { get; set; } = ForceChangeRateUnit.NewtonPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ForceChangeRateUnit.NewtonPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index 537dda7d9e..d4cfba4764 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -493,13 +493,18 @@ public static FrequencyUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is Hertz + /// + public static FrequencyUnit ToStringDefaultUnit { get; set; } = FrequencyUnit.Hertz; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(FrequencyUnit.Hertz); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index dc0def7001..df44df560b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -853,13 +853,18 @@ public static InformationUnit ParseUnit(string str, IFormatProvider formatProvid #endregion + /// + /// Set the default unit used by ToString(). Default is Bit + /// + public static InformationUnit ToStringDefaultUnit { get; set; } = InformationUnit.Bit; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(InformationUnit.Bit); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index 26d841a987..a040344585 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -493,13 +493,18 @@ public static KinematicViscosityUnit ParseUnit(string str, IFormatProvider forma #endregion + /// + /// Set the default unit used by ToString(). Default is SquareMeterPerSecond + /// + public static KinematicViscosityUnit ToStringDefaultUnit { get; set; } = KinematicViscosityUnit.SquareMeterPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(KinematicViscosityUnit.SquareMeterPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index 7846ba599f..9ba7456ce1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -613,13 +613,18 @@ public static LengthUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is Meter + /// + public static LengthUnit ToStringDefaultUnit { get; set; } = LengthUnit.Meter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(LengthUnit.Meter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index de8f5d6018..bd586733b5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -381,13 +381,18 @@ public static LevelUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Decibel + /// + public static LevelUnit ToStringDefaultUnit { get; set; } = LevelUnit.Decibel; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(LevelUnit.Decibel); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index 6c649b8c52..cf38e8ac32 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -673,13 +673,18 @@ public static MassUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion + /// + /// Set the default unit used by ToString(). Default is Kilogram + /// + public static MassUnit ToStringDefaultUnit { get; set; } = MassUnit.Kilogram; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(MassUnit.Kilogram); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index 2d0faf105e..c2b7ed351f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -533,13 +533,18 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is GramPerSecond + /// + public static MassFlowUnit ToStringDefaultUnit { get; set; } = MassFlowUnit.GramPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(MassFlowUnit.GramPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index 8c88158567..2e26e468b5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -653,13 +653,18 @@ public static PowerUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Watt + /// + public static PowerUnit ToStringDefaultUnit { get; set; } = PowerUnit.Watt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PowerUnit.Watt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index 607ee46d94..f1dba52587 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -381,13 +381,18 @@ public static PowerRatioUnit ParseUnit(string str, IFormatProvider formatProvide #endregion + /// + /// Set the default unit used by ToString(). Default is DecibelWatt + /// + public static PowerRatioUnit ToStringDefaultUnit { get; set; } = PowerRatioUnit.DecibelWatt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PowerRatioUnit.DecibelWatt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index 1d6531cd75..949192870a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -993,13 +993,18 @@ public static PressureUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is Pascal + /// + public static PressureUnit ToStringDefaultUnit { get; set; } = PressureUnit.Pascal; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PressureUnit.Pascal); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index ab502194ae..6364253e19 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -413,13 +413,18 @@ public static PressureChangeRateUnit ParseUnit(string str, IFormatProvider forma #endregion + /// + /// Set the default unit used by ToString(). Default is PascalPerSecond + /// + public static PressureChangeRateUnit ToStringDefaultUnit { get; set; } = PressureChangeRateUnit.PascalPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PressureChangeRateUnit.PascalPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index d981186fee..0726b77d77 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -453,13 +453,18 @@ public static RatioUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is DecimalFraction + /// + public static RatioUnit ToStringDefaultUnit { get; set; } = RatioUnit.DecimalFraction; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(RatioUnit.DecimalFraction); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 7a06a8b558..951908a271 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -493,13 +493,18 @@ public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider formatPr #endregion + /// + /// Set the default unit used by ToString(). Default is RadianPerSecond + /// + public static RotationalSpeedUnit ToStringDefaultUnit { get; set; } = RotationalSpeedUnit.RadianPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(RotationalSpeedUnit.RadianPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index 39099ca08d..38672dd739 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -493,13 +493,18 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatPro #endregion + /// + /// Set the default unit used by ToString(). Default is JoulePerKilogram + /// + public static SpecificEnergyUnit ToStringDefaultUnit { get; set; } = SpecificEnergyUnit.JoulePerKilogram; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(SpecificEnergyUnit.JoulePerKilogram); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index 9c3420821c..f3704b9d1e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -653,13 +653,18 @@ public static SpecificWeightUnit ParseUnit(string str, IFormatProvider formatPro #endregion + /// + /// Set the default unit used by ToString(). Default is NewtonPerCubicMeter + /// + public static SpecificWeightUnit ToStringDefaultUnit { get; set; } = SpecificWeightUnit.NewtonPerCubicMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(SpecificWeightUnit.NewtonPerCubicMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index b26772f673..c916efaaec 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -573,13 +573,18 @@ public static SpeedUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is MeterPerSecond + /// + public static SpeedUnit ToStringDefaultUnit { get; set; } = SpeedUnit.MeterPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(SpeedUnit.MeterPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index c6cdbfebee..7d3100c67c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -493,13 +493,18 @@ public static TemperatureUnit ParseUnit(string str, IFormatProvider formatProvid #endregion + /// + /// Set the default unit used by ToString(). Default is Kelvin + /// + public static TemperatureUnit ToStringDefaultUnit { get; set; } = TemperatureUnit.Kelvin; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(TemperatureUnit.Kelvin); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index cdbbc6777d..97f3d3114b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -513,13 +513,18 @@ public static TemperatureChangeRateUnit ParseUnit(string str, IFormatProvider fo #endregion + /// + /// Set the default unit used by ToString(). Default is DegreeCelsiusPerSecond + /// + public static TemperatureChangeRateUnit ToStringDefaultUnit { get; set; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index 9db32f4dac..e40b44e8a7 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -653,13 +653,18 @@ public static TorqueUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is NewtonMeter + /// + public static TorqueUnit ToStringDefaultUnit { get; set; } = TorqueUnit.NewtonMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(TorqueUnit.NewtonMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 9fd638199d..0366d7d3a0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -353,13 +353,18 @@ public static VitaminAUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is InternationalUnit + /// + public static VitaminAUnit ToStringDefaultUnit { get; set; } = VitaminAUnit.InternationalUnit; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(VitaminAUnit.InternationalUnit); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index 53d824909f..6e89da74e6 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -793,13 +793,18 @@ public static VolumeUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is CubicMeter + /// + public static VolumeUnit ToStringDefaultUnit { get; set; } = VolumeUnit.CubicMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(VolumeUnit.CubicMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index 211c3dece8..b236401c44 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -386,13 +386,18 @@ namespace UnitsNet #endregion + /// + /// Set the default unit used by ToString(). Default is $baseUnitSingularName + /// + public static $unitEnumName ToStringDefaultUnit { get; set; } = $unitEnumName.$baseUnitSingularName; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString($unitEnumName.$baseUnitSingularName); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index 4d707f64df..a06a50c8ed 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -194,6 +194,30 @@ namespace UnitsNet.Tests $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); Assert.IsFalse($baseUnitVariableName.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); + $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); + string $($baseUnitVariableName)String = $($baseUnitVariableName).ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); + } + +"@; foreach ($unit in $units) {@" + [Test] + public void ToStringReturnsCorrectNumberAndUnitWith$($unit.SingularName)AsDefualtUnit() + { + $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; + $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); + $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); + $($className).ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + +"@; }@" } } "@; From 9ca944bc7ab7f8b439db938a4f699a7f51279a0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Oveg=C3=A5rd?= Date: Wed, 10 Feb 2016 09:20:16 +0100 Subject: [PATCH 2/8] Replaced tabs with spaces --- .../GeneratedCode/AccelerationTestsBase.g.cs | 102 ++-- .../AmplitudeRatioTestsBase.g.cs | 46 +- .../GeneratedCode/AngleTestsBase.g.cs | 144 +++--- .../GeneratedCode/AreaTestsBase.g.cs | 144 +++--- .../GeneratedCode/DensityTestsBase.g.cs | 144 +++--- .../GeneratedCode/DurationTestsBase.g.cs | 144 +++--- .../ElectricCurrentTestsBase.g.cs | 88 ++-- .../ElectricPotentialTestsBase.g.cs | 74 +-- .../ElectricResistanceTestsBase.g.cs | 46 +- .../GeneratedCode/EnergyTestsBase.g.cs | 186 +++---- .../GeneratedCode/FlowTestsBase.g.cs | 88 ++-- .../ForceChangeRateTestsBase.g.cs | 18 +- .../GeneratedCode/ForceTestsBase.g.cs | 116 ++--- .../GeneratedCode/FrequencyTestsBase.g.cs | 116 ++--- .../GeneratedCode/InformationTestsBase.g.cs | 368 +++++++------- .../KinematicViscosityTestsBase.g.cs | 116 ++--- .../GeneratedCode/LengthTestsBase.g.cs | 200 ++++---- .../GeneratedCode/LevelTestsBase.g.cs | 32 +- .../GeneratedCode/MassFlowTestsBase.g.cs | 144 +++--- .../GeneratedCode/MassTestsBase.g.cs | 242 ++++----- .../GeneratedCode/PowerRatioTestsBase.g.cs | 32 +- .../GeneratedCode/PowerTestsBase.g.cs | 228 ++++----- .../PressureChangeRateTestsBase.g.cs | 60 +-- .../GeneratedCode/PressureTestsBase.g.cs | 466 +++++++++--------- .../GeneratedCode/RatioTestsBase.g.cs | 88 ++-- .../RotationalSpeedTestsBase.g.cs | 116 ++--- .../SpecificEnergyTestsBase.g.cs | 116 ++--- .../SpecificWeightTestsBase.g.cs | 228 ++++----- .../GeneratedCode/SpeedTestsBase.g.cs | 172 +++---- .../TemperatureChangeRateTestsBase.g.cs | 130 ++--- .../GeneratedCode/TemperatureTestsBase.g.cs | 116 ++--- .../GeneratedCode/TorqueTestsBase.g.cs | 228 ++++----- .../GeneratedCode/VitaminATestsBase.g.cs | 18 +- .../GeneratedCode/VolumeTestsBase.g.cs | 326 ++++++------ ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 18 +- 35 files changed, 2450 insertions(+), 2450 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index dc355038bf..64a55c7a36 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -203,94 +203,94 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); string meterpersecondsquaredString = meterpersecondsquared.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index c4f7fe5f29..7b1e0f98f7 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -183,46 +183,46 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); string decibelvoltString = decibelvolt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelMicrovoltAsDefualtUnit() { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelMillivoltAsDefualtUnit() { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelVoltAsDefualtUnit() { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index da49a60e5b..0f87ed1012 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle.ToStringDefaultUnit = AngleUnit.Degree; Angle degree = Angle.FromDegrees(1); string degreeString = degree.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithArcminuteAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Arcminute; - Angle value = Angle.From(1, AngleUnit.Arcminute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcminute; + Angle value = Angle.From(1, AngleUnit.Arcminute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithArcsecondAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; - Angle value = Angle.From(1, AngleUnit.Arcsecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; + Angle value = Angle.From(1, AngleUnit.Arcsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentiradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Centiradian; - Angle value = Angle.From(1, AngleUnit.Centiradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Centiradian; + Angle value = Angle.From(1, AngleUnit.Centiradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDeciradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Deciradian; - Angle value = Angle.From(1, AngleUnit.Deciradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Deciradian; + Angle value = Angle.From(1, AngleUnit.Deciradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Degree; - Angle value = Angle.From(1, AngleUnit.Degree); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle value = Angle.From(1, AngleUnit.Degree); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Gradian; - Angle value = Angle.From(1, AngleUnit.Gradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Gradian; + Angle value = Angle.From(1, AngleUnit.Gradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Microradian; - Angle value = Angle.From(1, AngleUnit.Microradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Microradian; + Angle value = Angle.From(1, AngleUnit.Microradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Milliradian; - Angle value = Angle.From(1, AngleUnit.Milliradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Milliradian; + Angle value = Angle.From(1, AngleUnit.Milliradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanoradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; - Angle value = Angle.From(1, AngleUnit.Nanoradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; + Angle value = Angle.From(1, AngleUnit.Nanoradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRadianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Radian; - Angle value = Angle.From(1, AngleUnit.Radian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Radian; + Angle value = Angle.From(1, AngleUnit.Radian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index 9215120cd9..726f92662a 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; Area squaremeter = Area.FromSquareMeters(1); string squaremeterString = squaremeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareCentimeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; - Area value = Area.From(1, AreaUnit.SquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; + Area value = Area.From(1, AreaUnit.SquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareDecimeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; - Area value = Area.From(1, AreaUnit.SquareDecimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; + Area value = Area.From(1, AreaUnit.SquareDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareFootAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareFoot; - Area value = Area.From(1, AreaUnit.SquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareFoot; + Area value = Area.From(1, AreaUnit.SquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareInchAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareInch; - Area value = Area.From(1, AreaUnit.SquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareInch; + Area value = Area.From(1, AreaUnit.SquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareKilometerAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; - Area value = Area.From(1, AreaUnit.SquareKilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; + Area value = Area.From(1, AreaUnit.SquareKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMeter; - Area value = Area.From(1, AreaUnit.SquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area value = Area.From(1, AreaUnit.SquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMicrometerAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; - Area value = Area.From(1, AreaUnit.SquareMicrometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; + Area value = Area.From(1, AreaUnit.SquareMicrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMileAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMile; - Area value = Area.From(1, AreaUnit.SquareMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMile; + Area value = Area.From(1, AreaUnit.SquareMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMillimeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; - Area value = Area.From(1, AreaUnit.SquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; + Area value = Area.From(1, AreaUnit.SquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareYardAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareYard; - Area value = Area.From(1, AreaUnit.SquareYard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareYard; + Area value = Area.From(1, AreaUnit.SquareYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 68b54cb471..20e56e7575 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); string kilogrampercubicmeterString = kilogrampercubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicCentimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMillimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicFootAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; - Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicInchAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; - Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicFootAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; - Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicInchAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; - Density value = Density.From(1, DensityUnit.PoundPerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; + Density value = Density.From(1, DensityUnit.PoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicCentimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMillimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index b148cc0940..64e708efc6 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration.ToStringDefaultUnit = DurationUnit.Second; Duration second = Duration.FromSeconds(1); string secondString = second.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDayAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Day; - Duration value = Duration.From(1, DurationUnit.Day); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Day; + Duration value = Duration.From(1, DurationUnit.Day); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHourAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Hour; - Duration value = Duration.From(1, DurationUnit.Hour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Hour; + Duration value = Duration.From(1, DurationUnit.Hour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrosecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Microsecond; - Duration value = Duration.From(1, DurationUnit.Microsecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Microsecond; + Duration value = Duration.From(1, DurationUnit.Microsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillisecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Millisecond; - Duration value = Duration.From(1, DurationUnit.Millisecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Millisecond; + Duration value = Duration.From(1, DurationUnit.Millisecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMinuteAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Minute; - Duration value = Duration.From(1, DurationUnit.Minute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Minute; + Duration value = Duration.From(1, DurationUnit.Minute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMonthAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Month; - Duration value = Duration.From(1, DurationUnit.Month); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Month; + Duration value = Duration.From(1, DurationUnit.Month); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanosecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; - Duration value = Duration.From(1, DurationUnit.Nanosecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; + Duration value = Duration.From(1, DurationUnit.Nanosecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Second; - Duration value = Duration.From(1, DurationUnit.Second); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration value = Duration.From(1, DurationUnit.Second); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWeekAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Week; - Duration value = Duration.From(1, DurationUnit.Week); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Week; + Duration value = Duration.From(1, DurationUnit.Week); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithYearAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Year; - Duration value = Duration.From(1, DurationUnit.Year); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Year; + Duration value = Duration.From(1, DurationUnit.Year); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 264449f25d..6d31f8d7ab 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -197,82 +197,82 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); string ampereString = ampere.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithAmpereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKiloampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegaampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanoampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index c563008ac1..6afa40eff5 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -191,70 +191,70 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; ElectricPotential volt = ElectricPotential.FromVolts(1); string voltString = volt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilovoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegavoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrovoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillivoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithVoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index 8b926774db..178f200425 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -179,46 +179,46 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; ElectricResistance ohm = ElectricResistance.FromOhms(1); string ohmString = ohm.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKiloohmAsDefualtUnit() { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegaohmAsDefualtUnit() { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithOhmAsDefualtUnit() { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index baff65f537..54736583f4 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -239,166 +239,166 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy.ToStringDefaultUnit = EnergyUnit.Joule; Energy joule = Energy.FromJoules(1); string jouleString = joule.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBritishThermalUnitAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; - Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; + Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCalorieAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Calorie; - Energy value = Energy.From(1, EnergyUnit.Calorie); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Calorie; + Energy value = Energy.From(1, EnergyUnit.Calorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithElectronVoltAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; - Energy value = Energy.From(1, EnergyUnit.ElectronVolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; + Energy value = Energy.From(1, EnergyUnit.ElectronVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithErgAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Erg; - Energy value = Energy.From(1, EnergyUnit.Erg); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Erg; + Energy value = Energy.From(1, EnergyUnit.Erg); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFootPoundAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.FootPound; - Energy value = Energy.From(1, EnergyUnit.FootPound); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.FootPound; + Energy value = Energy.From(1, EnergyUnit.FootPound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigawattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; - Energy value = Energy.From(1, EnergyUnit.GigawattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; + Energy value = Energy.From(1, EnergyUnit.GigawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithJouleAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Joule; - Energy value = Energy.From(1, EnergyUnit.Joule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy value = Energy.From(1, EnergyUnit.Joule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilocalorieAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; - Energy value = Energy.From(1, EnergyUnit.Kilocalorie); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; + Energy value = Energy.From(1, EnergyUnit.Kilocalorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilojouleAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; - Energy value = Energy.From(1, EnergyUnit.Kilojoule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; + Energy value = Energy.From(1, EnergyUnit.Kilojoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; - Energy value = Energy.From(1, EnergyUnit.KilowattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; + Energy value = Energy.From(1, EnergyUnit.KilowattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegajouleAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; - Energy value = Energy.From(1, EnergyUnit.Megajoule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; + Energy value = Energy.From(1, EnergyUnit.Megajoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; - Energy value = Energy.From(1, EnergyUnit.MegawattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; + Energy value = Energy.From(1, EnergyUnit.MegawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.WattHour; - Energy value = Energy.From(1, EnergyUnit.WattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.WattHour; + Energy value = Energy.From(1, EnergyUnit.WattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 402e7fa9b0..4520a3c16a 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -197,82 +197,82 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); string cubicmeterpersecondString = cubicmeterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicFootPerSecondAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; - Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerHourAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; - Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerSecondAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; - Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithLitersPerMinuteAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; - Flow value = Flow.From(1, FlowUnit.LitersPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; + Flow value = Flow.From(1, FlowUnit.LitersPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillionUsGallonsPerDayAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; - Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; + Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsGallonsPerMinuteAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; - Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; + Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index 75abf80e3a..7ec1831d92 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -167,22 +167,22 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); string newtonpersecondString = newtonpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSecondAsDefualtUnit() { - ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; - ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; - ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); - ForceChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); + ForceChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 3eba27b8b5..6483856b69 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Force.ToStringDefaultUnit = ForceUnit.Newton; + Force.ToStringDefaultUnit = ForceUnit.Newton; Force newton = Force.FromNewtons(1); string newtonString = newton.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDynAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Dyn; - Force value = Force.From(1, ForceUnit.Dyn); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Dyn; + Force value = Force.From(1, ForceUnit.Dyn); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.KilogramForce; - Force value = Force.From(1, ForceUnit.KilogramForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KilogramForce; + Force value = Force.From(1, ForceUnit.KilogramForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Kilonewton; - Force value = Force.From(1, ForceUnit.Kilonewton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Kilonewton; + Force value = Force.From(1, ForceUnit.Kilonewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKiloPondAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.KiloPond; - Force value = Force.From(1, ForceUnit.KiloPond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KiloPond; + Force value = Force.From(1, ForceUnit.KiloPond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Newton; - Force value = Force.From(1, ForceUnit.Newton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Newton; + Force value = Force.From(1, ForceUnit.Newton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundalAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Poundal; - Force value = Force.From(1, ForceUnit.Poundal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Poundal; + Force value = Force.From(1, ForceUnit.Poundal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForceAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.PoundForce; - Force value = Force.From(1, ForceUnit.PoundForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.PoundForce; + Force value = Force.From(1, ForceUnit.PoundForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.TonneForce; - Force value = Force.From(1, ForceUnit.TonneForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.TonneForce; + Force value = Force.From(1, ForceUnit.TonneForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index b1e65ce6d0..43b35a8281 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; Frequency hertz = Frequency.FromHertz(1); string hertzString = hertz.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCyclePerHourAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; - Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCyclePerMinuteAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; - Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigahertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; - Frequency value = Frequency.From(1, FrequencyUnit.Hertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency value = Frequency.From(1, FrequencyUnit.Hertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilohertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; - Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; + Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegahertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; - Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; + Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerahertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index 55a94856e8..2122a37be7 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -317,322 +317,322 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Information.ToStringDefaultUnit = InformationUnit.Bit; + Information.ToStringDefaultUnit = InformationUnit.Bit; Information bit = Information.FromBits(1); string bitString = bit.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Bit; - Information value = Information.From(1, InformationUnit.Bit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Bit; + Information value = Information.From(1, InformationUnit.Bit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithByteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Byte; - Information value = Information.From(1, InformationUnit.Byte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Byte; + Information value = Information.From(1, InformationUnit.Byte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exabit; - Information value = Information.From(1, InformationUnit.Exabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabit; + Information value = Information.From(1, InformationUnit.Exabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exabyte; - Information value = Information.From(1, InformationUnit.Exabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabyte; + Information value = Information.From(1, InformationUnit.Exabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExbibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exbibit; - Information value = Information.From(1, InformationUnit.Exbibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibit; + Information value = Information.From(1, InformationUnit.Exbibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExbibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exbibyte; - Information value = Information.From(1, InformationUnit.Exbibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibyte; + Information value = Information.From(1, InformationUnit.Exbibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGibibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gibibit; - Information value = Information.From(1, InformationUnit.Gibibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibit; + Information value = Information.From(1, InformationUnit.Gibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGibibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gibibyte; - Information value = Information.From(1, InformationUnit.Gibibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibyte; + Information value = Information.From(1, InformationUnit.Gibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gigabit; - Information value = Information.From(1, InformationUnit.Gigabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabit; + Information value = Information.From(1, InformationUnit.Gigabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gigabyte; - Information value = Information.From(1, InformationUnit.Gigabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabyte; + Information value = Information.From(1, InformationUnit.Gigabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKibibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kibibit; - Information value = Information.From(1, InformationUnit.Kibibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibit; + Information value = Information.From(1, InformationUnit.Kibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKibibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kibibyte; - Information value = Information.From(1, InformationUnit.Kibibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibyte; + Information value = Information.From(1, InformationUnit.Kibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilobitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kilobit; - Information value = Information.From(1, InformationUnit.Kilobit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobit; + Information value = Information.From(1, InformationUnit.Kilobit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilobyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kilobyte; - Information value = Information.From(1, InformationUnit.Kilobyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobyte; + Information value = Information.From(1, InformationUnit.Kilobyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMebibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Mebibit; - Information value = Information.From(1, InformationUnit.Mebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibit; + Information value = Information.From(1, InformationUnit.Mebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMebibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Mebibyte; - Information value = Information.From(1, InformationUnit.Mebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibyte; + Information value = Information.From(1, InformationUnit.Mebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Megabit; - Information value = Information.From(1, InformationUnit.Megabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabit; + Information value = Information.From(1, InformationUnit.Megabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Megabyte; - Information value = Information.From(1, InformationUnit.Megabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabyte; + Information value = Information.From(1, InformationUnit.Megabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPebibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Pebibit; - Information value = Information.From(1, InformationUnit.Pebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibit; + Information value = Information.From(1, InformationUnit.Pebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPebibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Pebibyte; - Information value = Information.From(1, InformationUnit.Pebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibyte; + Information value = Information.From(1, InformationUnit.Pebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPetabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Petabit; - Information value = Information.From(1, InformationUnit.Petabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabit; + Information value = Information.From(1, InformationUnit.Petabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPetabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Petabyte; - Information value = Information.From(1, InformationUnit.Petabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabyte; + Information value = Information.From(1, InformationUnit.Petabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTebibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Tebibit; - Information value = Information.From(1, InformationUnit.Tebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibit; + Information value = Information.From(1, InformationUnit.Tebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTebibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Tebibyte; - Information value = Information.From(1, InformationUnit.Tebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibyte; + Information value = Information.From(1, InformationUnit.Tebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Terabit; - Information value = Information.From(1, InformationUnit.Terabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabit; + Information value = Information.From(1, InformationUnit.Terabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Terabyte; - Information value = Information.From(1, InformationUnit.Terabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabyte; + Information value = Information.From(1, InformationUnit.Terabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 6bc405bf99..9691724f1f 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); string squaremeterpersecondString = squaremeterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentistokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecistokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilostokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrostokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillistokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanostokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterPerSecondAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithStokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index 306d567680..c30884f5de 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -245,178 +245,178 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Length.ToStringDefaultUnit = LengthUnit.Meter; + Length.ToStringDefaultUnit = LengthUnit.Meter; Length meter = Length.FromMeters(1); string meterString = meter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Centimeter; - Length value = Length.From(1, LengthUnit.Centimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Centimeter; + Length value = Length.From(1, LengthUnit.Centimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Decimeter; - Length value = Length.From(1, LengthUnit.Decimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Decimeter; + Length value = Length.From(1, LengthUnit.Decimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFootAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Foot; - Length value = Length.From(1, LengthUnit.Foot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Foot; + Length value = Length.From(1, LengthUnit.Foot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithInchAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Inch; - Length value = Length.From(1, LengthUnit.Inch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Inch; + Length value = Length.From(1, LengthUnit.Inch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Kilometer; - Length value = Length.From(1, LengthUnit.Kilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Kilometer; + Length value = Length.From(1, LengthUnit.Kilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Meter; - Length value = Length.From(1, LengthUnit.Meter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length value = Length.From(1, LengthUnit.Meter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroinchAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Microinch; - Length value = Length.From(1, LengthUnit.Microinch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Microinch; + Length value = Length.From(1, LengthUnit.Microinch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrometerAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Micrometer; - Length value = Length.From(1, LengthUnit.Micrometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Micrometer; + Length value = Length.From(1, LengthUnit.Micrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Mil; - Length value = Length.From(1, LengthUnit.Mil); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mil; + Length value = Length.From(1, LengthUnit.Mil); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMileAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Mile; - Length value = Length.From(1, LengthUnit.Mile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mile; + Length value = Length.From(1, LengthUnit.Mile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillimeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Millimeter; - Length value = Length.From(1, LengthUnit.Millimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Millimeter; + Length value = Length.From(1, LengthUnit.Millimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanometerAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Nanometer; - Length value = Length.From(1, LengthUnit.Nanometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Nanometer; + Length value = Length.From(1, LengthUnit.Nanometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNauticalMileAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.NauticalMile; - Length value = Length.From(1, LengthUnit.NauticalMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.NauticalMile; + Length value = Length.From(1, LengthUnit.NauticalMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithYardAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Yard; - Length value = Length.From(1, LengthUnit.Yard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Yard; + Length value = Length.From(1, LengthUnit.Yard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index 3d77584013..95d04f1d68 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -177,34 +177,34 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level.ToStringDefaultUnit = LevelUnit.Decibel; Level decibel = Level.FromDecibels(1); string decibelString = decibel.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelAsDefualtUnit() { - LevelUnit oldUnit = Level.ToStringDefaultUnit; - Level.ToStringDefaultUnit = LevelUnit.Decibel; - Level value = Level.From(1, LevelUnit.Decibel); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); - Level.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level value = Level.From(1, LevelUnit.Decibel); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNeperAsDefualtUnit() { - LevelUnit oldUnit = Level.ToStringDefaultUnit; - Level.ToStringDefaultUnit = LevelUnit.Neper; - Level value = Level.From(1, LevelUnit.Neper); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); - Level.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Neper; + Level value = Level.From(1, LevelUnit.Neper); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 3f3d327b24..266565f986 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); string grampersecondString = grampersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentigramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecagramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecigramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilligramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerDayAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; - MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; + MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 417a214677..f4a67d074e 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -263,214 +263,214 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass.ToStringDefaultUnit = MassUnit.Kilogram; Mass kilogram = Mass.FromKilograms(1); string kilogramString = kilogram.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentigramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Centigram; - Mass value = Mass.From(1, MassUnit.Centigram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Centigram; + Mass value = Mass.From(1, MassUnit.Centigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecagramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Decagram; - Mass value = Mass.From(1, MassUnit.Decagram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decagram; + Mass value = Mass.From(1, MassUnit.Decagram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecigramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Decigram; - Mass value = Mass.From(1, MassUnit.Decigram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decigram; + Mass value = Mass.From(1, MassUnit.Decigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Gram; - Mass value = Mass.From(1, MassUnit.Gram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Gram; + Mass value = Mass.From(1, MassUnit.Gram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Hectogram; - Mass value = Mass.From(1, MassUnit.Hectogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Hectogram; + Mass value = Mass.From(1, MassUnit.Hectogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Kilogram; - Mass value = Mass.From(1, MassUnit.Kilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass value = Mass.From(1, MassUnit.Kilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilotonneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Kilotonne; - Mass value = Mass.From(1, MassUnit.Kilotonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilotonne; + Mass value = Mass.From(1, MassUnit.Kilotonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithLongTonAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.LongTon; - Mass value = Mass.From(1, MassUnit.LongTon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.LongTon; + Mass value = Mass.From(1, MassUnit.LongTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegatonneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Megatonne; - Mass value = Mass.From(1, MassUnit.Megatonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Megatonne; + Mass value = Mass.From(1, MassUnit.Megatonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Microgram; - Mass value = Mass.From(1, MassUnit.Microgram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Microgram; + Mass value = Mass.From(1, MassUnit.Microgram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilligramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Milligram; - Mass value = Mass.From(1, MassUnit.Milligram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Milligram; + Mass value = Mass.From(1, MassUnit.Milligram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Nanogram; - Mass value = Mass.From(1, MassUnit.Nanogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Nanogram; + Mass value = Mass.From(1, MassUnit.Nanogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithOunceAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Ounce; - Mass value = Mass.From(1, MassUnit.Ounce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Ounce; + Mass value = Mass.From(1, MassUnit.Ounce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Pound; - Mass value = Mass.From(1, MassUnit.Pound); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Pound; + Mass value = Mass.From(1, MassUnit.Pound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithShortTonAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.ShortTon; - Mass value = Mass.From(1, MassUnit.ShortTon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.ShortTon; + Mass value = Mass.From(1, MassUnit.ShortTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithStoneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Stone; - Mass value = Mass.From(1, MassUnit.Stone); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Stone; + Mass value = Mass.From(1, MassUnit.Stone); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Tonne; - Mass value = Mass.From(1, MassUnit.Tonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Tonne; + Mass value = Mass.From(1, MassUnit.Tonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index afc9c13bc4..931ec7f1bc 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -177,34 +177,34 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); string decibelwattString = decibelwatt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelMilliwattAsDefualtUnit() { - PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; - PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); - PowerRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelWattAsDefualtUnit() { - PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; - PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); - PowerRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index a6323103b1..368d21be22 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -257,202 +257,202 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Power.ToStringDefaultUnit = PowerUnit.Watt; + Power.ToStringDefaultUnit = PowerUnit.Watt; Power watt = Power.FromWatts(1); string wattString = watt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBoilerHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; - Power value = Power.From(1, PowerUnit.BoilerHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; + Power value = Power.From(1, PowerUnit.BoilerHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithElectricalHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; - Power value = Power.From(1, PowerUnit.ElectricalHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; + Power value = Power.From(1, PowerUnit.ElectricalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFemtowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Femtowatt; - Power value = Power.From(1, PowerUnit.Femtowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Femtowatt; + Power value = Power.From(1, PowerUnit.Femtowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Gigawatt; - Power value = Power.From(1, PowerUnit.Gigawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Gigawatt; + Power value = Power.From(1, PowerUnit.Gigawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHydraulicHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; - Power value = Power.From(1, PowerUnit.HydraulicHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; + Power value = Power.From(1, PowerUnit.HydraulicHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Kilowatt; - Power value = Power.From(1, PowerUnit.Kilowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Kilowatt; + Power value = Power.From(1, PowerUnit.Kilowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMechanicalHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; - Power value = Power.From(1, PowerUnit.MechanicalHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; + Power value = Power.From(1, PowerUnit.MechanicalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Megawatt; - Power value = Power.From(1, PowerUnit.Megawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Megawatt; + Power value = Power.From(1, PowerUnit.Megawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMetricHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; - Power value = Power.From(1, PowerUnit.MetricHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; + Power value = Power.From(1, PowerUnit.MetricHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Microwatt; - Power value = Power.From(1, PowerUnit.Microwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Microwatt; + Power value = Power.From(1, PowerUnit.Microwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliwattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Milliwatt; - Power value = Power.From(1, PowerUnit.Milliwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Milliwatt; + Power value = Power.From(1, PowerUnit.Milliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Nanowatt; - Power value = Power.From(1, PowerUnit.Nanowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Nanowatt; + Power value = Power.From(1, PowerUnit.Nanowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPetawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Petawatt; - Power value = Power.From(1, PowerUnit.Petawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Petawatt; + Power value = Power.From(1, PowerUnit.Petawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPicowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Picowatt; - Power value = Power.From(1, PowerUnit.Picowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Picowatt; + Power value = Power.From(1, PowerUnit.Picowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Terawatt; - Power value = Power.From(1, PowerUnit.Terawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Terawatt; + Power value = Power.From(1, PowerUnit.Terawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Watt; - Power value = Power.From(1, PowerUnit.Watt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Watt; + Power value = Power.From(1, PowerUnit.Watt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index 317f0af622..e7e3733c2d 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -185,58 +185,58 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); string pascalpersecondString = pascalpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithAtmospherePerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopascalPerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegapascalPerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPascalPerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index 93222d94bd..864c8a2902 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -359,406 +359,406 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; Pressure pascal = Pressure.FromPascals(1); string pascalString = pascal.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithAtmosphereAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; - Pressure value = Pressure.From(1, PressureUnit.Atmosphere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; + Pressure value = Pressure.From(1, PressureUnit.Atmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Bar; - Pressure value = Pressure.From(1, PressureUnit.Bar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Bar; + Pressure value = Pressure.From(1, PressureUnit.Bar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentibarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Centibar; - Pressure value = Pressure.From(1, PressureUnit.Centibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Centibar; + Pressure value = Pressure.From(1, PressureUnit.Centibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecapascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; - Pressure value = Pressure.From(1, PressureUnit.Decapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; + Pressure value = Pressure.From(1, PressureUnit.Decapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Decibar; - Pressure value = Pressure.From(1, PressureUnit.Decibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decibar; + Pressure value = Pressure.From(1, PressureUnit.Decibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigapascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; - Pressure value = Pressure.From(1, PressureUnit.Gigapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; + Pressure value = Pressure.From(1, PressureUnit.Gigapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectopascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; - Pressure value = Pressure.From(1, PressureUnit.Hectopascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; + Pressure value = Pressure.From(1, PressureUnit.Hectopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilobarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; - Pressure value = Pressure.From(1, PressureUnit.Kilobar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; + Pressure value = Pressure.From(1, PressureUnit.Kilobar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; - Pressure value = Pressure.From(1, PressureUnit.Kilopascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; + Pressure value = Pressure.From(1, PressureUnit.Kilopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareFootAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; - Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareInchAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; - Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegabarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Megabar; - Pressure value = Pressure.From(1, PressureUnit.Megabar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megabar; + Pressure value = Pressure.From(1, PressureUnit.Megabar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegapascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; - Pressure value = Pressure.From(1, PressureUnit.Megapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; + Pressure value = Pressure.From(1, PressureUnit.Megapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicropascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; - Pressure value = Pressure.From(1, PressureUnit.Micropascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; + Pressure value = Pressure.From(1, PressureUnit.Micropascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillibarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Millibar; - Pressure value = Pressure.From(1, PressureUnit.Millibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Millibar; + Pressure value = Pressure.From(1, PressureUnit.Millibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Pascal; - Pressure value = Pressure.From(1, PressureUnit.Pascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure value = Pressure.From(1, PressureUnit.Pascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareFootAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; - Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareInchAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; - Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPsiAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Psi; - Pressure value = Pressure.From(1, PressureUnit.Psi); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Psi; + Pressure value = Pressure.From(1, PressureUnit.Psi); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTechnicalAtmosphereAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; - Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; + Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTorrAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Torr; - Pressure value = Pressure.From(1, PressureUnit.Torr); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Torr; + Pressure value = Pressure.From(1, PressureUnit.Torr); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 27c96ca539..d024d2556d 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -197,82 +197,82 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; Ratio decimalfraction = Ratio.FromDecimalFractions(1); string decimalfractionString = decimalfraction.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimalFractionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; - Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerBillionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerMillionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerThousandAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; - Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; + Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerTrillionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPercentAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.Percent; - Ratio value = Ratio.From(1, RatioUnit.Percent); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.Percent; + Ratio value = Ratio.From(1, RatioUnit.Percent); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 0794eaa618..be50210e62 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); string radianpersecondString = radianpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentiradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDeciradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanoradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerMinuteAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 0f81a0d72c..9002584536 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); string jouleperkilogramString = jouleperkilogram.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCaloriePerGramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithJoulePerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilocaloriePerGramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilojoulePerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourPerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegajoulePerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourPerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWattHourPerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 4f63508749..2cc5278d59 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -257,202 +257,202 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); string newtonpercubicmeterString = newtonpercubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicFootAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicInchAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicFootAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicInchAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 77ff0ec620..27d9dd232a 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -233,154 +233,154 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; Speed meterpersecond = Speed.FromMetersPerSecond(1); string meterpersecondString = meterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFootPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; - Speed value = Speed.From(1, SpeedUnit.FootPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; + Speed value = Speed.From(1, SpeedUnit.FootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerHourAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; - Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; + Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKnotAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.Knot; - Speed value = Speed.From(1, SpeedUnit.Knot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.Knot; + Speed value = Speed.From(1, SpeedUnit.Knot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterPerHourAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; - Speed value = Speed.From(1, SpeedUnit.MeterPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; + Speed value = Speed.From(1, SpeedUnit.MeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilePerHourAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; - Speed value = Speed.From(1, SpeedUnit.MilePerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; + Speed value = Speed.From(1, SpeedUnit.MilePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index c826d257db..b5f32c853c 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -215,118 +215,118 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); string degreecelsiuspersecondString = degreecelsiuspersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentidegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecadegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecidegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillidegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 2ef8499deb..02c32c313f 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; Temperature kelvin = Temperature.FromKelvins(1); string kelvinString = kelvin.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeDelisleAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeFahrenheitAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeNewtonAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeRankineAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeReaumurAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeRoemerAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKelvinAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; - Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index e4dfc47607..7552313201 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -257,202 +257,202 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; Torque newtonmeter = Torque.FromNewtonMeters(1); string newtonmeterString = newtonmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceFootAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; - Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceInchAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; - Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; - Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; - Torque value = Torque.From(1, TorqueUnit.NewtonMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; - Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForceFootAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; - Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForceInchAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; - Torque value = Torque.From(1, TorqueUnit.PoundForceInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; + Torque value = Torque.From(1, TorqueUnit.PoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index bb33c97f20..7eae28d304 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -167,22 +167,22 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; VitaminA internationalunit = VitaminA.FromInternationalUnits(1); string internationalunitString = internationalunit.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithInternationalUnitAsDefualtUnit() { - VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; - VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; - VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); - VitaminA.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); + VitaminA.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index a51007a15f..ab1aedc8bb 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -299,286 +299,286 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; Volume cubicmeter = Volume.FromCubicMeters(1); string cubicmeterString = cubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentiliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; - Volume value = Volume.From(1, VolumeUnit.Centiliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; + Volume value = Volume.From(1, VolumeUnit.Centiliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicCentimeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; - Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; + Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicDecimeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; - Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; + Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicFootAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; - Volume value = Volume.From(1, VolumeUnit.CubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; + Volume value = Volume.From(1, VolumeUnit.CubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicInchAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; - Volume value = Volume.From(1, VolumeUnit.CubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; + Volume value = Volume.From(1, VolumeUnit.CubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicKilometerAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; - Volume value = Volume.From(1, VolumeUnit.CubicKilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; + Volume value = Volume.From(1, VolumeUnit.CubicKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; - Volume value = Volume.From(1, VolumeUnit.CubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume value = Volume.From(1, VolumeUnit.CubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMileAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; - Volume value = Volume.From(1, VolumeUnit.CubicMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; + Volume value = Volume.From(1, VolumeUnit.CubicMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMillimeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; - Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; + Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicYardAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; - Volume value = Volume.From(1, VolumeUnit.CubicYard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; + Volume value = Volume.From(1, VolumeUnit.CubicYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDeciliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; - Volume value = Volume.From(1, VolumeUnit.Deciliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; + Volume value = Volume.From(1, VolumeUnit.Deciliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectoliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; - Volume value = Volume.From(1, VolumeUnit.Hectoliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; + Volume value = Volume.From(1, VolumeUnit.Hectoliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithImperialGallonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; - Volume value = Volume.From(1, VolumeUnit.ImperialGallon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; + Volume value = Volume.From(1, VolumeUnit.ImperialGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithImperialOunceAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; - Volume value = Volume.From(1, VolumeUnit.ImperialOunce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; + Volume value = Volume.From(1, VolumeUnit.ImperialOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithLiterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Liter; - Volume value = Volume.From(1, VolumeUnit.Liter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Liter; + Volume value = Volume.From(1, VolumeUnit.Liter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMetricCupAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; - Volume value = Volume.From(1, VolumeUnit.MetricCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; + Volume value = Volume.From(1, VolumeUnit.MetricCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; - Volume value = Volume.From(1, VolumeUnit.Milliliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; + Volume value = Volume.From(1, VolumeUnit.Milliliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTablespoonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; - Volume value = Volume.From(1, VolumeUnit.Tablespoon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; + Volume value = Volume.From(1, VolumeUnit.Tablespoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTeaspoonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; - Volume value = Volume.From(1, VolumeUnit.Teaspoon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; + Volume value = Volume.From(1, VolumeUnit.Teaspoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsCustomaryCupAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; - Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; + Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsGallonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; - Volume value = Volume.From(1, VolumeUnit.UsGallon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; + Volume value = Volume.From(1, VolumeUnit.UsGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsLegalCupAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; - Volume value = Volume.From(1, VolumeUnit.UsLegalCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; + Volume value = Volume.From(1, VolumeUnit.UsLegalCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsOunceAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; - Volume value = Volume.From(1, VolumeUnit.UsOunce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; + Volume value = Volume.From(1, VolumeUnit.UsOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index a06a50c8ed..d713e155ef 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -198,23 +198,23 @@ namespace UnitsNet.Tests [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); + $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); string $($baseUnitVariableName)String = $($baseUnitVariableName).ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); } "@; foreach ($unit in $units) {@" [Test] public void ToStringReturnsCorrectNumberAndUnitWith$($unit.SingularName)AsDefualtUnit() { - $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; - $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); - $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); - $($className).ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; + $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); + $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); + $($className).ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } "@; }@" From 43a1678c25f1f3b65d6f81bb52c8bd2977648233 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Oveg=C3=A5rd?= Date: Wed, 10 Feb 2016 09:23:41 +0100 Subject: [PATCH 3/8] More spaces/tabs --- UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs | 2 +- .../GeneratedCode/TemperatureChangeRateTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs | 2 +- UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Density.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Information.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Length.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs | 4 ++-- UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 | 4 ++-- .../Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 | 2 +- 70 files changed, 105 insertions(+), 105 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index 64a55c7a36..ab31ca1de3 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -200,7 +200,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(meterpersecondsquared.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 7b1e0f98f7..95b2068752 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -180,7 +180,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decibelvolt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index 0f87ed1012..71bf47907c 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(degree.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Angle.ToStringDefaultUnit = AngleUnit.Degree; diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index 726f92662a..d3e00fa9d2 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(squaremeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Area.ToStringDefaultUnit = AreaUnit.SquareMeter; diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 20e56e7575..bf3a59d9e3 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 64e708efc6..27347daa39 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(second.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Duration.ToStringDefaultUnit = DurationUnit.Second; diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 6d31f8d7ab..7f94115d0b 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -194,7 +194,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(ampere.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 6afa40eff5..8ff908da0a 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -188,7 +188,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(volt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index 178f200425..c14e0e43bc 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -176,7 +176,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(ohm.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index 54736583f4..3f26d3abe3 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -236,7 +236,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(joule.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Energy.ToStringDefaultUnit = EnergyUnit.Joule; diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 4520a3c16a..2c7f5d4308 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -194,7 +194,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(cubicmeterpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index 7ec1831d92..ff2747f64a 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -164,7 +164,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newtonpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 6483856b69..4d7445604e 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newton.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Force.ToStringDefaultUnit = ForceUnit.Newton; diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index 43b35a8281..d10b68778c 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(hertz.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index 2122a37be7..3fee97a04e 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -314,7 +314,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(bit.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Information.ToStringDefaultUnit = InformationUnit.Bit; diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 9691724f1f..1c9476bff4 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(squaremeterpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index c30884f5de..0f8b20de2e 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -242,7 +242,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(meter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Length.ToStringDefaultUnit = LengthUnit.Meter; diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index 95d04f1d68..0d8ddee27e 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -174,7 +174,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decibel.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Level.ToStringDefaultUnit = LevelUnit.Decibel; diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 266565f986..5899d94b1c 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(grampersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index f4a67d074e..a439829b6f 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -260,7 +260,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(kilogram.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Mass.ToStringDefaultUnit = MassUnit.Kilogram; diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index 931ec7f1bc..0b043b1eeb 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -174,7 +174,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decibelwatt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 368d21be22..c3f1ac1490 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -254,7 +254,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(watt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Power.ToStringDefaultUnit = PowerUnit.Watt; diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index e7e3733c2d..2690b00c01 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -182,7 +182,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(pascalpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index 864c8a2902..c5cb303c56 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -356,7 +356,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(pascal.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Pressure.ToStringDefaultUnit = PressureUnit.Pascal; diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index d024d2556d..b44ed6fc54 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -194,7 +194,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decimalfraction.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index be50210e62..c10f65f14a 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(radianpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 9002584536..c99bc3cc49 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(jouleperkilogram.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 2cc5278d59..ba994878eb 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -254,7 +254,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newtonpercubicmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 27d9dd232a..6c19e0ba22 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -230,7 +230,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(meterpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index b5f32c853c..82eaad3f4f 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -212,7 +212,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 02c32c313f..03c910379b 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(kelvin.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 7552313201..6e772f465f 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -254,7 +254,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newtonmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index 7eae28d304..f46f5b4f89 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -164,7 +164,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(internationalunit.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index ab1aedc8bb..746ad26174 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -296,7 +296,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(cubicmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index 06cb9a0466..1f693b5a27 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -473,10 +473,10 @@ public static AccelerationUnit ParseUnit(string str, IFormatProvider formatProvi #endregion - /// + /// /// Set the default unit used by ToString(). Default is MeterPerSecondSquared /// - public static AccelerationUnit ToStringDefaultUnit { get; set; } = AccelerationUnit.MeterPerSecondSquared; + public static AccelerationUnit ToStringDefaultUnit { get; set; } = AccelerationUnit.MeterPerSecondSquared; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index 3345a69d0e..665f7932cb 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -401,10 +401,10 @@ public static AmplitudeRatioUnit ParseUnit(string str, IFormatProvider formatPro #endregion - /// + /// /// Set the default unit used by ToString(). Default is DecibelVolt /// - public static AmplitudeRatioUnit ToStringDefaultUnit { get; set; } = AmplitudeRatioUnit.DecibelVolt; + public static AmplitudeRatioUnit ToStringDefaultUnit { get; set; } = AmplitudeRatioUnit.DecibelVolt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index 77cff19645..0cc5293fae 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -533,10 +533,10 @@ public static AngleUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Degree /// - public static AngleUnit ToStringDefaultUnit { get; set; } = AngleUnit.Degree; + public static AngleUnit ToStringDefaultUnit { get; set; } = AngleUnit.Degree; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index 5e08fe1eae..8ae5edfda5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -533,10 +533,10 @@ public static AreaUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion - /// + /// /// Set the default unit used by ToString(). Default is SquareMeter /// - public static AreaUnit ToStringDefaultUnit { get; set; } = AreaUnit.SquareMeter; + public static AreaUnit ToStringDefaultUnit { get; set; } = AreaUnit.SquareMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 69041d5b2c..842783bed7 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -533,10 +533,10 @@ public static DensityUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is KilogramPerCubicMeter /// - public static DensityUnit ToStringDefaultUnit { get; set; } = DensityUnit.KilogramPerCubicMeter; + public static DensityUnit ToStringDefaultUnit { get; set; } = DensityUnit.KilogramPerCubicMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index ca0fe56f2e..5734d29371 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -533,10 +533,10 @@ public static DurationUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is Second /// - public static DurationUnit ToStringDefaultUnit { get; set; } = DurationUnit.Second; + public static DurationUnit ToStringDefaultUnit { get; set; } = DurationUnit.Second; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index a619d6e0f1..b27d9ed508 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -453,10 +453,10 @@ public static ElectricCurrentUnit ParseUnit(string str, IFormatProvider formatPr #endregion - /// + /// /// Set the default unit used by ToString(). Default is Ampere /// - public static ElectricCurrentUnit ToStringDefaultUnit { get; set; } = ElectricCurrentUnit.Ampere; + public static ElectricCurrentUnit ToStringDefaultUnit { get; set; } = ElectricCurrentUnit.Ampere; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index d13104076a..2697432f2b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -433,10 +433,10 @@ public static ElectricPotentialUnit ParseUnit(string str, IFormatProvider format #endregion - /// + /// /// Set the default unit used by ToString(). Default is Volt /// - public static ElectricPotentialUnit ToStringDefaultUnit { get; set; } = ElectricPotentialUnit.Volt; + public static ElectricPotentialUnit ToStringDefaultUnit { get; set; } = ElectricPotentialUnit.Volt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index 7eefaddba2..c7f4dbb522 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -393,10 +393,10 @@ public static ElectricResistanceUnit ParseUnit(string str, IFormatProvider forma #endregion - /// + /// /// Set the default unit used by ToString(). Default is Ohm /// - public static ElectricResistanceUnit ToStringDefaultUnit { get; set; } = ElectricResistanceUnit.Ohm; + public static ElectricResistanceUnit ToStringDefaultUnit { get; set; } = ElectricResistanceUnit.Ohm; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index 83f057350d..91d0404698 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -593,10 +593,10 @@ public static EnergyUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is Joule /// - public static EnergyUnit ToStringDefaultUnit { get; set; } = EnergyUnit.Joule; + public static EnergyUnit ToStringDefaultUnit { get; set; } = EnergyUnit.Joule; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index d06971cdad..fa590a1243 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -453,10 +453,10 @@ public static FlowUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion - /// + /// /// Set the default unit used by ToString(). Default is CubicMeterPerSecond /// - public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond; + public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index 42df19cd1a..4e84c3aaf2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -493,10 +493,10 @@ public static ForceUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Newton /// - public static ForceUnit ToStringDefaultUnit { get; set; } = ForceUnit.Newton; + public static ForceUnit ToStringDefaultUnit { get; set; } = ForceUnit.Newton; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 3e2a1c5407..3f7d44cb17 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -353,10 +353,10 @@ public static ForceChangeRateUnit ParseUnit(string str, IFormatProvider formatPr #endregion - /// + /// /// Set the default unit used by ToString(). Default is NewtonPerSecond /// - public static ForceChangeRateUnit ToStringDefaultUnit { get; set; } = ForceChangeRateUnit.NewtonPerSecond; + public static ForceChangeRateUnit ToStringDefaultUnit { get; set; } = ForceChangeRateUnit.NewtonPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index d4cfba4764..4110be7e44 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -493,10 +493,10 @@ public static FrequencyUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is Hertz /// - public static FrequencyUnit ToStringDefaultUnit { get; set; } = FrequencyUnit.Hertz; + public static FrequencyUnit ToStringDefaultUnit { get; set; } = FrequencyUnit.Hertz; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index df44df560b..dca8726316 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -853,10 +853,10 @@ public static InformationUnit ParseUnit(string str, IFormatProvider formatProvid #endregion - /// + /// /// Set the default unit used by ToString(). Default is Bit /// - public static InformationUnit ToStringDefaultUnit { get; set; } = InformationUnit.Bit; + public static InformationUnit ToStringDefaultUnit { get; set; } = InformationUnit.Bit; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index a040344585..1f797d8697 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -493,10 +493,10 @@ public static KinematicViscosityUnit ParseUnit(string str, IFormatProvider forma #endregion - /// + /// /// Set the default unit used by ToString(). Default is SquareMeterPerSecond /// - public static KinematicViscosityUnit ToStringDefaultUnit { get; set; } = KinematicViscosityUnit.SquareMeterPerSecond; + public static KinematicViscosityUnit ToStringDefaultUnit { get; set; } = KinematicViscosityUnit.SquareMeterPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index 9ba7456ce1..04b1c8f347 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -613,10 +613,10 @@ public static LengthUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is Meter /// - public static LengthUnit ToStringDefaultUnit { get; set; } = LengthUnit.Meter; + public static LengthUnit ToStringDefaultUnit { get; set; } = LengthUnit.Meter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index bd586733b5..7138756d94 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -381,10 +381,10 @@ public static LevelUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Decibel /// - public static LevelUnit ToStringDefaultUnit { get; set; } = LevelUnit.Decibel; + public static LevelUnit ToStringDefaultUnit { get; set; } = LevelUnit.Decibel; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index cf38e8ac32..f224a1d60a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -673,10 +673,10 @@ public static MassUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion - /// + /// /// Set the default unit used by ToString(). Default is Kilogram /// - public static MassUnit ToStringDefaultUnit { get; set; } = MassUnit.Kilogram; + public static MassUnit ToStringDefaultUnit { get; set; } = MassUnit.Kilogram; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index c2b7ed351f..79ea970d28 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -533,10 +533,10 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is GramPerSecond /// - public static MassFlowUnit ToStringDefaultUnit { get; set; } = MassFlowUnit.GramPerSecond; + public static MassFlowUnit ToStringDefaultUnit { get; set; } = MassFlowUnit.GramPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index 2e26e468b5..a23d1db5f2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -653,10 +653,10 @@ public static PowerUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Watt /// - public static PowerUnit ToStringDefaultUnit { get; set; } = PowerUnit.Watt; + public static PowerUnit ToStringDefaultUnit { get; set; } = PowerUnit.Watt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index f1dba52587..e74ad6ff08 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -381,10 +381,10 @@ public static PowerRatioUnit ParseUnit(string str, IFormatProvider formatProvide #endregion - /// + /// /// Set the default unit used by ToString(). Default is DecibelWatt /// - public static PowerRatioUnit ToStringDefaultUnit { get; set; } = PowerRatioUnit.DecibelWatt; + public static PowerRatioUnit ToStringDefaultUnit { get; set; } = PowerRatioUnit.DecibelWatt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index 949192870a..88057cb0e3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -993,10 +993,10 @@ public static PressureUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is Pascal /// - public static PressureUnit ToStringDefaultUnit { get; set; } = PressureUnit.Pascal; + public static PressureUnit ToStringDefaultUnit { get; set; } = PressureUnit.Pascal; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index 6364253e19..13cc2bde4a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -413,10 +413,10 @@ public static PressureChangeRateUnit ParseUnit(string str, IFormatProvider forma #endregion - /// + /// /// Set the default unit used by ToString(). Default is PascalPerSecond /// - public static PressureChangeRateUnit ToStringDefaultUnit { get; set; } = PressureChangeRateUnit.PascalPerSecond; + public static PressureChangeRateUnit ToStringDefaultUnit { get; set; } = PressureChangeRateUnit.PascalPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index 0726b77d77..00db256403 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -453,10 +453,10 @@ public static RatioUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is DecimalFraction /// - public static RatioUnit ToStringDefaultUnit { get; set; } = RatioUnit.DecimalFraction; + public static RatioUnit ToStringDefaultUnit { get; set; } = RatioUnit.DecimalFraction; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 951908a271..f818695f20 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -493,10 +493,10 @@ public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider formatPr #endregion - /// + /// /// Set the default unit used by ToString(). Default is RadianPerSecond /// - public static RotationalSpeedUnit ToStringDefaultUnit { get; set; } = RotationalSpeedUnit.RadianPerSecond; + public static RotationalSpeedUnit ToStringDefaultUnit { get; set; } = RotationalSpeedUnit.RadianPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index 38672dd739..1c28a48375 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -493,10 +493,10 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatPro #endregion - /// + /// /// Set the default unit used by ToString(). Default is JoulePerKilogram /// - public static SpecificEnergyUnit ToStringDefaultUnit { get; set; } = SpecificEnergyUnit.JoulePerKilogram; + public static SpecificEnergyUnit ToStringDefaultUnit { get; set; } = SpecificEnergyUnit.JoulePerKilogram; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index f3704b9d1e..77901424d9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -653,10 +653,10 @@ public static SpecificWeightUnit ParseUnit(string str, IFormatProvider formatPro #endregion - /// + /// /// Set the default unit used by ToString(). Default is NewtonPerCubicMeter /// - public static SpecificWeightUnit ToStringDefaultUnit { get; set; } = SpecificWeightUnit.NewtonPerCubicMeter; + public static SpecificWeightUnit ToStringDefaultUnit { get; set; } = SpecificWeightUnit.NewtonPerCubicMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index c916efaaec..989ae5eaba 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -573,10 +573,10 @@ public static SpeedUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is MeterPerSecond /// - public static SpeedUnit ToStringDefaultUnit { get; set; } = SpeedUnit.MeterPerSecond; + public static SpeedUnit ToStringDefaultUnit { get; set; } = SpeedUnit.MeterPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index 7d3100c67c..c6e437c5b4 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -493,10 +493,10 @@ public static TemperatureUnit ParseUnit(string str, IFormatProvider formatProvid #endregion - /// + /// /// Set the default unit used by ToString(). Default is Kelvin /// - public static TemperatureUnit ToStringDefaultUnit { get; set; } = TemperatureUnit.Kelvin; + public static TemperatureUnit ToStringDefaultUnit { get; set; } = TemperatureUnit.Kelvin; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index 97f3d3114b..798bd9bc70 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -513,10 +513,10 @@ public static TemperatureChangeRateUnit ParseUnit(string str, IFormatProvider fo #endregion - /// + /// /// Set the default unit used by ToString(). Default is DegreeCelsiusPerSecond /// - public static TemperatureChangeRateUnit ToStringDefaultUnit { get; set; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + public static TemperatureChangeRateUnit ToStringDefaultUnit { get; set; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index e40b44e8a7..63a0344b56 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -653,10 +653,10 @@ public static TorqueUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is NewtonMeter /// - public static TorqueUnit ToStringDefaultUnit { get; set; } = TorqueUnit.NewtonMeter; + public static TorqueUnit ToStringDefaultUnit { get; set; } = TorqueUnit.NewtonMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 0366d7d3a0..6521795793 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -353,10 +353,10 @@ public static VitaminAUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is InternationalUnit /// - public static VitaminAUnit ToStringDefaultUnit { get; set; } = VitaminAUnit.InternationalUnit; + public static VitaminAUnit ToStringDefaultUnit { get; set; } = VitaminAUnit.InternationalUnit; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index 6e89da74e6..34992ab083 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -793,10 +793,10 @@ public static VolumeUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is CubicMeter /// - public static VolumeUnit ToStringDefaultUnit { get; set; } = VolumeUnit.CubicMeter; + public static VolumeUnit ToStringDefaultUnit { get; set; } = VolumeUnit.CubicMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index b236401c44..3e0bfb2d69 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -386,10 +386,10 @@ namespace UnitsNet #endregion - /// + /// /// Set the default unit used by ToString(). Default is $baseUnitSingularName /// - public static $unitEnumName ToStringDefaultUnit { get; set; } = $unitEnumName.$baseUnitSingularName; + public static $unitEnumName ToStringDefaultUnit { get; set; } = $unitEnumName.$baseUnitSingularName; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index d713e155ef..d6a8f60550 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -195,7 +195,7 @@ namespace UnitsNet.Tests Assert.IsFalse($baseUnitVariableName.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); From 68e67b2eccb0dcabd0bddc76335452532cff6ad7 Mon Sep 17 00:00:00 2001 From: tongbong Date: Wed, 10 Feb 2016 12:45:43 +0100 Subject: [PATCH 4/8] Add cubic micrometer unit --- UnitsNet.Tests/CustomCode/VolumeTests.cs | 2 ++ .../GeneratedCode/VolumeTestsBase.g.cs | 6 +++++ UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs | 1 + .../GeneratedCode/UnitClasses/Volume.g.cs | 20 ++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 6 +++++ UnitsNet/Scripts/UnitDefinitions/Volume.json | 24 +++++++++++++++---- 6 files changed, 55 insertions(+), 4 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs index 9d20fde52a..241889b9ab 100644 --- a/UnitsNet.Tests/CustomCode/VolumeTests.cs +++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs @@ -43,6 +43,8 @@ public class VolumeTests : VolumeTestsBase protected override double CubicMillimetersInOneCubicMeter => 1E9; + protected override double CubicMicrometersInOneCubicMeter => 1E18; + protected override double CubicYardsInOneCubicMeter => 1.30795062; protected override double DecilitersInOneCubicMeter => 1E4; diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 97a0f13a8b..ff47f26b60 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -43,6 +43,7 @@ public abstract partial class VolumeTestsBase protected abstract double CubicInchesInOneCubicMeter { get; } protected abstract double CubicKilometersInOneCubicMeter { get; } protected abstract double CubicMetersInOneCubicMeter { get; } + protected abstract double CubicMicrometersInOneCubicMeter { get; } protected abstract double CubicMilesInOneCubicMeter { get; } protected abstract double CubicMillimetersInOneCubicMeter { get; } protected abstract double CubicYardsInOneCubicMeter { get; } @@ -68,6 +69,7 @@ public abstract partial class VolumeTestsBase protected virtual double CubicInchesTolerance { get { return 1e-5; } } protected virtual double CubicKilometersTolerance { get { return 1e-5; } } protected virtual double CubicMetersTolerance { get { return 1e-5; } } + protected virtual double CubicMicrometersTolerance { get { return 1e-5; } } protected virtual double CubicMilesTolerance { get { return 1e-5; } } protected virtual double CubicMillimetersTolerance { get { return 1e-5; } } protected virtual double CubicYardsTolerance { get { return 1e-5; } } @@ -97,6 +99,7 @@ public void CubicMeterToVolumeUnits() Assert.AreEqual(CubicInchesInOneCubicMeter, cubicmeter.CubicInches, CubicInchesTolerance); Assert.AreEqual(CubicKilometersInOneCubicMeter, cubicmeter.CubicKilometers, CubicKilometersTolerance); Assert.AreEqual(CubicMetersInOneCubicMeter, cubicmeter.CubicMeters, CubicMetersTolerance); + Assert.AreEqual(CubicMicrometersInOneCubicMeter, cubicmeter.CubicMicrometers, CubicMicrometersTolerance); Assert.AreEqual(CubicMilesInOneCubicMeter, cubicmeter.CubicMiles, CubicMilesTolerance); Assert.AreEqual(CubicMillimetersInOneCubicMeter, cubicmeter.CubicMillimeters, CubicMillimetersTolerance); Assert.AreEqual(CubicYardsInOneCubicMeter, cubicmeter.CubicYards, CubicYardsTolerance); @@ -125,6 +128,7 @@ public void FromValueAndUnit() Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicInch).CubicInches, CubicInchesTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicKilometer).CubicKilometers, CubicKilometersTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicMeter).CubicMeters, CubicMetersTolerance); + Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicMicrometer).CubicMicrometers, CubicMicrometersTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicMile).CubicMiles, CubicMilesTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicMillimeter).CubicMillimeters, CubicMillimetersTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.CubicYard).CubicYards, CubicYardsTolerance); @@ -154,6 +158,7 @@ public void As() Assert.AreEqual(CubicInchesInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicInch), CubicInchesTolerance); Assert.AreEqual(CubicKilometersInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicKilometer), CubicKilometersTolerance); Assert.AreEqual(CubicMetersInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicMeter), CubicMetersTolerance); + Assert.AreEqual(CubicMicrometersInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicMicrometer), CubicMicrometersTolerance); Assert.AreEqual(CubicMilesInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicMile), CubicMilesTolerance); Assert.AreEqual(CubicMillimetersInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicMillimeter), CubicMillimetersTolerance); Assert.AreEqual(CubicYardsInOneCubicMeter, cubicmeter.As(VolumeUnit.CubicYard), CubicYardsTolerance); @@ -183,6 +188,7 @@ public void ConversionRoundTrip() Assert.AreEqual(1, Volume.FromCubicInches(cubicmeter.CubicInches).CubicMeters, CubicInchesTolerance); Assert.AreEqual(1, Volume.FromCubicKilometers(cubicmeter.CubicKilometers).CubicMeters, CubicKilometersTolerance); Assert.AreEqual(1, Volume.FromCubicMeters(cubicmeter.CubicMeters).CubicMeters, CubicMetersTolerance); + Assert.AreEqual(1, Volume.FromCubicMicrometers(cubicmeter.CubicMicrometers).CubicMeters, CubicMicrometersTolerance); Assert.AreEqual(1, Volume.FromCubicMiles(cubicmeter.CubicMiles).CubicMeters, CubicMilesTolerance); Assert.AreEqual(1, Volume.FromCubicMillimeters(cubicmeter.CubicMillimeters).CubicMeters, CubicMillimetersTolerance); Assert.AreEqual(1, Volume.FromCubicYards(cubicmeter.CubicYards).CubicMeters, CubicYardsTolerance); diff --git a/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs b/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs index 36e409a7d3..16741221c6 100644 --- a/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs @@ -32,6 +32,7 @@ public enum VolumeUnit CubicInch, CubicKilometer, CubicMeter, + CubicMicrometer, CubicMile, CubicMillimeter, CubicYard, diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index 53d824909f..d2fc288bff 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -110,6 +110,14 @@ public double CubicMeters get { return _cubicMeters; } } + /// + /// Get Volume in CubicMicrometers. + /// + public double CubicMicrometers + { + get { return _cubicMeters*1e18; } + } + /// /// Get Volume in CubicMiles. /// @@ -303,6 +311,14 @@ public static Volume FromCubicMeters(double cubicmeters) return new Volume(cubicmeters); } + /// + /// Get Volume from CubicMicrometers. + /// + public static Volume FromCubicMicrometers(double cubicmicrometers) + { + return new Volume(cubicmicrometers/1e18); + } + /// /// Get Volume from CubicMiles. /// @@ -456,6 +472,8 @@ public static Volume From(double value, VolumeUnit fromUnit) return FromCubicKilometers(value); case VolumeUnit.CubicMeter: return FromCubicMeters(value); + case VolumeUnit.CubicMicrometer: + return FromCubicMicrometers(value); case VolumeUnit.CubicMile: return FromCubicMiles(value); case VolumeUnit.CubicMillimeter: @@ -635,6 +653,8 @@ public double As(VolumeUnit unit) return CubicKilometers; case VolumeUnit.CubicMeter: return CubicMeters; + case VolumeUnit.CubicMicrometer: + return CubicMicrometers; case VolumeUnit.CubicMile: return CubicMiles; case VolumeUnit.CubicMillimeter: diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 34f44e565c..36d0f6fe45 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1911,6 +1911,12 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "m³"), new AbbreviationsForCulture("ru-RU", "м³"), }), + new CulturesForEnumValue((int) VolumeUnit.CubicMicrometer, + new[] + { + new AbbreviationsForCulture("en-US", "µm³"), + new AbbreviationsForCulture("ru-RU", "мкм³"), + }), new CulturesForEnumValue((int) VolumeUnit.CubicMile, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/Volume.json b/UnitsNet/Scripts/UnitDefinitions/Volume.json index 2f191efcb9..f1a49ec419 100644 --- a/UnitsNet/Scripts/UnitDefinitions/Volume.json +++ b/UnitsNet/Scripts/UnitDefinitions/Volume.json @@ -101,6 +101,22 @@ } ] }, + { + "SingularName": "CubicMicrometer", + "PluralName": "CubicMicrometers", + "FromUnitToBaseFunc": "x/1e18", + "FromBaseToUnitFunc": "x*1e18", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": ["µm³"] + }, + { + "Culture": "ru-RU", + "Abbreviations": ["мкм³"] + } + ] + }, { "SingularName": "CubicMile", "PluralName": "CubicMiles", @@ -287,10 +303,10 @@ "FromUnitToBaseFunc": "x*0.0002365882365", "FromBaseToUnitFunc": "x/0.0002365882365", "Localization": [ - { - "Culture": "en-US", - "Abbreviations": [] - } + { + "Culture": "en-US", + "Abbreviations": [ ] + } ] }, { From 344dfa5820b9672d3b7b3e4cdd11a9935651023d Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Sun, 7 Feb 2016 14:30:05 +0100 Subject: [PATCH 5/8] Added ToStringDefaultUnit to enable custom units for ToString(). --- .../GeneratedCode/AccelerationTestsBase.g.cs | 94 ++++ .../AmplitudeRatioTestsBase.g.cs | 46 ++ .../GeneratedCode/AngleTestsBase.g.cs | 130 ++++++ .../GeneratedCode/AreaTestsBase.g.cs | 130 ++++++ .../GeneratedCode/DensityTestsBase.g.cs | 130 ++++++ .../GeneratedCode/DurationTestsBase.g.cs | 130 ++++++ .../ElectricCurrentTestsBase.g.cs | 82 ++++ .../ElectricPotentialTestsBase.g.cs | 70 +++ .../ElectricResistanceTestsBase.g.cs | 46 ++ .../GeneratedCode/EnergyTestsBase.g.cs | 166 +++++++ .../GeneratedCode/FlowTestsBase.g.cs | 82 ++++ .../ForceChangeRateTestsBase.g.cs | 22 + .../GeneratedCode/ForceTestsBase.g.cs | 106 +++++ .../GeneratedCode/FrequencyTestsBase.g.cs | 106 +++++ .../GeneratedCode/InformationTestsBase.g.cs | 322 ++++++++++++++ .../KinematicViscosityTestsBase.g.cs | 106 +++++ .../GeneratedCode/LengthTestsBase.g.cs | 178 ++++++++ .../GeneratedCode/LevelTestsBase.g.cs | 34 ++ .../GeneratedCode/MassFlowTestsBase.g.cs | 130 ++++++ .../GeneratedCode/MassTestsBase.g.cs | 214 +++++++++ .../GeneratedCode/PowerRatioTestsBase.g.cs | 34 ++ .../GeneratedCode/PowerTestsBase.g.cs | 202 +++++++++ .../PressureChangeRateTestsBase.g.cs | 58 +++ .../GeneratedCode/PressureTestsBase.g.cs | 406 ++++++++++++++++++ .../GeneratedCode/RatioTestsBase.g.cs | 82 ++++ .../RotationalSpeedTestsBase.g.cs | 106 +++++ .../SpecificEnergyTestsBase.g.cs | 106 +++++ .../SpecificWeightTestsBase.g.cs | 202 +++++++++ .../GeneratedCode/SpeedTestsBase.g.cs | 154 +++++++ .../TemperatureChangeRateTestsBase.g.cs | 118 +++++ .../GeneratedCode/TemperatureTestsBase.g.cs | 106 +++++ .../GeneratedCode/TorqueTestsBase.g.cs | 202 +++++++++ .../GeneratedCode/VitaminATestsBase.g.cs | 22 + .../GeneratedCode/VolumeTestsBase.g.cs | 286 ++++++++++++ .../UnitClasses/Acceleration.g.cs | 7 +- .../UnitClasses/AmplitudeRatio.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 7 +- .../GeneratedCode/UnitClasses/Density.g.cs | 7 +- .../GeneratedCode/UnitClasses/Duration.g.cs | 7 +- .../UnitClasses/ElectricCurrent.g.cs | 7 +- .../UnitClasses/ElectricPotential.g.cs | 7 +- .../UnitClasses/ElectricResistance.g.cs | 7 +- .../GeneratedCode/UnitClasses/Energy.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 7 +- .../UnitClasses/ForceChangeRate.g.cs | 7 +- .../GeneratedCode/UnitClasses/Frequency.g.cs | 7 +- .../UnitClasses/Information.g.cs | 7 +- .../UnitClasses/KinematicViscosity.g.cs | 7 +- .../GeneratedCode/UnitClasses/Length.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 7 +- .../GeneratedCode/UnitClasses/MassFlow.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 7 +- .../GeneratedCode/UnitClasses/PowerRatio.g.cs | 7 +- .../GeneratedCode/UnitClasses/Pressure.g.cs | 7 +- .../UnitClasses/PressureChangeRate.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 7 +- .../UnitClasses/RotationalSpeed.g.cs | 7 +- .../UnitClasses/SpecificEnergy.g.cs | 7 +- .../UnitClasses/SpecificWeight.g.cs | 7 +- UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 7 +- .../UnitClasses/Temperature.g.cs | 7 +- .../UnitClasses/TemperatureChangeRate.g.cs | 7 +- .../GeneratedCode/UnitClasses/Torque.g.cs | 7 +- .../GeneratedCode/UnitClasses/VitaminA.g.cs | 7 +- .../GeneratedCode/UnitClasses/Volume.g.cs | 7 +- .../Include-GenerateUnitClassSourceCode.ps1 | 7 +- ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 24 ++ 70 files changed, 4642 insertions(+), 35 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index e55a0044a4..dc355038bf 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -199,5 +199,99 @@ public void EqualsReturnsFalseOnNull() Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); Assert.IsFalse(meterpersecondsquared.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); + string meterpersecondsquaredString = meterpersecondsquared.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondSquaredAsDefualtUnit() + { + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 786dcee38d..c4f7fe5f29 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -179,5 +179,51 @@ public void EqualsReturnsFalseOnNull() AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); Assert.IsFalse(decibelvolt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); + string decibelvoltString = decibelvolt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelMicrovoltAsDefualtUnit() + { + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelMillivoltAsDefualtUnit() + { + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelVoltAsDefualtUnit() + { + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index d330008fcc..da49a60e5b 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Angle degree = Angle.FromDegrees(1); Assert.IsFalse(degree.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle degree = Angle.FromDegrees(1); + string degreeString = degree.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithArcminuteAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcminute; + Angle value = Angle.From(1, AngleUnit.Arcminute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithArcsecondAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; + Angle value = Angle.From(1, AngleUnit.Arcsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentiradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Centiradian; + Angle value = Angle.From(1, AngleUnit.Centiradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDeciradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Deciradian; + Angle value = Angle.From(1, AngleUnit.Deciradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle value = Angle.From(1, AngleUnit.Degree); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Gradian; + Angle value = Angle.From(1, AngleUnit.Gradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Microradian; + Angle value = Angle.From(1, AngleUnit.Microradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Milliradian; + Angle value = Angle.From(1, AngleUnit.Milliradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanoradianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; + Angle value = Angle.From(1, AngleUnit.Nanoradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRadianAsDefualtUnit() + { + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Radian; + Angle value = Angle.From(1, AngleUnit.Radian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index ada71764bf..9215120cd9 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Area squaremeter = Area.FromSquareMeters(1); Assert.IsFalse(squaremeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area squaremeter = Area.FromSquareMeters(1); + string squaremeterString = squaremeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareCentimeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; + Area value = Area.From(1, AreaUnit.SquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareDecimeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; + Area value = Area.From(1, AreaUnit.SquareDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareFootAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareFoot; + Area value = Area.From(1, AreaUnit.SquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareInchAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareInch; + Area value = Area.From(1, AreaUnit.SquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareKilometerAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; + Area value = Area.From(1, AreaUnit.SquareKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area value = Area.From(1, AreaUnit.SquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMicrometerAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; + Area value = Area.From(1, AreaUnit.SquareMicrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMileAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMile; + Area value = Area.From(1, AreaUnit.SquareMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMillimeterAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; + Area value = Area.From(1, AreaUnit.SquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareYardAsDefualtUnit() + { + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareYard; + Area value = Area.From(1, AreaUnit.SquareYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 87a39ad9c6..68b54cb471 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); + string kilogrampercubicmeterString = kilogrampercubicmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicCentimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMillimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicFootAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicInchAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicFootAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicInchAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; + Density value = Density.From(1, DensityUnit.PoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicCentimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMillimeterAsDefualtUnit() + { + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 3b134a6b08..b148cc0940 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() Duration second = Duration.FromSeconds(1); Assert.IsFalse(second.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration second = Duration.FromSeconds(1); + string secondString = second.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDayAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Day; + Duration value = Duration.From(1, DurationUnit.Day); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHourAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Hour; + Duration value = Duration.From(1, DurationUnit.Hour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrosecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Microsecond; + Duration value = Duration.From(1, DurationUnit.Microsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillisecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Millisecond; + Duration value = Duration.From(1, DurationUnit.Millisecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMinuteAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Minute; + Duration value = Duration.From(1, DurationUnit.Minute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMonthAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Month; + Duration value = Duration.From(1, DurationUnit.Month); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanosecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; + Duration value = Duration.From(1, DurationUnit.Nanosecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSecondAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration value = Duration.From(1, DurationUnit.Second); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWeekAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Week; + Duration value = Duration.From(1, DurationUnit.Week); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithYearAsDefualtUnit() + { + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Year; + Duration value = Duration.From(1, DurationUnit.Year); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 52f03bd23f..264449f25d 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -193,5 +193,87 @@ public void EqualsReturnsFalseOnNull() ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); Assert.IsFalse(ampere.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); + string ampereString = ampere.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithAmpereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKiloampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegaampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanoampereAsDefualtUnit() + { + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 319f56cacc..c563008ac1 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -187,5 +187,75 @@ public void EqualsReturnsFalseOnNull() ElectricPotential volt = ElectricPotential.FromVolts(1); Assert.IsFalse(volt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential volt = ElectricPotential.FromVolts(1); + string voltString = volt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilovoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegavoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrovoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillivoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithVoltAsDefualtUnit() + { + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index a23d9028c1..8b926774db 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -175,5 +175,51 @@ public void EqualsReturnsFalseOnNull() ElectricResistance ohm = ElectricResistance.FromOhms(1); Assert.IsFalse(ohm.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance ohm = ElectricResistance.FromOhms(1); + string ohmString = ohm.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKiloohmAsDefualtUnit() + { + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegaohmAsDefualtUnit() + { + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithOhmAsDefualtUnit() + { + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index e23f86a521..baff65f537 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -235,5 +235,171 @@ public void EqualsReturnsFalseOnNull() Energy joule = Energy.FromJoules(1); Assert.IsFalse(joule.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy joule = Energy.FromJoules(1); + string jouleString = joule.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBritishThermalUnitAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; + Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCalorieAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Calorie; + Energy value = Energy.From(1, EnergyUnit.Calorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithElectronVoltAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; + Energy value = Energy.From(1, EnergyUnit.ElectronVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithErgAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Erg; + Energy value = Energy.From(1, EnergyUnit.Erg); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFootPoundAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.FootPound; + Energy value = Energy.From(1, EnergyUnit.FootPound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigawattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; + Energy value = Energy.From(1, EnergyUnit.GigawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithJouleAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy value = Energy.From(1, EnergyUnit.Joule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilocalorieAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; + Energy value = Energy.From(1, EnergyUnit.Kilocalorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilojouleAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; + Energy value = Energy.From(1, EnergyUnit.Kilojoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; + Energy value = Energy.From(1, EnergyUnit.KilowattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegajouleAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; + Energy value = Energy.From(1, EnergyUnit.Megajoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; + Energy value = Energy.From(1, EnergyUnit.MegawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWattHourAsDefualtUnit() + { + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.WattHour; + Energy value = Energy.From(1, EnergyUnit.WattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 8287346863..402e7fa9b0 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -193,5 +193,87 @@ public void EqualsReturnsFalseOnNull() Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); Assert.IsFalse(cubicmeterpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); + string cubicmeterpersecondString = cubicmeterpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicFootPerSecondAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerHourAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerSecondAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithLitersPerMinuteAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; + Flow value = Flow.From(1, FlowUnit.LitersPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillionUsGallonsPerDayAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; + Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsGallonsPerMinuteAsDefualtUnit() + { + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; + Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index c521f78f26..75abf80e3a 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -163,5 +163,27 @@ public void EqualsReturnsFalseOnNull() ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); Assert.IsFalse(newtonpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); + string newtonpersecondString = newtonpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSecondAsDefualtUnit() + { + ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); + ForceChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 94a60dbe77..3eba27b8b5 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() Force newton = Force.FromNewtons(1); Assert.IsFalse(newton.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Force.ToStringDefaultUnit = ForceUnit.Newton; + Force newton = Force.FromNewtons(1); + string newtonString = newton.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDynAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Dyn; + Force value = Force.From(1, ForceUnit.Dyn); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KilogramForce; + Force value = Force.From(1, ForceUnit.KilogramForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Kilonewton; + Force value = Force.From(1, ForceUnit.Kilonewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKiloPondAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KiloPond; + Force value = Force.From(1, ForceUnit.KiloPond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Newton; + Force value = Force.From(1, ForceUnit.Newton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundalAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Poundal; + Force value = Force.From(1, ForceUnit.Poundal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForceAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.PoundForce; + Force value = Force.From(1, ForceUnit.PoundForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceAsDefualtUnit() + { + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.TonneForce; + Force value = Force.From(1, ForceUnit.TonneForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index c01b961863..b1e65ce6d0 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() Frequency hertz = Frequency.FromHertz(1); Assert.IsFalse(hertz.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency hertz = Frequency.FromHertz(1); + string hertzString = hertz.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCyclePerHourAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCyclePerMinuteAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigahertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency value = Frequency.From(1, FrequencyUnit.Hertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilohertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; + Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegahertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; + Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerahertzAsDefualtUnit() + { + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index f740691f61..55a94856e8 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -313,5 +313,327 @@ public void EqualsReturnsFalseOnNull() Information bit = Information.FromBits(1); Assert.IsFalse(bit.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Information.ToStringDefaultUnit = InformationUnit.Bit; + Information bit = Information.FromBits(1); + string bitString = bit.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Bit; + Information value = Information.From(1, InformationUnit.Bit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithByteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Byte; + Information value = Information.From(1, InformationUnit.Byte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabit; + Information value = Information.From(1, InformationUnit.Exabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabyte; + Information value = Information.From(1, InformationUnit.Exabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExbibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibit; + Information value = Information.From(1, InformationUnit.Exbibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithExbibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibyte; + Information value = Information.From(1, InformationUnit.Exbibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGibibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibit; + Information value = Information.From(1, InformationUnit.Gibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGibibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibyte; + Information value = Information.From(1, InformationUnit.Gibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabit; + Information value = Information.From(1, InformationUnit.Gigabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabyte; + Information value = Information.From(1, InformationUnit.Gigabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKibibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibit; + Information value = Information.From(1, InformationUnit.Kibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKibibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibyte; + Information value = Information.From(1, InformationUnit.Kibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilobitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobit; + Information value = Information.From(1, InformationUnit.Kilobit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilobyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobyte; + Information value = Information.From(1, InformationUnit.Kilobyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMebibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibit; + Information value = Information.From(1, InformationUnit.Mebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMebibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibyte; + Information value = Information.From(1, InformationUnit.Mebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabit; + Information value = Information.From(1, InformationUnit.Megabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabyte; + Information value = Information.From(1, InformationUnit.Megabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPebibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibit; + Information value = Information.From(1, InformationUnit.Pebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPebibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibyte; + Information value = Information.From(1, InformationUnit.Pebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPetabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabit; + Information value = Information.From(1, InformationUnit.Petabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPetabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabyte; + Information value = Information.From(1, InformationUnit.Petabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTebibitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibit; + Information value = Information.From(1, InformationUnit.Tebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTebibyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibyte; + Information value = Information.From(1, InformationUnit.Tebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerabitAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabit; + Information value = Information.From(1, InformationUnit.Terabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerabyteAsDefualtUnit() + { + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabyte; + Information value = Information.From(1, InformationUnit.Terabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index b22eb12e06..6bc405bf99 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); Assert.IsFalse(squaremeterpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); + string squaremeterpersecondString = squaremeterpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentistokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecistokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilostokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrostokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillistokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanostokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterPerSecondAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithStokesAsDefualtUnit() + { + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index a247b5798b..306d567680 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -241,5 +241,183 @@ public void EqualsReturnsFalseOnNull() Length meter = Length.FromMeters(1); Assert.IsFalse(meter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length meter = Length.FromMeters(1); + string meterString = meter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Centimeter; + Length value = Length.From(1, LengthUnit.Centimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Decimeter; + Length value = Length.From(1, LengthUnit.Decimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFootAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Foot; + Length value = Length.From(1, LengthUnit.Foot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithInchAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Inch; + Length value = Length.From(1, LengthUnit.Inch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Kilometer; + Length value = Length.From(1, LengthUnit.Kilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length value = Length.From(1, LengthUnit.Meter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroinchAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Microinch; + Length value = Length.From(1, LengthUnit.Microinch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrometerAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Micrometer; + Length value = Length.From(1, LengthUnit.Micrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mil; + Length value = Length.From(1, LengthUnit.Mil); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMileAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mile; + Length value = Length.From(1, LengthUnit.Mile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Millimeter; + Length value = Length.From(1, LengthUnit.Millimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanometerAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Nanometer; + Length value = Length.From(1, LengthUnit.Nanometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNauticalMileAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.NauticalMile; + Length value = Length.From(1, LengthUnit.NauticalMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithYardAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Yard; + Length value = Length.From(1, LengthUnit.Yard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index dac295d95d..3d77584013 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -173,5 +173,39 @@ public void EqualsReturnsFalseOnNull() Level decibel = Level.FromDecibels(1); Assert.IsFalse(decibel.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level decibel = Level.FromDecibels(1); + string decibelString = decibel.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelAsDefualtUnit() + { + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level value = Level.From(1, LevelUnit.Decibel); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNeperAsDefualtUnit() + { + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Neper; + Level value = Level.From(1, LevelUnit.Neper); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 583c7cf5dc..3f3d327b24 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -217,5 +217,135 @@ public void EqualsReturnsFalseOnNull() MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); Assert.IsFalse(grampersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); + string grampersecondString = grampersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentigramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecagramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecigramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilligramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanogramPerSecondAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonnePerDayAsDefualtUnit() + { + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; + MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 7775d245e0..417a214677 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -259,5 +259,219 @@ public void EqualsReturnsFalseOnNull() Mass kilogram = Mass.FromKilograms(1); Assert.IsFalse(kilogram.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass kilogram = Mass.FromKilograms(1); + string kilogramString = kilogram.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentigramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Centigram; + Mass value = Mass.From(1, MassUnit.Centigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecagramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decagram; + Mass value = Mass.From(1, MassUnit.Decagram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecigramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decigram; + Mass value = Mass.From(1, MassUnit.Decigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Gram; + Mass value = Mass.From(1, MassUnit.Gram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Hectogram; + Mass value = Mass.From(1, MassUnit.Hectogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass value = Mass.From(1, MassUnit.Kilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilotonneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilotonne; + Mass value = Mass.From(1, MassUnit.Kilotonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithLongTonAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.LongTon; + Mass value = Mass.From(1, MassUnit.LongTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegatonneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Megatonne; + Mass value = Mass.From(1, MassUnit.Megatonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Microgram; + Mass value = Mass.From(1, MassUnit.Microgram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilligramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Milligram; + Mass value = Mass.From(1, MassUnit.Milligram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanogramAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Nanogram; + Mass value = Mass.From(1, MassUnit.Nanogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithOunceAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Ounce; + Mass value = Mass.From(1, MassUnit.Ounce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Pound; + Mass value = Mass.From(1, MassUnit.Pound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithShortTonAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.ShortTon; + Mass value = Mass.From(1, MassUnit.ShortTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithStoneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Stone; + Mass value = Mass.From(1, MassUnit.Stone); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneAsDefualtUnit() + { + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Tonne; + Mass value = Mass.From(1, MassUnit.Tonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index 4c505d6c08..afc9c13bc4 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -173,5 +173,39 @@ public void EqualsReturnsFalseOnNull() PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); Assert.IsFalse(decibelwatt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); + string decibelwattString = decibelwatt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelMilliwattAsDefualtUnit() + { + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibelWattAsDefualtUnit() + { + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 221ceaf04f..a6323103b1 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -253,5 +253,207 @@ public void EqualsReturnsFalseOnNull() Power watt = Power.FromWatts(1); Assert.IsFalse(watt.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Power.ToStringDefaultUnit = PowerUnit.Watt; + Power watt = Power.FromWatts(1); + string wattString = watt.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBoilerHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; + Power value = Power.From(1, PowerUnit.BoilerHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithElectricalHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; + Power value = Power.From(1, PowerUnit.ElectricalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFemtowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Femtowatt; + Power value = Power.From(1, PowerUnit.Femtowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Gigawatt; + Power value = Power.From(1, PowerUnit.Gigawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHydraulicHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; + Power value = Power.From(1, PowerUnit.HydraulicHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Kilowatt; + Power value = Power.From(1, PowerUnit.Kilowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMechanicalHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; + Power value = Power.From(1, PowerUnit.MechanicalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Megawatt; + Power value = Power.From(1, PowerUnit.Megawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMetricHorsepowerAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; + Power value = Power.From(1, PowerUnit.MetricHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Microwatt; + Power value = Power.From(1, PowerUnit.Microwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliwattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Milliwatt; + Power value = Power.From(1, PowerUnit.Milliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Nanowatt; + Power value = Power.From(1, PowerUnit.Nanowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPetawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Petawatt; + Power value = Power.From(1, PowerUnit.Petawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPicowattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Picowatt; + Power value = Power.From(1, PowerUnit.Picowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTerawattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Terawatt; + Power value = Power.From(1, PowerUnit.Terawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWattAsDefualtUnit() + { + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Watt; + Power value = Power.From(1, PowerUnit.Watt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index f9200bb56a..317f0af622 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -181,5 +181,63 @@ public void EqualsReturnsFalseOnNull() PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); Assert.IsFalse(pascalpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); + string pascalpersecondString = pascalpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithAtmospherePerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopascalPerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegapascalPerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPascalPerSecondAsDefualtUnit() + { + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index cf3b489a71..93222d94bd 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -355,5 +355,411 @@ public void EqualsReturnsFalseOnNull() Pressure pascal = Pressure.FromPascals(1); Assert.IsFalse(pascal.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure pascal = Pressure.FromPascals(1); + string pascalString = pascal.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithAtmosphereAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; + Pressure value = Pressure.From(1, PressureUnit.Atmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithBarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Bar; + Pressure value = Pressure.From(1, PressureUnit.Bar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentibarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Centibar; + Pressure value = Pressure.From(1, PressureUnit.Centibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecapascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; + Pressure value = Pressure.From(1, PressureUnit.Decapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecibarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decibar; + Pressure value = Pressure.From(1, PressureUnit.Decibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithGigapascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; + Pressure value = Pressure.From(1, PressureUnit.Gigapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectopascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; + Pressure value = Pressure.From(1, PressureUnit.Hectopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilobarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; + Pressure value = Pressure.From(1, PressureUnit.Kilobar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; + Pressure value = Pressure.From(1, PressureUnit.Kilopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareFootAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareInchAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegabarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megabar; + Pressure value = Pressure.From(1, PressureUnit.Megabar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegapascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; + Pressure value = Pressure.From(1, PressureUnit.Megapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicropascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; + Pressure value = Pressure.From(1, PressureUnit.Micropascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillibarAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Millibar; + Pressure value = Pressure.From(1, PressureUnit.Millibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPascalAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure value = Pressure.From(1, PressureUnit.Pascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareFootAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareInchAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPsiAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Psi; + Pressure value = Pressure.From(1, PressureUnit.Psi); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTechnicalAtmosphereAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; + Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareCentimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMillimeterAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTorrAsDefualtUnit() + { + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Torr; + Pressure value = Pressure.From(1, PressureUnit.Torr); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 212682834e..27c96ca539 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -193,5 +193,87 @@ public void EqualsReturnsFalseOnNull() Ratio decimalfraction = Ratio.FromDecimalFractions(1); Assert.IsFalse(decimalfraction.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio decimalfraction = Ratio.FromDecimalFractions(1); + string decimalfractionString = decimalfraction.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimalFractionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerBillionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerMillionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerThousandAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; + Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPartPerTrillionAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPercentAsDefualtUnit() + { + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.Percent; + Ratio value = Ratio.From(1, RatioUnit.Percent); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 552412d898..0794eaa618 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.IsFalse(radianpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + string radianpersecondString = radianpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentiradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDeciradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicroradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanoradianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerMinuteAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerSecondAsDefualtUnit() + { + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 7a5ba37b27..0f81a0d72c 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); Assert.IsFalse(jouleperkilogram.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); + string jouleperkilogramString = jouleperkilogram.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCaloriePerGramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithJoulePerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilocaloriePerGramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilojoulePerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourPerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegajoulePerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourPerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithWattHourPerKilogramAsDefualtUnit() + { + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 52535a75d2..4f63508749 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -253,5 +253,207 @@ public void EqualsReturnsFalseOnNull() SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); Assert.IsFalse(newtonpercubicmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); + string newtonpercubicmeterString = newtonpercubicmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicFootAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicInchAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicFootAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicInchAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicCentimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMillimeterAsDefualtUnit() + { + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index c87c6c8bb8..77ff0ec620 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -229,5 +229,159 @@ public void EqualsReturnsFalseOnNull() Speed meterpersecond = Speed.FromMetersPerSecond(1); Assert.IsFalse(meterpersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed meterpersecond = Speed.FromMetersPerSecond(1); + string meterpersecondString = meterpersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithFootPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; + Speed value = Speed.From(1, SpeedUnit.FootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerHourAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; + Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKnotAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.Knot; + Speed value = Speed.From(1, SpeedUnit.Knot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterPerHourAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; + Speed value = Speed.From(1, SpeedUnit.MeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilePerHourAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; + Speed value = Speed.From(1, SpeedUnit.MilePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondAsDefualtUnit() + { + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index e5b1a8daf6..c826d257db 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -211,5 +211,123 @@ public void EqualsReturnsFalseOnNull() TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); + string degreecelsiuspersecondString = degreecelsiuspersecond.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentidegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecadegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDecidegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMicrodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMillidegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNanodegreeCelsiusPerSecondAsDefualtUnit() + { + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 874ea01916..2ef8499deb 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -205,5 +205,111 @@ public void EqualsReturnsFalseOnNull() Temperature kelvin = Temperature.FromKelvins(1); Assert.IsFalse(kelvin.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature kelvin = Temperature.FromKelvins(1); + string kelvinString = kelvin.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeDelisleAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeFahrenheitAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeNewtonAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeRankineAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeReaumurAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDegreeRoemerAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKelvinAsDefualtUnit() + { + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 8b7469ba75..e4dfc47607 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -253,5 +253,207 @@ public void EqualsReturnsFalseOnNull() Torque newtonmeter = Torque.FromNewtonMeters(1); Assert.IsFalse(newtonmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque newtonmeter = Torque.FromNewtonMeters(1); + string newtonmeterString = newtonmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceFootAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceInchAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithNewtonMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForceFootAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithPoundForceInchAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; + Torque value = Torque.From(1, TorqueUnit.PoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceCentimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMillimeterAsDefualtUnit() + { + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index f6c0f92814..bb33c97f20 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -163,5 +163,27 @@ public void EqualsReturnsFalseOnNull() VitaminA internationalunit = VitaminA.FromInternationalUnits(1); Assert.IsFalse(internationalunit.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA internationalunit = VitaminA.FromInternationalUnits(1); + string internationalunitString = internationalunit.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithInternationalUnitAsDefualtUnit() + { + VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); + VitaminA.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index ff47f26b60..3ebf75f253 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -301,5 +301,291 @@ public void EqualsReturnsFalseOnNull() Volume cubicmeter = Volume.FromCubicMeters(1); Assert.IsFalse(cubicmeter.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume cubicmeter = Volume.FromCubicMeters(1); + string cubicmeterString = cubicmeter.ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentiliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; + Volume value = Volume.From(1, VolumeUnit.Centiliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicCentimeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; + Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicDecimeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; + Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicFootAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; + Volume value = Volume.From(1, VolumeUnit.CubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicInchAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; + Volume value = Volume.From(1, VolumeUnit.CubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicKilometerAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; + Volume value = Volume.From(1, VolumeUnit.CubicKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume value = Volume.From(1, VolumeUnit.CubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMileAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; + Volume value = Volume.From(1, VolumeUnit.CubicMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicMillimeterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; + Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCubicYardAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; + Volume value = Volume.From(1, VolumeUnit.CubicYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDeciliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; + Volume value = Volume.From(1, VolumeUnit.Deciliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithHectoliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; + Volume value = Volume.From(1, VolumeUnit.Hectoliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithImperialGallonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; + Volume value = Volume.From(1, VolumeUnit.ImperialGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithImperialOunceAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; + Volume value = Volume.From(1, VolumeUnit.ImperialOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithLiterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Liter; + Volume value = Volume.From(1, VolumeUnit.Liter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMetricCupAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; + Volume value = Volume.From(1, VolumeUnit.MetricCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithMilliliterAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; + Volume value = Volume.From(1, VolumeUnit.Milliliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTablespoonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; + Volume value = Volume.From(1, VolumeUnit.Tablespoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithTeaspoonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; + Volume value = Volume.From(1, VolumeUnit.Teaspoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsCustomaryCupAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; + Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsGallonAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; + Volume value = Volume.From(1, VolumeUnit.UsGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsLegalCupAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; + Volume value = Volume.From(1, VolumeUnit.UsLegalCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithUsOunceAsDefualtUnit() + { + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; + Volume value = Volume.From(1, VolumeUnit.UsOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index 2e97a8bb1d..06cb9a0466 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -473,13 +473,18 @@ public static AccelerationUnit ParseUnit(string str, IFormatProvider formatProvi #endregion + /// + /// Set the default unit used by ToString(). Default is MeterPerSecondSquared + /// + public static AccelerationUnit ToStringDefaultUnit { get; set; } = AccelerationUnit.MeterPerSecondSquared; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AccelerationUnit.MeterPerSecondSquared); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index af61d1867c..3345a69d0e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -401,13 +401,18 @@ public static AmplitudeRatioUnit ParseUnit(string str, IFormatProvider formatPro #endregion + /// + /// Set the default unit used by ToString(). Default is DecibelVolt + /// + public static AmplitudeRatioUnit ToStringDefaultUnit { get; set; } = AmplitudeRatioUnit.DecibelVolt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AmplitudeRatioUnit.DecibelVolt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index e47a9faa7c..77cff19645 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -533,13 +533,18 @@ public static AngleUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Degree + /// + public static AngleUnit ToStringDefaultUnit { get; set; } = AngleUnit.Degree; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AngleUnit.Degree); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index 726318e673..5e08fe1eae 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -533,13 +533,18 @@ public static AreaUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion + /// + /// Set the default unit used by ToString(). Default is SquareMeter + /// + public static AreaUnit ToStringDefaultUnit { get; set; } = AreaUnit.SquareMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(AreaUnit.SquareMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 839f6c968f..69041d5b2c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -533,13 +533,18 @@ public static DensityUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is KilogramPerCubicMeter + /// + public static DensityUnit ToStringDefaultUnit { get; set; } = DensityUnit.KilogramPerCubicMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(DensityUnit.KilogramPerCubicMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index bf8c463258..ca0fe56f2e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -533,13 +533,18 @@ public static DurationUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is Second + /// + public static DurationUnit ToStringDefaultUnit { get; set; } = DurationUnit.Second; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(DurationUnit.Second); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index f7125fafa8..a619d6e0f1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -453,13 +453,18 @@ public static ElectricCurrentUnit ParseUnit(string str, IFormatProvider formatPr #endregion + /// + /// Set the default unit used by ToString(). Default is Ampere + /// + public static ElectricCurrentUnit ToStringDefaultUnit { get; set; } = ElectricCurrentUnit.Ampere; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ElectricCurrentUnit.Ampere); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index a722ba2583..d13104076a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -433,13 +433,18 @@ public static ElectricPotentialUnit ParseUnit(string str, IFormatProvider format #endregion + /// + /// Set the default unit used by ToString(). Default is Volt + /// + public static ElectricPotentialUnit ToStringDefaultUnit { get; set; } = ElectricPotentialUnit.Volt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ElectricPotentialUnit.Volt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index ea491f99d8..7eefaddba2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -393,13 +393,18 @@ public static ElectricResistanceUnit ParseUnit(string str, IFormatProvider forma #endregion + /// + /// Set the default unit used by ToString(). Default is Ohm + /// + public static ElectricResistanceUnit ToStringDefaultUnit { get; set; } = ElectricResistanceUnit.Ohm; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ElectricResistanceUnit.Ohm); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index c8ae39b475..83f057350d 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -593,13 +593,18 @@ public static EnergyUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is Joule + /// + public static EnergyUnit ToStringDefaultUnit { get; set; } = EnergyUnit.Joule; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(EnergyUnit.Joule); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index 42b467469c..d06971cdad 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -453,13 +453,18 @@ public static FlowUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion + /// + /// Set the default unit used by ToString(). Default is CubicMeterPerSecond + /// + public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(FlowUnit.CubicMeterPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index 5c2c200dd4..42df19cd1a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -493,13 +493,18 @@ public static ForceUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Newton + /// + public static ForceUnit ToStringDefaultUnit { get; set; } = ForceUnit.Newton; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ForceUnit.Newton); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 1aea4c3271..3e2a1c5407 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -353,13 +353,18 @@ public static ForceChangeRateUnit ParseUnit(string str, IFormatProvider formatPr #endregion + /// + /// Set the default unit used by ToString(). Default is NewtonPerSecond + /// + public static ForceChangeRateUnit ToStringDefaultUnit { get; set; } = ForceChangeRateUnit.NewtonPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(ForceChangeRateUnit.NewtonPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index 537dda7d9e..d4cfba4764 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -493,13 +493,18 @@ public static FrequencyUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is Hertz + /// + public static FrequencyUnit ToStringDefaultUnit { get; set; } = FrequencyUnit.Hertz; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(FrequencyUnit.Hertz); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index dc0def7001..df44df560b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -853,13 +853,18 @@ public static InformationUnit ParseUnit(string str, IFormatProvider formatProvid #endregion + /// + /// Set the default unit used by ToString(). Default is Bit + /// + public static InformationUnit ToStringDefaultUnit { get; set; } = InformationUnit.Bit; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(InformationUnit.Bit); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index 26d841a987..a040344585 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -493,13 +493,18 @@ public static KinematicViscosityUnit ParseUnit(string str, IFormatProvider forma #endregion + /// + /// Set the default unit used by ToString(). Default is SquareMeterPerSecond + /// + public static KinematicViscosityUnit ToStringDefaultUnit { get; set; } = KinematicViscosityUnit.SquareMeterPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(KinematicViscosityUnit.SquareMeterPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index 7846ba599f..9ba7456ce1 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -613,13 +613,18 @@ public static LengthUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is Meter + /// + public static LengthUnit ToStringDefaultUnit { get; set; } = LengthUnit.Meter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(LengthUnit.Meter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index de8f5d6018..bd586733b5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -381,13 +381,18 @@ public static LevelUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Decibel + /// + public static LevelUnit ToStringDefaultUnit { get; set; } = LevelUnit.Decibel; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(LevelUnit.Decibel); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index 6c649b8c52..cf38e8ac32 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -673,13 +673,18 @@ public static MassUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion + /// + /// Set the default unit used by ToString(). Default is Kilogram + /// + public static MassUnit ToStringDefaultUnit { get; set; } = MassUnit.Kilogram; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(MassUnit.Kilogram); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index 2d0faf105e..c2b7ed351f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -533,13 +533,18 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is GramPerSecond + /// + public static MassFlowUnit ToStringDefaultUnit { get; set; } = MassFlowUnit.GramPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(MassFlowUnit.GramPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index 8c88158567..2e26e468b5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -653,13 +653,18 @@ public static PowerUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is Watt + /// + public static PowerUnit ToStringDefaultUnit { get; set; } = PowerUnit.Watt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PowerUnit.Watt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index 607ee46d94..f1dba52587 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -381,13 +381,18 @@ public static PowerRatioUnit ParseUnit(string str, IFormatProvider formatProvide #endregion + /// + /// Set the default unit used by ToString(). Default is DecibelWatt + /// + public static PowerRatioUnit ToStringDefaultUnit { get; set; } = PowerRatioUnit.DecibelWatt; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PowerRatioUnit.DecibelWatt); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index 1d6531cd75..949192870a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -993,13 +993,18 @@ public static PressureUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is Pascal + /// + public static PressureUnit ToStringDefaultUnit { get; set; } = PressureUnit.Pascal; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PressureUnit.Pascal); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index ab502194ae..6364253e19 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -413,13 +413,18 @@ public static PressureChangeRateUnit ParseUnit(string str, IFormatProvider forma #endregion + /// + /// Set the default unit used by ToString(). Default is PascalPerSecond + /// + public static PressureChangeRateUnit ToStringDefaultUnit { get; set; } = PressureChangeRateUnit.PascalPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(PressureChangeRateUnit.PascalPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index d981186fee..0726b77d77 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -453,13 +453,18 @@ public static RatioUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is DecimalFraction + /// + public static RatioUnit ToStringDefaultUnit { get; set; } = RatioUnit.DecimalFraction; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(RatioUnit.DecimalFraction); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 7a06a8b558..951908a271 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -493,13 +493,18 @@ public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider formatPr #endregion + /// + /// Set the default unit used by ToString(). Default is RadianPerSecond + /// + public static RotationalSpeedUnit ToStringDefaultUnit { get; set; } = RotationalSpeedUnit.RadianPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(RotationalSpeedUnit.RadianPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index 39099ca08d..38672dd739 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -493,13 +493,18 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatPro #endregion + /// + /// Set the default unit used by ToString(). Default is JoulePerKilogram + /// + public static SpecificEnergyUnit ToStringDefaultUnit { get; set; } = SpecificEnergyUnit.JoulePerKilogram; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(SpecificEnergyUnit.JoulePerKilogram); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index 9c3420821c..f3704b9d1e 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -653,13 +653,18 @@ public static SpecificWeightUnit ParseUnit(string str, IFormatProvider formatPro #endregion + /// + /// Set the default unit used by ToString(). Default is NewtonPerCubicMeter + /// + public static SpecificWeightUnit ToStringDefaultUnit { get; set; } = SpecificWeightUnit.NewtonPerCubicMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(SpecificWeightUnit.NewtonPerCubicMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index b26772f673..c916efaaec 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -573,13 +573,18 @@ public static SpeedUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion + /// + /// Set the default unit used by ToString(). Default is MeterPerSecond + /// + public static SpeedUnit ToStringDefaultUnit { get; set; } = SpeedUnit.MeterPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(SpeedUnit.MeterPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index c6cdbfebee..7d3100c67c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -493,13 +493,18 @@ public static TemperatureUnit ParseUnit(string str, IFormatProvider formatProvid #endregion + /// + /// Set the default unit used by ToString(). Default is Kelvin + /// + public static TemperatureUnit ToStringDefaultUnit { get; set; } = TemperatureUnit.Kelvin; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(TemperatureUnit.Kelvin); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index cdbbc6777d..97f3d3114b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -513,13 +513,18 @@ public static TemperatureChangeRateUnit ParseUnit(string str, IFormatProvider fo #endregion + /// + /// Set the default unit used by ToString(). Default is DegreeCelsiusPerSecond + /// + public static TemperatureChangeRateUnit ToStringDefaultUnit { get; set; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index 9db32f4dac..e40b44e8a7 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -653,13 +653,18 @@ public static TorqueUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is NewtonMeter + /// + public static TorqueUnit ToStringDefaultUnit { get; set; } = TorqueUnit.NewtonMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(TorqueUnit.NewtonMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 9fd638199d..0366d7d3a0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -353,13 +353,18 @@ public static VitaminAUnit ParseUnit(string str, IFormatProvider formatProvider #endregion + /// + /// Set the default unit used by ToString(). Default is InternationalUnit + /// + public static VitaminAUnit ToStringDefaultUnit { get; set; } = VitaminAUnit.InternationalUnit; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(VitaminAUnit.InternationalUnit); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index d2fc288bff..df40ee9015 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -813,13 +813,18 @@ public static VolumeUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion + /// + /// Set the default unit used by ToString(). Default is CubicMeter + /// + public static VolumeUnit ToStringDefaultUnit { get; set; } = VolumeUnit.CubicMeter; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString(VolumeUnit.CubicMeter); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index 211c3dece8..b236401c44 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -386,13 +386,18 @@ namespace UnitsNet #endregion + /// + /// Set the default unit used by ToString(). Default is $baseUnitSingularName + /// + public static $unitEnumName ToStringDefaultUnit { get; set; } = $unitEnumName.$baseUnitSingularName; + /// /// Get default string representation of value and unit. /// /// String representation. public override string ToString() { - return ToString($unitEnumName.$baseUnitSingularName); + return ToString(ToStringDefaultUnit); } /// diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index 4d707f64df..a06a50c8ed 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -194,6 +194,30 @@ namespace UnitsNet.Tests $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); Assert.IsFalse($baseUnitVariableName.Equals(null)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() + { + $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); + $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); + string $($baseUnitVariableName)String = $($baseUnitVariableName).ToString(); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); + } + +"@; foreach ($unit in $units) {@" + [Test] + public void ToStringReturnsCorrectNumberAndUnitWith$($unit.SingularName)AsDefualtUnit() + { + $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; + $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); + $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); + $($className).ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); + } + +"@; }@" } } "@; From 1ebad2eaf64d05bd72ac1a81d1bc0ca249337f2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Oveg=C3=A5rd?= Date: Wed, 10 Feb 2016 09:20:16 +0100 Subject: [PATCH 6/8] Replaced tabs with spaces --- .../GeneratedCode/AccelerationTestsBase.g.cs | 102 ++-- .../AmplitudeRatioTestsBase.g.cs | 46 +- .../GeneratedCode/AngleTestsBase.g.cs | 144 +++--- .../GeneratedCode/AreaTestsBase.g.cs | 144 +++--- .../GeneratedCode/DensityTestsBase.g.cs | 144 +++--- .../GeneratedCode/DurationTestsBase.g.cs | 144 +++--- .../ElectricCurrentTestsBase.g.cs | 88 ++-- .../ElectricPotentialTestsBase.g.cs | 74 +-- .../ElectricResistanceTestsBase.g.cs | 46 +- .../GeneratedCode/EnergyTestsBase.g.cs | 186 +++---- .../GeneratedCode/FlowTestsBase.g.cs | 88 ++-- .../ForceChangeRateTestsBase.g.cs | 18 +- .../GeneratedCode/ForceTestsBase.g.cs | 116 ++--- .../GeneratedCode/FrequencyTestsBase.g.cs | 116 ++--- .../GeneratedCode/InformationTestsBase.g.cs | 368 +++++++------- .../KinematicViscosityTestsBase.g.cs | 116 ++--- .../GeneratedCode/LengthTestsBase.g.cs | 200 ++++---- .../GeneratedCode/LevelTestsBase.g.cs | 32 +- .../GeneratedCode/MassFlowTestsBase.g.cs | 144 +++--- .../GeneratedCode/MassTestsBase.g.cs | 242 ++++----- .../GeneratedCode/PowerRatioTestsBase.g.cs | 32 +- .../GeneratedCode/PowerTestsBase.g.cs | 228 ++++----- .../PressureChangeRateTestsBase.g.cs | 60 +-- .../GeneratedCode/PressureTestsBase.g.cs | 466 +++++++++--------- .../GeneratedCode/RatioTestsBase.g.cs | 88 ++-- .../RotationalSpeedTestsBase.g.cs | 116 ++--- .../SpecificEnergyTestsBase.g.cs | 116 ++--- .../SpecificWeightTestsBase.g.cs | 228 ++++----- .../GeneratedCode/SpeedTestsBase.g.cs | 172 +++---- .../TemperatureChangeRateTestsBase.g.cs | 130 ++--- .../GeneratedCode/TemperatureTestsBase.g.cs | 116 ++--- .../GeneratedCode/TorqueTestsBase.g.cs | 228 ++++----- .../GeneratedCode/VitaminATestsBase.g.cs | 18 +- .../GeneratedCode/VolumeTestsBase.g.cs | 326 ++++++------ ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 18 +- 35 files changed, 2450 insertions(+), 2450 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index dc355038bf..64a55c7a36 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -203,94 +203,94 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); string meterpersecondsquaredString = meterpersecondsquared.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondSquaredAsDefualtUnit() { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; + Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; + Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); + Acceleration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index c4f7fe5f29..7b1e0f98f7 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -183,46 +183,46 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); string decibelvoltString = decibelvolt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelMicrovoltAsDefualtUnit() { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelMillivoltAsDefualtUnit() { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelVoltAsDefualtUnit() { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; + AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; + AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); + AmplitudeRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index da49a60e5b..0f87ed1012 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle.ToStringDefaultUnit = AngleUnit.Degree; Angle degree = Angle.FromDegrees(1); string degreeString = degree.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithArcminuteAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Arcminute; - Angle value = Angle.From(1, AngleUnit.Arcminute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcminute; + Angle value = Angle.From(1, AngleUnit.Arcminute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithArcsecondAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; - Angle value = Angle.From(1, AngleUnit.Arcsecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; + Angle value = Angle.From(1, AngleUnit.Arcsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentiradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Centiradian; - Angle value = Angle.From(1, AngleUnit.Centiradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Centiradian; + Angle value = Angle.From(1, AngleUnit.Centiradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDeciradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Deciradian; - Angle value = Angle.From(1, AngleUnit.Deciradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Deciradian; + Angle value = Angle.From(1, AngleUnit.Deciradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Degree; - Angle value = Angle.From(1, AngleUnit.Degree); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Degree; + Angle value = Angle.From(1, AngleUnit.Degree); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Gradian; - Angle value = Angle.From(1, AngleUnit.Gradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Gradian; + Angle value = Angle.From(1, AngleUnit.Gradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Microradian; - Angle value = Angle.From(1, AngleUnit.Microradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Microradian; + Angle value = Angle.From(1, AngleUnit.Microradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Milliradian; - Angle value = Angle.From(1, AngleUnit.Milliradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Milliradian; + Angle value = Angle.From(1, AngleUnit.Milliradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanoradianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; - Angle value = Angle.From(1, AngleUnit.Nanoradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; + Angle value = Angle.From(1, AngleUnit.Nanoradian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRadianAsDefualtUnit() { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Radian; - Angle value = Angle.From(1, AngleUnit.Radian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AngleUnit oldUnit = Angle.ToStringDefaultUnit; + Angle.ToStringDefaultUnit = AngleUnit.Radian; + Angle value = Angle.From(1, AngleUnit.Radian); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); + Angle.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index 9215120cd9..726f92662a 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; Area squaremeter = Area.FromSquareMeters(1); string squaremeterString = squaremeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareCentimeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; - Area value = Area.From(1, AreaUnit.SquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; + Area value = Area.From(1, AreaUnit.SquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareDecimeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; - Area value = Area.From(1, AreaUnit.SquareDecimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; + Area value = Area.From(1, AreaUnit.SquareDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareFootAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareFoot; - Area value = Area.From(1, AreaUnit.SquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareFoot; + Area value = Area.From(1, AreaUnit.SquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareInchAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareInch; - Area value = Area.From(1, AreaUnit.SquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareInch; + Area value = Area.From(1, AreaUnit.SquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareKilometerAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; - Area value = Area.From(1, AreaUnit.SquareKilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; + Area value = Area.From(1, AreaUnit.SquareKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMeter; - Area value = Area.From(1, AreaUnit.SquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMeter; + Area value = Area.From(1, AreaUnit.SquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMicrometerAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; - Area value = Area.From(1, AreaUnit.SquareMicrometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; + Area value = Area.From(1, AreaUnit.SquareMicrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMileAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMile; - Area value = Area.From(1, AreaUnit.SquareMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMile; + Area value = Area.From(1, AreaUnit.SquareMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMillimeterAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; - Area value = Area.From(1, AreaUnit.SquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; + Area value = Area.From(1, AreaUnit.SquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareYardAsDefualtUnit() { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareYard; - Area value = Area.From(1, AreaUnit.SquareYard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + AreaUnit oldUnit = Area.ToStringDefaultUnit; + Area.ToStringDefaultUnit = AreaUnit.SquareYard; + Area value = Area.From(1, AreaUnit.SquareYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); + Area.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 68b54cb471..20e56e7575 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); string kilogrampercubicmeterString = kilogrampercubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicCentimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMillimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; + Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicFootAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; - Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicInchAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; - Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; + Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicFootAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; - Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; + Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicInchAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; - Density value = Density.From(1, DensityUnit.PoundPerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; + Density value = Density.From(1, DensityUnit.PoundPerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicCentimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMillimeterAsDefualtUnit() { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DensityUnit oldUnit = Density.ToStringDefaultUnit; + Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; + Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); + Density.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index b148cc0940..64e708efc6 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration.ToStringDefaultUnit = DurationUnit.Second; Duration second = Duration.FromSeconds(1); string secondString = second.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDayAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Day; - Duration value = Duration.From(1, DurationUnit.Day); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Day; + Duration value = Duration.From(1, DurationUnit.Day); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHourAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Hour; - Duration value = Duration.From(1, DurationUnit.Hour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Hour; + Duration value = Duration.From(1, DurationUnit.Hour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrosecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Microsecond; - Duration value = Duration.From(1, DurationUnit.Microsecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Microsecond; + Duration value = Duration.From(1, DurationUnit.Microsecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillisecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Millisecond; - Duration value = Duration.From(1, DurationUnit.Millisecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Millisecond; + Duration value = Duration.From(1, DurationUnit.Millisecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMinuteAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Minute; - Duration value = Duration.From(1, DurationUnit.Minute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Minute; + Duration value = Duration.From(1, DurationUnit.Minute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMonthAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Month; - Duration value = Duration.From(1, DurationUnit.Month); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Month; + Duration value = Duration.From(1, DurationUnit.Month); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanosecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; - Duration value = Duration.From(1, DurationUnit.Nanosecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; + Duration value = Duration.From(1, DurationUnit.Nanosecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSecondAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Second; - Duration value = Duration.From(1, DurationUnit.Second); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Second; + Duration value = Duration.From(1, DurationUnit.Second); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWeekAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Week; - Duration value = Duration.From(1, DurationUnit.Week); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Week; + Duration value = Duration.From(1, DurationUnit.Week); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithYearAsDefualtUnit() { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Year; - Duration value = Duration.From(1, DurationUnit.Year); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + DurationUnit oldUnit = Duration.ToStringDefaultUnit; + Duration.ToStringDefaultUnit = DurationUnit.Year; + Duration value = Duration.From(1, DurationUnit.Year); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); + Duration.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 264449f25d..6d31f8d7ab 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -197,82 +197,82 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); string ampereString = ampere.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithAmpereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKiloampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegaampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanoampereAsDefualtUnit() { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; + ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; + ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); + ElectricCurrent.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index c563008ac1..6afa40eff5 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -191,70 +191,70 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; ElectricPotential volt = ElectricPotential.FromVolts(1); string voltString = volt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilovoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegavoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrovoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillivoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithVoltAsDefualtUnit() { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; + ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; + ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); + ElectricPotential.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index 8b926774db..178f200425 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -179,46 +179,46 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; ElectricResistance ohm = ElectricResistance.FromOhms(1); string ohmString = ohm.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKiloohmAsDefualtUnit() { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegaohmAsDefualtUnit() { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithOhmAsDefualtUnit() { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; + ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; + ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); + ElectricResistance.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index baff65f537..54736583f4 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -239,166 +239,166 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy.ToStringDefaultUnit = EnergyUnit.Joule; Energy joule = Energy.FromJoules(1); string jouleString = joule.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBritishThermalUnitAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; - Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; + Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCalorieAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Calorie; - Energy value = Energy.From(1, EnergyUnit.Calorie); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Calorie; + Energy value = Energy.From(1, EnergyUnit.Calorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithElectronVoltAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; - Energy value = Energy.From(1, EnergyUnit.ElectronVolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; + Energy value = Energy.From(1, EnergyUnit.ElectronVolt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithErgAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Erg; - Energy value = Energy.From(1, EnergyUnit.Erg); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Erg; + Energy value = Energy.From(1, EnergyUnit.Erg); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFootPoundAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.FootPound; - Energy value = Energy.From(1, EnergyUnit.FootPound); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.FootPound; + Energy value = Energy.From(1, EnergyUnit.FootPound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigawattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; - Energy value = Energy.From(1, EnergyUnit.GigawattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; + Energy value = Energy.From(1, EnergyUnit.GigawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithJouleAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Joule; - Energy value = Energy.From(1, EnergyUnit.Joule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Joule; + Energy value = Energy.From(1, EnergyUnit.Joule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilocalorieAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; - Energy value = Energy.From(1, EnergyUnit.Kilocalorie); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; + Energy value = Energy.From(1, EnergyUnit.Kilocalorie); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilojouleAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; - Energy value = Energy.From(1, EnergyUnit.Kilojoule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; + Energy value = Energy.From(1, EnergyUnit.Kilojoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; - Energy value = Energy.From(1, EnergyUnit.KilowattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; + Energy value = Energy.From(1, EnergyUnit.KilowattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegajouleAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; - Energy value = Energy.From(1, EnergyUnit.Megajoule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; + Energy value = Energy.From(1, EnergyUnit.Megajoule); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; - Energy value = Energy.From(1, EnergyUnit.MegawattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; + Energy value = Energy.From(1, EnergyUnit.MegawattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWattHourAsDefualtUnit() { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.WattHour; - Energy value = Energy.From(1, EnergyUnit.WattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + EnergyUnit oldUnit = Energy.ToStringDefaultUnit; + Energy.ToStringDefaultUnit = EnergyUnit.WattHour; + Energy value = Energy.From(1, EnergyUnit.WattHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); + Energy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 402e7fa9b0..4520a3c16a 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -197,82 +197,82 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); string cubicmeterpersecondString = cubicmeterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicFootPerSecondAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; - Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerHourAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; - Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerSecondAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; - Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; + Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithLitersPerMinuteAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; - Flow value = Flow.From(1, FlowUnit.LitersPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; + Flow value = Flow.From(1, FlowUnit.LitersPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillionUsGallonsPerDayAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; - Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; + Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsGallonsPerMinuteAsDefualtUnit() { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; - Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FlowUnit oldUnit = Flow.ToStringDefaultUnit; + Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; + Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); + Flow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index 75abf80e3a..7ec1831d92 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -167,22 +167,22 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); string newtonpersecondString = newtonpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSecondAsDefualtUnit() { - ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; - ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; - ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); - ForceChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; + ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; + ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); + ForceChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 3eba27b8b5..6483856b69 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Force.ToStringDefaultUnit = ForceUnit.Newton; + Force.ToStringDefaultUnit = ForceUnit.Newton; Force newton = Force.FromNewtons(1); string newtonString = newton.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDynAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Dyn; - Force value = Force.From(1, ForceUnit.Dyn); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Dyn; + Force value = Force.From(1, ForceUnit.Dyn); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.KilogramForce; - Force value = Force.From(1, ForceUnit.KilogramForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KilogramForce; + Force value = Force.From(1, ForceUnit.KilogramForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Kilonewton; - Force value = Force.From(1, ForceUnit.Kilonewton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Kilonewton; + Force value = Force.From(1, ForceUnit.Kilonewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKiloPondAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.KiloPond; - Force value = Force.From(1, ForceUnit.KiloPond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.KiloPond; + Force value = Force.From(1, ForceUnit.KiloPond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Newton; - Force value = Force.From(1, ForceUnit.Newton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Newton; + Force value = Force.From(1, ForceUnit.Newton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundalAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Poundal; - Force value = Force.From(1, ForceUnit.Poundal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.Poundal; + Force value = Force.From(1, ForceUnit.Poundal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForceAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.PoundForce; - Force value = Force.From(1, ForceUnit.PoundForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.PoundForce; + Force value = Force.From(1, ForceUnit.PoundForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceAsDefualtUnit() { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.TonneForce; - Force value = Force.From(1, ForceUnit.TonneForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + ForceUnit oldUnit = Force.ToStringDefaultUnit; + Force.ToStringDefaultUnit = ForceUnit.TonneForce; + Force value = Force.From(1, ForceUnit.TonneForce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); + Force.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index b1e65ce6d0..43b35a8281 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; Frequency hertz = Frequency.FromHertz(1); string hertzString = hertz.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCyclePerHourAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; - Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCyclePerMinuteAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; - Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; + Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigahertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; - Frequency value = Frequency.From(1, FrequencyUnit.Hertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; + Frequency value = Frequency.From(1, FrequencyUnit.Hertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilohertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; - Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; + Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegahertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; - Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; + Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerahertzAsDefualtUnit() { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; + Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; + Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); + Frequency.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index 55a94856e8..2122a37be7 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -317,322 +317,322 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Information.ToStringDefaultUnit = InformationUnit.Bit; + Information.ToStringDefaultUnit = InformationUnit.Bit; Information bit = Information.FromBits(1); string bitString = bit.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Bit; - Information value = Information.From(1, InformationUnit.Bit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Bit; + Information value = Information.From(1, InformationUnit.Bit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithByteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Byte; - Information value = Information.From(1, InformationUnit.Byte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Byte; + Information value = Information.From(1, InformationUnit.Byte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exabit; - Information value = Information.From(1, InformationUnit.Exabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabit; + Information value = Information.From(1, InformationUnit.Exabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exabyte; - Information value = Information.From(1, InformationUnit.Exabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exabyte; + Information value = Information.From(1, InformationUnit.Exabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExbibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exbibit; - Information value = Information.From(1, InformationUnit.Exbibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibit; + Information value = Information.From(1, InformationUnit.Exbibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithExbibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exbibyte; - Information value = Information.From(1, InformationUnit.Exbibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Exbibyte; + Information value = Information.From(1, InformationUnit.Exbibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGibibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gibibit; - Information value = Information.From(1, InformationUnit.Gibibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibit; + Information value = Information.From(1, InformationUnit.Gibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGibibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gibibyte; - Information value = Information.From(1, InformationUnit.Gibibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gibibyte; + Information value = Information.From(1, InformationUnit.Gibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gigabit; - Information value = Information.From(1, InformationUnit.Gigabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabit; + Information value = Information.From(1, InformationUnit.Gigabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gigabyte; - Information value = Information.From(1, InformationUnit.Gigabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Gigabyte; + Information value = Information.From(1, InformationUnit.Gigabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKibibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kibibit; - Information value = Information.From(1, InformationUnit.Kibibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibit; + Information value = Information.From(1, InformationUnit.Kibibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKibibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kibibyte; - Information value = Information.From(1, InformationUnit.Kibibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kibibyte; + Information value = Information.From(1, InformationUnit.Kibibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilobitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kilobit; - Information value = Information.From(1, InformationUnit.Kilobit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobit; + Information value = Information.From(1, InformationUnit.Kilobit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilobyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kilobyte; - Information value = Information.From(1, InformationUnit.Kilobyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Kilobyte; + Information value = Information.From(1, InformationUnit.Kilobyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMebibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Mebibit; - Information value = Information.From(1, InformationUnit.Mebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibit; + Information value = Information.From(1, InformationUnit.Mebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMebibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Mebibyte; - Information value = Information.From(1, InformationUnit.Mebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Mebibyte; + Information value = Information.From(1, InformationUnit.Mebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Megabit; - Information value = Information.From(1, InformationUnit.Megabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabit; + Information value = Information.From(1, InformationUnit.Megabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Megabyte; - Information value = Information.From(1, InformationUnit.Megabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Megabyte; + Information value = Information.From(1, InformationUnit.Megabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPebibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Pebibit; - Information value = Information.From(1, InformationUnit.Pebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibit; + Information value = Information.From(1, InformationUnit.Pebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPebibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Pebibyte; - Information value = Information.From(1, InformationUnit.Pebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Pebibyte; + Information value = Information.From(1, InformationUnit.Pebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPetabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Petabit; - Information value = Information.From(1, InformationUnit.Petabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabit; + Information value = Information.From(1, InformationUnit.Petabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPetabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Petabyte; - Information value = Information.From(1, InformationUnit.Petabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Petabyte; + Information value = Information.From(1, InformationUnit.Petabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTebibitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Tebibit; - Information value = Information.From(1, InformationUnit.Tebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibit; + Information value = Information.From(1, InformationUnit.Tebibit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTebibyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Tebibyte; - Information value = Information.From(1, InformationUnit.Tebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Tebibyte; + Information value = Information.From(1, InformationUnit.Tebibyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerabitAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Terabit; - Information value = Information.From(1, InformationUnit.Terabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabit; + Information value = Information.From(1, InformationUnit.Terabit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerabyteAsDefualtUnit() { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Terabyte; - Information value = Information.From(1, InformationUnit.Terabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + InformationUnit oldUnit = Information.ToStringDefaultUnit; + Information.ToStringDefaultUnit = InformationUnit.Terabyte; + Information value = Information.From(1, InformationUnit.Terabyte); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); + Information.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 6bc405bf99..9691724f1f 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); string squaremeterpersecondString = squaremeterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentistokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecistokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilostokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrostokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillistokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanostokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterPerSecondAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithStokesAsDefualtUnit() { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; + KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; + KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); + KinematicViscosity.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index 306d567680..c30884f5de 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -245,178 +245,178 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Length.ToStringDefaultUnit = LengthUnit.Meter; + Length.ToStringDefaultUnit = LengthUnit.Meter; Length meter = Length.FromMeters(1); string meterString = meter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Centimeter; - Length value = Length.From(1, LengthUnit.Centimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Centimeter; + Length value = Length.From(1, LengthUnit.Centimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Decimeter; - Length value = Length.From(1, LengthUnit.Decimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Decimeter; + Length value = Length.From(1, LengthUnit.Decimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFootAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Foot; - Length value = Length.From(1, LengthUnit.Foot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Foot; + Length value = Length.From(1, LengthUnit.Foot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithInchAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Inch; - Length value = Length.From(1, LengthUnit.Inch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Inch; + Length value = Length.From(1, LengthUnit.Inch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Kilometer; - Length value = Length.From(1, LengthUnit.Kilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Kilometer; + Length value = Length.From(1, LengthUnit.Kilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Meter; - Length value = Length.From(1, LengthUnit.Meter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length value = Length.From(1, LengthUnit.Meter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroinchAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Microinch; - Length value = Length.From(1, LengthUnit.Microinch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Microinch; + Length value = Length.From(1, LengthUnit.Microinch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrometerAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Micrometer; - Length value = Length.From(1, LengthUnit.Micrometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Micrometer; + Length value = Length.From(1, LengthUnit.Micrometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Mil; - Length value = Length.From(1, LengthUnit.Mil); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mil; + Length value = Length.From(1, LengthUnit.Mil); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMileAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Mile; - Length value = Length.From(1, LengthUnit.Mile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Mile; + Length value = Length.From(1, LengthUnit.Mile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillimeterAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Millimeter; - Length value = Length.From(1, LengthUnit.Millimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Millimeter; + Length value = Length.From(1, LengthUnit.Millimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanometerAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Nanometer; - Length value = Length.From(1, LengthUnit.Nanometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Nanometer; + Length value = Length.From(1, LengthUnit.Nanometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNauticalMileAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.NauticalMile; - Length value = Length.From(1, LengthUnit.NauticalMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.NauticalMile; + Length value = Length.From(1, LengthUnit.NauticalMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithYardAsDefualtUnit() { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Yard; - Length value = Length.From(1, LengthUnit.Yard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Yard; + Length value = Length.From(1, LengthUnit.Yard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index 3d77584013..95d04f1d68 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -177,34 +177,34 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level.ToStringDefaultUnit = LevelUnit.Decibel; Level decibel = Level.FromDecibels(1); string decibelString = decibel.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelAsDefualtUnit() { - LevelUnit oldUnit = Level.ToStringDefaultUnit; - Level.ToStringDefaultUnit = LevelUnit.Decibel; - Level value = Level.From(1, LevelUnit.Decibel); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); - Level.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Decibel; + Level value = Level.From(1, LevelUnit.Decibel); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNeperAsDefualtUnit() { - LevelUnit oldUnit = Level.ToStringDefaultUnit; - Level.ToStringDefaultUnit = LevelUnit.Neper; - Level value = Level.From(1, LevelUnit.Neper); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); - Level.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + LevelUnit oldUnit = Level.ToStringDefaultUnit; + Level.ToStringDefaultUnit = LevelUnit.Neper; + Level value = Level.From(1, LevelUnit.Neper); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); + Level.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 3f3d327b24..266565f986 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -221,130 +221,130 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); string grampersecondString = grampersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentigramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecagramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecigramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilligramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanogramPerSecondAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; + MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonnePerDayAsDefualtUnit() { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; - MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; + MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; + MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); + MassFlow.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index 417a214677..f4a67d074e 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -263,214 +263,214 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass.ToStringDefaultUnit = MassUnit.Kilogram; Mass kilogram = Mass.FromKilograms(1); string kilogramString = kilogram.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentigramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Centigram; - Mass value = Mass.From(1, MassUnit.Centigram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Centigram; + Mass value = Mass.From(1, MassUnit.Centigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecagramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Decagram; - Mass value = Mass.From(1, MassUnit.Decagram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decagram; + Mass value = Mass.From(1, MassUnit.Decagram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecigramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Decigram; - Mass value = Mass.From(1, MassUnit.Decigram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Decigram; + Mass value = Mass.From(1, MassUnit.Decigram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Gram; - Mass value = Mass.From(1, MassUnit.Gram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Gram; + Mass value = Mass.From(1, MassUnit.Gram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Hectogram; - Mass value = Mass.From(1, MassUnit.Hectogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Hectogram; + Mass value = Mass.From(1, MassUnit.Hectogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Kilogram; - Mass value = Mass.From(1, MassUnit.Kilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilogram; + Mass value = Mass.From(1, MassUnit.Kilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilotonneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Kilotonne; - Mass value = Mass.From(1, MassUnit.Kilotonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Kilotonne; + Mass value = Mass.From(1, MassUnit.Kilotonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithLongTonAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.LongTon; - Mass value = Mass.From(1, MassUnit.LongTon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.LongTon; + Mass value = Mass.From(1, MassUnit.LongTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegatonneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Megatonne; - Mass value = Mass.From(1, MassUnit.Megatonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Megatonne; + Mass value = Mass.From(1, MassUnit.Megatonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Microgram; - Mass value = Mass.From(1, MassUnit.Microgram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Microgram; + Mass value = Mass.From(1, MassUnit.Microgram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilligramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Milligram; - Mass value = Mass.From(1, MassUnit.Milligram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Milligram; + Mass value = Mass.From(1, MassUnit.Milligram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanogramAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Nanogram; - Mass value = Mass.From(1, MassUnit.Nanogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Nanogram; + Mass value = Mass.From(1, MassUnit.Nanogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithOunceAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Ounce; - Mass value = Mass.From(1, MassUnit.Ounce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Ounce; + Mass value = Mass.From(1, MassUnit.Ounce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Pound; - Mass value = Mass.From(1, MassUnit.Pound); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Pound; + Mass value = Mass.From(1, MassUnit.Pound); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithShortTonAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.ShortTon; - Mass value = Mass.From(1, MassUnit.ShortTon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.ShortTon; + Mass value = Mass.From(1, MassUnit.ShortTon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithStoneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Stone; - Mass value = Mass.From(1, MassUnit.Stone); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Stone; + Mass value = Mass.From(1, MassUnit.Stone); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneAsDefualtUnit() { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Tonne; - Mass value = Mass.From(1, MassUnit.Tonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + MassUnit oldUnit = Mass.ToStringDefaultUnit; + Mass.ToStringDefaultUnit = MassUnit.Tonne; + Mass value = Mass.From(1, MassUnit.Tonne); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); + Mass.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index afc9c13bc4..931ec7f1bc 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -177,34 +177,34 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); string decibelwattString = decibelwatt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelMilliwattAsDefualtUnit() { - PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; - PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); - PowerRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibelWattAsDefualtUnit() { - PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; - PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); - PowerRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; + PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; + PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); + PowerRatio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index a6323103b1..368d21be22 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -257,202 +257,202 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Power.ToStringDefaultUnit = PowerUnit.Watt; + Power.ToStringDefaultUnit = PowerUnit.Watt; Power watt = Power.FromWatts(1); string wattString = watt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBoilerHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; - Power value = Power.From(1, PowerUnit.BoilerHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; + Power value = Power.From(1, PowerUnit.BoilerHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithElectricalHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; - Power value = Power.From(1, PowerUnit.ElectricalHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; + Power value = Power.From(1, PowerUnit.ElectricalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFemtowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Femtowatt; - Power value = Power.From(1, PowerUnit.Femtowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Femtowatt; + Power value = Power.From(1, PowerUnit.Femtowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Gigawatt; - Power value = Power.From(1, PowerUnit.Gigawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Gigawatt; + Power value = Power.From(1, PowerUnit.Gigawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHydraulicHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; - Power value = Power.From(1, PowerUnit.HydraulicHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; + Power value = Power.From(1, PowerUnit.HydraulicHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Kilowatt; - Power value = Power.From(1, PowerUnit.Kilowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Kilowatt; + Power value = Power.From(1, PowerUnit.Kilowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMechanicalHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; - Power value = Power.From(1, PowerUnit.MechanicalHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; + Power value = Power.From(1, PowerUnit.MechanicalHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Megawatt; - Power value = Power.From(1, PowerUnit.Megawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Megawatt; + Power value = Power.From(1, PowerUnit.Megawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMetricHorsepowerAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; - Power value = Power.From(1, PowerUnit.MetricHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; + Power value = Power.From(1, PowerUnit.MetricHorsepower); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Microwatt; - Power value = Power.From(1, PowerUnit.Microwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Microwatt; + Power value = Power.From(1, PowerUnit.Microwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliwattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Milliwatt; - Power value = Power.From(1, PowerUnit.Milliwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Milliwatt; + Power value = Power.From(1, PowerUnit.Milliwatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Nanowatt; - Power value = Power.From(1, PowerUnit.Nanowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Nanowatt; + Power value = Power.From(1, PowerUnit.Nanowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPetawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Petawatt; - Power value = Power.From(1, PowerUnit.Petawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Petawatt; + Power value = Power.From(1, PowerUnit.Petawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPicowattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Picowatt; - Power value = Power.From(1, PowerUnit.Picowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Picowatt; + Power value = Power.From(1, PowerUnit.Picowatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTerawattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Terawatt; - Power value = Power.From(1, PowerUnit.Terawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Terawatt; + Power value = Power.From(1, PowerUnit.Terawatt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWattAsDefualtUnit() { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Watt; - Power value = Power.From(1, PowerUnit.Watt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PowerUnit oldUnit = Power.ToStringDefaultUnit; + Power.ToStringDefaultUnit = PowerUnit.Watt; + Power value = Power.From(1, PowerUnit.Watt); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); + Power.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index 317f0af622..e7e3733c2d 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -185,58 +185,58 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); string pascalpersecondString = pascalpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithAtmospherePerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopascalPerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegapascalPerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPascalPerSecondAsDefualtUnit() { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; + PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; + PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); + PressureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index 93222d94bd..864c8a2902 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -359,406 +359,406 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; Pressure pascal = Pressure.FromPascals(1); string pascalString = pascal.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithAtmosphereAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; - Pressure value = Pressure.From(1, PressureUnit.Atmosphere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; + Pressure value = Pressure.From(1, PressureUnit.Atmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithBarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Bar; - Pressure value = Pressure.From(1, PressureUnit.Bar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Bar; + Pressure value = Pressure.From(1, PressureUnit.Bar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentibarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Centibar; - Pressure value = Pressure.From(1, PressureUnit.Centibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Centibar; + Pressure value = Pressure.From(1, PressureUnit.Centibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecapascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; - Pressure value = Pressure.From(1, PressureUnit.Decapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; + Pressure value = Pressure.From(1, PressureUnit.Decapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecibarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Decibar; - Pressure value = Pressure.From(1, PressureUnit.Decibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Decibar; + Pressure value = Pressure.From(1, PressureUnit.Decibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithGigapascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; - Pressure value = Pressure.From(1, PressureUnit.Gigapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; + Pressure value = Pressure.From(1, PressureUnit.Gigapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectopascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; - Pressure value = Pressure.From(1, PressureUnit.Hectopascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; + Pressure value = Pressure.From(1, PressureUnit.Hectopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilobarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; - Pressure value = Pressure.From(1, PressureUnit.Kilobar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; + Pressure value = Pressure.From(1, PressureUnit.Kilobar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; - Pressure value = Pressure.From(1, PressureUnit.Kilopascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; + Pressure value = Pressure.From(1, PressureUnit.Kilopascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareFootAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; - Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareInchAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; - Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegabarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Megabar; - Pressure value = Pressure.From(1, PressureUnit.Megabar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megabar; + Pressure value = Pressure.From(1, PressureUnit.Megabar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegapascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; - Pressure value = Pressure.From(1, PressureUnit.Megapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; + Pressure value = Pressure.From(1, PressureUnit.Megapascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicropascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; - Pressure value = Pressure.From(1, PressureUnit.Micropascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; + Pressure value = Pressure.From(1, PressureUnit.Micropascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillibarAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Millibar; - Pressure value = Pressure.From(1, PressureUnit.Millibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Millibar; + Pressure value = Pressure.From(1, PressureUnit.Millibar); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPascalAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Pascal; - Pressure value = Pressure.From(1, PressureUnit.Pascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Pascal; + Pressure value = Pressure.From(1, PressureUnit.Pascal); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareFootAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; - Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareInchAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; - Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; + Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPsiAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Psi; - Pressure value = Pressure.From(1, PressureUnit.Psi); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Psi; + Pressure value = Pressure.From(1, PressureUnit.Psi); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTechnicalAtmosphereAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; - Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; + Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareCentimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMillimeterAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; + Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTorrAsDefualtUnit() { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Torr; - Pressure value = Pressure.From(1, PressureUnit.Torr); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + PressureUnit oldUnit = Pressure.ToStringDefaultUnit; + Pressure.ToStringDefaultUnit = PressureUnit.Torr; + Pressure value = Pressure.From(1, PressureUnit.Torr); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); + Pressure.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index 27c96ca539..d024d2556d 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -197,82 +197,82 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; Ratio decimalfraction = Ratio.FromDecimalFractions(1); string decimalfractionString = decimalfraction.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimalFractionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; - Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; + Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerBillionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerMillionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerThousandAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; - Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; + Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPartPerTrillionAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; + Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPercentAsDefualtUnit() { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.Percent; - Ratio value = Ratio.From(1, RatioUnit.Percent); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RatioUnit oldUnit = Ratio.ToStringDefaultUnit; + Ratio.ToStringDefaultUnit = RatioUnit.Percent; + Ratio value = Ratio.From(1, RatioUnit.Percent); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); + Ratio.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 0794eaa618..be50210e62 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); string radianpersecondString = radianpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentiradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDeciradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicroradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanoradianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerMinuteAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerSecondAsDefualtUnit() { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; + RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; + RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); + RotationalSpeed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 0f81a0d72c..9002584536 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); string jouleperkilogramString = jouleperkilogram.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCaloriePerGramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithJoulePerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilocaloriePerGramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilojoulePerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourPerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegajoulePerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourPerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithWattHourPerKilogramAsDefualtUnit() { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; + SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; + SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); + SpecificEnergy.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 4f63508749..2cc5278d59 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -257,202 +257,202 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); string newtonpercubicmeterString = newtonpercubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicFootAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicInchAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicFootAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicInchAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicCentimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMillimeterAsDefualtUnit() { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; + SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; + SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); + SpecificWeight.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 77ff0ec620..27d9dd232a 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -233,154 +233,154 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; Speed meterpersecond = Speed.FromMetersPerSecond(1); string meterpersecondString = meterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithFootPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; - Speed value = Speed.From(1, SpeedUnit.FootPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; + Speed value = Speed.From(1, SpeedUnit.FootPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerHourAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; - Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; + Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKnotAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.Knot; - Speed value = Speed.From(1, SpeedUnit.Knot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.Knot; + Speed value = Speed.From(1, SpeedUnit.Knot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterPerHourAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; - Speed value = Speed.From(1, SpeedUnit.MeterPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; + Speed value = Speed.From(1, SpeedUnit.MeterPerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilePerHourAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; - Speed value = Speed.From(1, SpeedUnit.MilePerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; + Speed value = Speed.From(1, SpeedUnit.MilePerHour); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; + Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondAsDefualtUnit() { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + SpeedUnit oldUnit = Speed.ToStringDefaultUnit; + Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; + Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); + Speed.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index c826d257db..b5f32c853c 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -215,118 +215,118 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); string degreecelsiuspersecondString = degreecelsiuspersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentidegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecadegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDecidegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMicrodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMillidegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNanodegreeCelsiusPerSecondAsDefualtUnit() { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; + TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; + TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); + TemperatureChangeRate.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 2ef8499deb..02c32c313f 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -209,106 +209,106 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; Temperature kelvin = Temperature.FromKelvins(1); string kelvinString = kelvin.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeDelisleAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeFahrenheitAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeNewtonAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeRankineAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeReaumurAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDegreeRoemerAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; + Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKelvinAsDefualtUnit() { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; - Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; + Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; + Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); + Temperature.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index e4dfc47607..7552313201 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -257,202 +257,202 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; Torque newtonmeter = Torque.FromNewtonMeters(1); string newtonmeterString = newtonmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceFootAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; - Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceInchAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; - Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; + Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; - Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; - Torque value = Torque.From(1, TorqueUnit.NewtonMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithNewtonMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; - Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; + Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForceFootAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; - Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; + Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithPoundForceInchAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; - Torque value = Torque.From(1, TorqueUnit.PoundForceInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; + Torque value = Torque.From(1, TorqueUnit.PoundForceInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceCentimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMillimeterAsDefualtUnit() { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + TorqueUnit oldUnit = Torque.ToStringDefaultUnit; + Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; + Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); + Torque.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index bb33c97f20..7eae28d304 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -167,22 +167,22 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; VitaminA internationalunit = VitaminA.FromInternationalUnits(1); string internationalunitString = internationalunit.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithInternationalUnitAsDefualtUnit() { - VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; - VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; - VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); - VitaminA.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; + VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; + VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); + VitaminA.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 3ebf75f253..e1ee82aa18 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -305,286 +305,286 @@ public void EqualsReturnsFalseOnNull() [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; Volume cubicmeter = Volume.FromCubicMeters(1); string cubicmeterString = cubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCentiliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; - Volume value = Volume.From(1, VolumeUnit.Centiliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; + Volume value = Volume.From(1, VolumeUnit.Centiliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicCentimeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; - Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; + Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicDecimeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; - Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; + Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicFootAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; - Volume value = Volume.From(1, VolumeUnit.CubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; + Volume value = Volume.From(1, VolumeUnit.CubicFoot); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicInchAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; - Volume value = Volume.From(1, VolumeUnit.CubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; + Volume value = Volume.From(1, VolumeUnit.CubicInch); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicKilometerAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; - Volume value = Volume.From(1, VolumeUnit.CubicKilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; + Volume value = Volume.From(1, VolumeUnit.CubicKilometer); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; - Volume value = Volume.From(1, VolumeUnit.CubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; + Volume value = Volume.From(1, VolumeUnit.CubicMeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMileAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; - Volume value = Volume.From(1, VolumeUnit.CubicMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; + Volume value = Volume.From(1, VolumeUnit.CubicMile); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicMillimeterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; - Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; + Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithCubicYardAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; - Volume value = Volume.From(1, VolumeUnit.CubicYard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; + Volume value = Volume.From(1, VolumeUnit.CubicYard); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithDeciliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; - Volume value = Volume.From(1, VolumeUnit.Deciliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; + Volume value = Volume.From(1, VolumeUnit.Deciliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithHectoliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; - Volume value = Volume.From(1, VolumeUnit.Hectoliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; + Volume value = Volume.From(1, VolumeUnit.Hectoliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithImperialGallonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; - Volume value = Volume.From(1, VolumeUnit.ImperialGallon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; + Volume value = Volume.From(1, VolumeUnit.ImperialGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithImperialOunceAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; - Volume value = Volume.From(1, VolumeUnit.ImperialOunce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; + Volume value = Volume.From(1, VolumeUnit.ImperialOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithLiterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Liter; - Volume value = Volume.From(1, VolumeUnit.Liter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Liter; + Volume value = Volume.From(1, VolumeUnit.Liter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMetricCupAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; - Volume value = Volume.From(1, VolumeUnit.MetricCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; + Volume value = Volume.From(1, VolumeUnit.MetricCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithMilliliterAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; - Volume value = Volume.From(1, VolumeUnit.Milliliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; + Volume value = Volume.From(1, VolumeUnit.Milliliter); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTablespoonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; - Volume value = Volume.From(1, VolumeUnit.Tablespoon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; + Volume value = Volume.From(1, VolumeUnit.Tablespoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithTeaspoonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; - Volume value = Volume.From(1, VolumeUnit.Teaspoon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; + Volume value = Volume.From(1, VolumeUnit.Teaspoon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsCustomaryCupAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; - Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; + Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsGallonAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; - Volume value = Volume.From(1, VolumeUnit.UsGallon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; + Volume value = Volume.From(1, VolumeUnit.UsGallon); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsLegalCupAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; - Volume value = Volume.From(1, VolumeUnit.UsLegalCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; + Volume value = Volume.From(1, VolumeUnit.UsLegalCup); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } [Test] public void ToStringReturnsCorrectNumberAndUnitWithUsOunceAsDefualtUnit() { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; - Volume value = Volume.From(1, VolumeUnit.UsOunce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + VolumeUnit oldUnit = Volume.ToStringDefaultUnit; + Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; + Volume value = Volume.From(1, VolumeUnit.UsOunce); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); + Volume.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } } diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index a06a50c8ed..d713e155ef 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -198,23 +198,23 @@ namespace UnitsNet.Tests [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { - $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); + $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); string $($baseUnitVariableName)String = $($baseUnitVariableName).ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); + Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); } "@; foreach ($unit in $units) {@" [Test] public void ToStringReturnsCorrectNumberAndUnitWith$($unit.SingularName)AsDefualtUnit() { - $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; - $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); - $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); - $($className).ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); + $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; + $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); + $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); + string valueString = value.ToString(); + string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); + $($className).ToStringDefaultUnit = oldUnit; + Assert.AreEqual("1 " + unitString, valueString); } "@; }@" From ce38c7766d1ec6e498dee9060438c59916ed4149 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Oveg=C3=A5rd?= Date: Wed, 10 Feb 2016 09:23:41 +0100 Subject: [PATCH 7/8] More spaces/tabs --- UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs | 2 +- .../GeneratedCode/TemperatureChangeRateTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs | 2 +- UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs | 2 +- UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Area.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Density.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Force.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Information.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Length.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Level.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Power.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs | 4 ++-- UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs | 4 ++-- UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 | 4 ++-- .../Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 | 2 +- 70 files changed, 105 insertions(+), 105 deletions(-) diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index 64a55c7a36..ab31ca1de3 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -200,7 +200,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(meterpersecondsquared.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 7b1e0f98f7..95b2068752 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -180,7 +180,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decibelvolt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index 0f87ed1012..71bf47907c 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(degree.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Angle.ToStringDefaultUnit = AngleUnit.Degree; diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index 726f92662a..d3e00fa9d2 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(squaremeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Area.ToStringDefaultUnit = AreaUnit.SquareMeter; diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index 20e56e7575..bf3a59d9e3 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 64e708efc6..27347daa39 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(second.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Duration.ToStringDefaultUnit = DurationUnit.Second; diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 6d31f8d7ab..7f94115d0b 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -194,7 +194,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(ampere.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 6afa40eff5..8ff908da0a 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -188,7 +188,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(volt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index 178f200425..c14e0e43bc 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -176,7 +176,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(ohm.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index 54736583f4..3f26d3abe3 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -236,7 +236,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(joule.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Energy.ToStringDefaultUnit = EnergyUnit.Joule; diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 4520a3c16a..2c7f5d4308 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -194,7 +194,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(cubicmeterpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index 7ec1831d92..ff2747f64a 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -164,7 +164,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newtonpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 6483856b69..4d7445604e 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newton.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Force.ToStringDefaultUnit = ForceUnit.Newton; diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index 43b35a8281..d10b68778c 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(hertz.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index 2122a37be7..3fee97a04e 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -314,7 +314,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(bit.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Information.ToStringDefaultUnit = InformationUnit.Bit; diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 9691724f1f..1c9476bff4 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(squaremeterpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index c30884f5de..0f8b20de2e 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -242,7 +242,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(meter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Length.ToStringDefaultUnit = LengthUnit.Meter; diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index 95d04f1d68..0d8ddee27e 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -174,7 +174,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decibel.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Level.ToStringDefaultUnit = LevelUnit.Decibel; diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 266565f986..5899d94b1c 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -218,7 +218,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(grampersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index f4a67d074e..a439829b6f 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -260,7 +260,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(kilogram.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Mass.ToStringDefaultUnit = MassUnit.Kilogram; diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index 931ec7f1bc..0b043b1eeb 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -174,7 +174,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decibelwatt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index 368d21be22..c3f1ac1490 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -254,7 +254,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(watt.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Power.ToStringDefaultUnit = PowerUnit.Watt; diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index e7e3733c2d..2690b00c01 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -182,7 +182,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(pascalpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index 864c8a2902..c5cb303c56 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -356,7 +356,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(pascal.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Pressure.ToStringDefaultUnit = PressureUnit.Pascal; diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index d024d2556d..b44ed6fc54 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -194,7 +194,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(decimalfraction.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index be50210e62..c10f65f14a 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(radianpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index 9002584536..c99bc3cc49 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(jouleperkilogram.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index 2cc5278d59..ba994878eb 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -254,7 +254,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newtonpercubicmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 27d9dd232a..6c19e0ba22 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -230,7 +230,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(meterpersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index b5f32c853c..82eaad3f4f 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -212,7 +212,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 02c32c313f..03c910379b 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -206,7 +206,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(kelvin.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 7552313201..6e772f465f 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -254,7 +254,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(newtonmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index 7eae28d304..f46f5b4f89 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -164,7 +164,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(internationalunit.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index e1ee82aa18..48e3bcbe99 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -302,7 +302,7 @@ public void EqualsReturnsFalseOnNull() Assert.IsFalse(cubicmeter.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; diff --git a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs index 06cb9a0466..1f693b5a27 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs @@ -473,10 +473,10 @@ public static AccelerationUnit ParseUnit(string str, IFormatProvider formatProvi #endregion - /// + /// /// Set the default unit used by ToString(). Default is MeterPerSecondSquared /// - public static AccelerationUnit ToStringDefaultUnit { get; set; } = AccelerationUnit.MeterPerSecondSquared; + public static AccelerationUnit ToStringDefaultUnit { get; set; } = AccelerationUnit.MeterPerSecondSquared; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs index 3345a69d0e..665f7932cb 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs @@ -401,10 +401,10 @@ public static AmplitudeRatioUnit ParseUnit(string str, IFormatProvider formatPro #endregion - /// + /// /// Set the default unit used by ToString(). Default is DecibelVolt /// - public static AmplitudeRatioUnit ToStringDefaultUnit { get; set; } = AmplitudeRatioUnit.DecibelVolt; + public static AmplitudeRatioUnit ToStringDefaultUnit { get; set; } = AmplitudeRatioUnit.DecibelVolt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index 77cff19645..0cc5293fae 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -533,10 +533,10 @@ public static AngleUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Degree /// - public static AngleUnit ToStringDefaultUnit { get; set; } = AngleUnit.Degree; + public static AngleUnit ToStringDefaultUnit { get; set; } = AngleUnit.Degree; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs index 5e08fe1eae..8ae5edfda5 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Area.g.cs @@ -533,10 +533,10 @@ public static AreaUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion - /// + /// /// Set the default unit used by ToString(). Default is SquareMeter /// - public static AreaUnit ToStringDefaultUnit { get; set; } = AreaUnit.SquareMeter; + public static AreaUnit ToStringDefaultUnit { get; set; } = AreaUnit.SquareMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs index 69041d5b2c..842783bed7 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Density.g.cs @@ -533,10 +533,10 @@ public static DensityUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is KilogramPerCubicMeter /// - public static DensityUnit ToStringDefaultUnit { get; set; } = DensityUnit.KilogramPerCubicMeter; + public static DensityUnit ToStringDefaultUnit { get; set; } = DensityUnit.KilogramPerCubicMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs index ca0fe56f2e..5734d29371 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs @@ -533,10 +533,10 @@ public static DurationUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is Second /// - public static DurationUnit ToStringDefaultUnit { get; set; } = DurationUnit.Second; + public static DurationUnit ToStringDefaultUnit { get; set; } = DurationUnit.Second; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs index a619d6e0f1..b27d9ed508 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricCurrent.g.cs @@ -453,10 +453,10 @@ public static ElectricCurrentUnit ParseUnit(string str, IFormatProvider formatPr #endregion - /// + /// /// Set the default unit used by ToString(). Default is Ampere /// - public static ElectricCurrentUnit ToStringDefaultUnit { get; set; } = ElectricCurrentUnit.Ampere; + public static ElectricCurrentUnit ToStringDefaultUnit { get; set; } = ElectricCurrentUnit.Ampere; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs index d13104076a..2697432f2b 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricPotential.g.cs @@ -433,10 +433,10 @@ public static ElectricPotentialUnit ParseUnit(string str, IFormatProvider format #endregion - /// + /// /// Set the default unit used by ToString(). Default is Volt /// - public static ElectricPotentialUnit ToStringDefaultUnit { get; set; } = ElectricPotentialUnit.Volt; + public static ElectricPotentialUnit ToStringDefaultUnit { get; set; } = ElectricPotentialUnit.Volt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs index 7eefaddba2..c7f4dbb522 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ElectricResistance.g.cs @@ -393,10 +393,10 @@ public static ElectricResistanceUnit ParseUnit(string str, IFormatProvider forma #endregion - /// + /// /// Set the default unit used by ToString(). Default is Ohm /// - public static ElectricResistanceUnit ToStringDefaultUnit { get; set; } = ElectricResistanceUnit.Ohm; + public static ElectricResistanceUnit ToStringDefaultUnit { get; set; } = ElectricResistanceUnit.Ohm; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs index 83f057350d..91d0404698 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Energy.g.cs @@ -593,10 +593,10 @@ public static EnergyUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is Joule /// - public static EnergyUnit ToStringDefaultUnit { get; set; } = EnergyUnit.Joule; + public static EnergyUnit ToStringDefaultUnit { get; set; } = EnergyUnit.Joule; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index d06971cdad..fa590a1243 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -453,10 +453,10 @@ public static FlowUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion - /// + /// /// Set the default unit used by ToString(). Default is CubicMeterPerSecond /// - public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond; + public static FlowUnit ToStringDefaultUnit { get; set; } = FlowUnit.CubicMeterPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs index 42df19cd1a..4e84c3aaf2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Force.g.cs @@ -493,10 +493,10 @@ public static ForceUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Newton /// - public static ForceUnit ToStringDefaultUnit { get; set; } = ForceUnit.Newton; + public static ForceUnit ToStringDefaultUnit { get; set; } = ForceUnit.Newton; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 3e2a1c5407..3f7d44cb17 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -353,10 +353,10 @@ public static ForceChangeRateUnit ParseUnit(string str, IFormatProvider formatPr #endregion - /// + /// /// Set the default unit used by ToString(). Default is NewtonPerSecond /// - public static ForceChangeRateUnit ToStringDefaultUnit { get; set; } = ForceChangeRateUnit.NewtonPerSecond; + public static ForceChangeRateUnit ToStringDefaultUnit { get; set; } = ForceChangeRateUnit.NewtonPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs index d4cfba4764..4110be7e44 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Frequency.g.cs @@ -493,10 +493,10 @@ public static FrequencyUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is Hertz /// - public static FrequencyUnit ToStringDefaultUnit { get; set; } = FrequencyUnit.Hertz; + public static FrequencyUnit ToStringDefaultUnit { get; set; } = FrequencyUnit.Hertz; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs index df44df560b..dca8726316 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Information.g.cs @@ -853,10 +853,10 @@ public static InformationUnit ParseUnit(string str, IFormatProvider formatProvid #endregion - /// + /// /// Set the default unit used by ToString(). Default is Bit /// - public static InformationUnit ToStringDefaultUnit { get; set; } = InformationUnit.Bit; + public static InformationUnit ToStringDefaultUnit { get; set; } = InformationUnit.Bit; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs index a040344585..1f797d8697 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/KinematicViscosity.g.cs @@ -493,10 +493,10 @@ public static KinematicViscosityUnit ParseUnit(string str, IFormatProvider forma #endregion - /// + /// /// Set the default unit used by ToString(). Default is SquareMeterPerSecond /// - public static KinematicViscosityUnit ToStringDefaultUnit { get; set; } = KinematicViscosityUnit.SquareMeterPerSecond; + public static KinematicViscosityUnit ToStringDefaultUnit { get; set; } = KinematicViscosityUnit.SquareMeterPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs index 9ba7456ce1..04b1c8f347 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Length.g.cs @@ -613,10 +613,10 @@ public static LengthUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is Meter /// - public static LengthUnit ToStringDefaultUnit { get; set; } = LengthUnit.Meter; + public static LengthUnit ToStringDefaultUnit { get; set; } = LengthUnit.Meter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs index bd586733b5..7138756d94 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Level.g.cs @@ -381,10 +381,10 @@ public static LevelUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Decibel /// - public static LevelUnit ToStringDefaultUnit { get; set; } = LevelUnit.Decibel; + public static LevelUnit ToStringDefaultUnit { get; set; } = LevelUnit.Decibel; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs index cf38e8ac32..f224a1d60a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Mass.g.cs @@ -673,10 +673,10 @@ public static MassUnit ParseUnit(string str, IFormatProvider formatProvider = nu #endregion - /// + /// /// Set the default unit used by ToString(). Default is Kilogram /// - public static MassUnit ToStringDefaultUnit { get; set; } = MassUnit.Kilogram; + public static MassUnit ToStringDefaultUnit { get; set; } = MassUnit.Kilogram; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs index c2b7ed351f..79ea970d28 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs @@ -533,10 +533,10 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is GramPerSecond /// - public static MassFlowUnit ToStringDefaultUnit { get; set; } = MassFlowUnit.GramPerSecond; + public static MassFlowUnit ToStringDefaultUnit { get; set; } = MassFlowUnit.GramPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs index 2e26e468b5..a23d1db5f2 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Power.g.cs @@ -653,10 +653,10 @@ public static PowerUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is Watt /// - public static PowerUnit ToStringDefaultUnit { get; set; } = PowerUnit.Watt; + public static PowerUnit ToStringDefaultUnit { get; set; } = PowerUnit.Watt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs index f1dba52587..e74ad6ff08 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PowerRatio.g.cs @@ -381,10 +381,10 @@ public static PowerRatioUnit ParseUnit(string str, IFormatProvider formatProvide #endregion - /// + /// /// Set the default unit used by ToString(). Default is DecibelWatt /// - public static PowerRatioUnit ToStringDefaultUnit { get; set; } = PowerRatioUnit.DecibelWatt; + public static PowerRatioUnit ToStringDefaultUnit { get; set; } = PowerRatioUnit.DecibelWatt; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs index 949192870a..88057cb0e3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Pressure.g.cs @@ -993,10 +993,10 @@ public static PressureUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is Pascal /// - public static PressureUnit ToStringDefaultUnit { get; set; } = PressureUnit.Pascal; + public static PressureUnit ToStringDefaultUnit { get; set; } = PressureUnit.Pascal; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs index 6364253e19..13cc2bde4a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/PressureChangeRate.g.cs @@ -413,10 +413,10 @@ public static PressureChangeRateUnit ParseUnit(string str, IFormatProvider forma #endregion - /// + /// /// Set the default unit used by ToString(). Default is PascalPerSecond /// - public static PressureChangeRateUnit ToStringDefaultUnit { get; set; } = PressureChangeRateUnit.PascalPerSecond; + public static PressureChangeRateUnit ToStringDefaultUnit { get; set; } = PressureChangeRateUnit.PascalPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs index 0726b77d77..00db256403 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Ratio.g.cs @@ -453,10 +453,10 @@ public static RatioUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is DecimalFraction /// - public static RatioUnit ToStringDefaultUnit { get; set; } = RatioUnit.DecimalFraction; + public static RatioUnit ToStringDefaultUnit { get; set; } = RatioUnit.DecimalFraction; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 951908a271..f818695f20 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -493,10 +493,10 @@ public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider formatPr #endregion - /// + /// /// Set the default unit used by ToString(). Default is RadianPerSecond /// - public static RotationalSpeedUnit ToStringDefaultUnit { get; set; } = RotationalSpeedUnit.RadianPerSecond; + public static RotationalSpeedUnit ToStringDefaultUnit { get; set; } = RotationalSpeedUnit.RadianPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs index 38672dd739..1c28a48375 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs @@ -493,10 +493,10 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatPro #endregion - /// + /// /// Set the default unit used by ToString(). Default is JoulePerKilogram /// - public static SpecificEnergyUnit ToStringDefaultUnit { get; set; } = SpecificEnergyUnit.JoulePerKilogram; + public static SpecificEnergyUnit ToStringDefaultUnit { get; set; } = SpecificEnergyUnit.JoulePerKilogram; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs index f3704b9d1e..77901424d9 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificWeight.g.cs @@ -653,10 +653,10 @@ public static SpecificWeightUnit ParseUnit(string str, IFormatProvider formatPro #endregion - /// + /// /// Set the default unit used by ToString(). Default is NewtonPerCubicMeter /// - public static SpecificWeightUnit ToStringDefaultUnit { get; set; } = SpecificWeightUnit.NewtonPerCubicMeter; + public static SpecificWeightUnit ToStringDefaultUnit { get; set; } = SpecificWeightUnit.NewtonPerCubicMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index c916efaaec..989ae5eaba 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -573,10 +573,10 @@ public static SpeedUnit ParseUnit(string str, IFormatProvider formatProvider = n #endregion - /// + /// /// Set the default unit used by ToString(). Default is MeterPerSecond /// - public static SpeedUnit ToStringDefaultUnit { get; set; } = SpeedUnit.MeterPerSecond; + public static SpeedUnit ToStringDefaultUnit { get; set; } = SpeedUnit.MeterPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs index 7d3100c67c..c6e437c5b4 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Temperature.g.cs @@ -493,10 +493,10 @@ public static TemperatureUnit ParseUnit(string str, IFormatProvider formatProvid #endregion - /// + /// /// Set the default unit used by ToString(). Default is Kelvin /// - public static TemperatureUnit ToStringDefaultUnit { get; set; } = TemperatureUnit.Kelvin; + public static TemperatureUnit ToStringDefaultUnit { get; set; } = TemperatureUnit.Kelvin; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs index 97f3d3114b..798bd9bc70 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/TemperatureChangeRate.g.cs @@ -513,10 +513,10 @@ public static TemperatureChangeRateUnit ParseUnit(string str, IFormatProvider fo #endregion - /// + /// /// Set the default unit used by ToString(). Default is DegreeCelsiusPerSecond /// - public static TemperatureChangeRateUnit ToStringDefaultUnit { get; set; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; + public static TemperatureChangeRateUnit ToStringDefaultUnit { get; set; } = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs index e40b44e8a7..63a0344b56 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Torque.g.cs @@ -653,10 +653,10 @@ public static TorqueUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is NewtonMeter /// - public static TorqueUnit ToStringDefaultUnit { get; set; } = TorqueUnit.NewtonMeter; + public static TorqueUnit ToStringDefaultUnit { get; set; } = TorqueUnit.NewtonMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs index 0366d7d3a0..6521795793 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/VitaminA.g.cs @@ -353,10 +353,10 @@ public static VitaminAUnit ParseUnit(string str, IFormatProvider formatProvider #endregion - /// + /// /// Set the default unit used by ToString(). Default is InternationalUnit /// - public static VitaminAUnit ToStringDefaultUnit { get; set; } = VitaminAUnit.InternationalUnit; + public static VitaminAUnit ToStringDefaultUnit { get; set; } = VitaminAUnit.InternationalUnit; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index df40ee9015..335c8af90c 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -813,10 +813,10 @@ public static VolumeUnit ParseUnit(string str, IFormatProvider formatProvider = #endregion - /// + /// /// Set the default unit used by ToString(). Default is CubicMeter /// - public static VolumeUnit ToStringDefaultUnit { get; set; } = VolumeUnit.CubicMeter; + public static VolumeUnit ToStringDefaultUnit { get; set; } = VolumeUnit.CubicMeter; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 index b236401c44..3e0bfb2d69 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitClassSourceCode.ps1 @@ -386,10 +386,10 @@ namespace UnitsNet #endregion - /// + /// /// Set the default unit used by ToString(). Default is $baseUnitSingularName /// - public static $unitEnumName ToStringDefaultUnit { get; set; } = $unitEnumName.$baseUnitSingularName; + public static $unitEnumName ToStringDefaultUnit { get; set; } = $unitEnumName.$baseUnitSingularName; /// /// Get default string representation of value and unit. diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index d713e155ef..d6a8f60550 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -195,7 +195,7 @@ namespace UnitsNet.Tests Assert.IsFalse($baseUnitVariableName.Equals(null)); } - [Test] + [Test] public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() { $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); From 95418e092e0e073f39bdf98f1339cdc27fead2e4 Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Sun, 14 Feb 2016 20:39:30 +0100 Subject: [PATCH 8/8] Removed auto generated tests for ToString() and added 2 tests in length --- UnitsNet.Tests/CustomCode/LengthTests.cs | 21 + .../GeneratedCode/AccelerationTestsBase.g.cs | 94 ---- .../AmplitudeRatioTestsBase.g.cs | 46 -- .../GeneratedCode/AngleTestsBase.g.cs | 130 ------ .../GeneratedCode/AreaTestsBase.g.cs | 130 ------ .../GeneratedCode/DensityTestsBase.g.cs | 130 ------ .../GeneratedCode/DurationTestsBase.g.cs | 130 ------ .../ElectricCurrentTestsBase.g.cs | 82 ---- .../ElectricPotentialTestsBase.g.cs | 70 --- .../ElectricResistanceTestsBase.g.cs | 46 -- .../GeneratedCode/EnergyTestsBase.g.cs | 166 ------- .../GeneratedCode/FlowTestsBase.g.cs | 82 ---- .../ForceChangeRateTestsBase.g.cs | 22 - .../GeneratedCode/ForceTestsBase.g.cs | 106 ----- .../GeneratedCode/FrequencyTestsBase.g.cs | 106 ----- .../GeneratedCode/InformationTestsBase.g.cs | 322 -------------- .../KinematicViscosityTestsBase.g.cs | 106 ----- .../GeneratedCode/LengthTestsBase.g.cs | 178 -------- .../GeneratedCode/LevelTestsBase.g.cs | 34 -- .../GeneratedCode/MassFlowTestsBase.g.cs | 130 ------ .../GeneratedCode/MassTestsBase.g.cs | 214 --------- .../GeneratedCode/PowerRatioTestsBase.g.cs | 34 -- .../GeneratedCode/PowerTestsBase.g.cs | 202 --------- .../PressureChangeRateTestsBase.g.cs | 58 --- .../GeneratedCode/PressureTestsBase.g.cs | 406 ------------------ .../GeneratedCode/RatioTestsBase.g.cs | 82 ---- .../RotationalSpeedTestsBase.g.cs | 106 ----- .../SpecificEnergyTestsBase.g.cs | 106 ----- .../SpecificWeightTestsBase.g.cs | 202 --------- .../GeneratedCode/SpeedTestsBase.g.cs | 154 ------- .../TemperatureChangeRateTestsBase.g.cs | 118 ----- .../GeneratedCode/TemperatureTestsBase.g.cs | 106 ----- .../GeneratedCode/TorqueTestsBase.g.cs | 202 --------- .../GeneratedCode/VitaminATestsBase.g.cs | 22 - .../GeneratedCode/VolumeTestsBase.g.cs | 286 ------------ .../CustomCode/UnitClasses/Length.extra.cs | 1 + ...de-GenerateUnitTestBaseClassSourceCode.ps1 | 26 +- 37 files changed, 23 insertions(+), 4433 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs index ad183c9d35..197853bcc2 100644 --- a/UnitsNet.Tests/CustomCode/LengthTests.cs +++ b/UnitsNet.Tests/CustomCode/LengthTests.cs @@ -20,6 +20,7 @@ // THE SOFTWARE. using NUnit.Framework; +using UnitsNet.Units; namespace UnitsNet.Tests.CustomCode { @@ -88,5 +89,25 @@ public void LengthTimesLengthEqualsArea() Area area = Length.FromMeters(10)*Length.FromMeters(2); Assert.AreEqual(area, Area.FromSquareMeters(20)); } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnitWhichIsMeter() + { + Length.ToStringDefaultUnit = LengthUnit.Meter; + Length meter = Length.FromMeters(5); + string meterString = meter.ToString(); + Assert.AreEqual("5 m", meterString); + } + + [Test] + public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit() + { + LengthUnit oldUnit = Length.ToStringDefaultUnit; + Length.ToStringDefaultUnit = LengthUnit.Centimeter; + Length value = Length.From(2, LengthUnit.Centimeter); + string valueString = value.ToString(); + Length.ToStringDefaultUnit = oldUnit; + Assert.AreEqual("2 cm", valueString); + } } } \ No newline at end of file diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs index ab31ca1de3..e55a0044a4 100644 --- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs @@ -199,99 +199,5 @@ public void EqualsReturnsFalseOnNull() Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); Assert.IsFalse(meterpersecondsquared.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; - Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1); - string meterpersecondsquaredString = meterpersecondsquared.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared), meterpersecondsquaredString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.CentimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.CentimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.DecimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.DecimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.KilometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.KilometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MicrometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MicrometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.MillimeterPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.MillimeterPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondSquaredAsDefualtUnit() - { - AccelerationUnit oldUnit = Acceleration.ToStringDefaultUnit; - Acceleration.ToStringDefaultUnit = AccelerationUnit.NanometerPerSecondSquared; - Acceleration value = Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AccelerationUnit.NanometerPerSecondSquared); - Acceleration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs index 95b2068752..786dcee38d 100644 --- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs @@ -179,51 +179,5 @@ public void EqualsReturnsFalseOnNull() AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); Assert.IsFalse(decibelvolt.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; - AmplitudeRatio decibelvolt = AmplitudeRatio.FromDecibelVolts(1); - string decibelvoltString = decibelvolt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt), decibelvoltString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibelMicrovoltAsDefualtUnit() - { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMicrovolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMicrovolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMicrovolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibelMillivoltAsDefualtUnit() - { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelMillivolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelMillivolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelMillivolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibelVoltAsDefualtUnit() - { - AmplitudeRatioUnit oldUnit = AmplitudeRatio.ToStringDefaultUnit; - AmplitudeRatio.ToStringDefaultUnit = AmplitudeRatioUnit.DecibelVolt; - AmplitudeRatio value = AmplitudeRatio.From(1, AmplitudeRatioUnit.DecibelVolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AmplitudeRatioUnit.DecibelVolt); - AmplitudeRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs index 71bf47907c..d330008fcc 100644 --- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs @@ -217,135 +217,5 @@ public void EqualsReturnsFalseOnNull() Angle degree = Angle.FromDegrees(1); Assert.IsFalse(degree.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Angle.ToStringDefaultUnit = AngleUnit.Degree; - Angle degree = Angle.FromDegrees(1); - string degreeString = degree.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree), degreeString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithArcminuteAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Arcminute; - Angle value = Angle.From(1, AngleUnit.Arcminute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcminute); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithArcsecondAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Arcsecond; - Angle value = Angle.From(1, AngleUnit.Arcsecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Arcsecond); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentiradianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Centiradian; - Angle value = Angle.From(1, AngleUnit.Centiradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Centiradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDeciradianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Deciradian; - Angle value = Angle.From(1, AngleUnit.Deciradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Deciradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Degree; - Angle value = Angle.From(1, AngleUnit.Degree); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Degree); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGradianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Gradian; - Angle value = Angle.From(1, AngleUnit.Gradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Gradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicroradianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Microradian; - Angle value = Angle.From(1, AngleUnit.Microradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Microradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilliradianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Milliradian; - Angle value = Angle.From(1, AngleUnit.Milliradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Milliradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanoradianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Nanoradian; - Angle value = Angle.From(1, AngleUnit.Nanoradian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Nanoradian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithRadianAsDefualtUnit() - { - AngleUnit oldUnit = Angle.ToStringDefaultUnit; - Angle.ToStringDefaultUnit = AngleUnit.Radian; - Angle value = Angle.From(1, AngleUnit.Radian); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AngleUnit.Radian); - Angle.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs index d3e00fa9d2..ada71764bf 100644 --- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs @@ -217,135 +217,5 @@ public void EqualsReturnsFalseOnNull() Area squaremeter = Area.FromSquareMeters(1); Assert.IsFalse(squaremeter.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Area.ToStringDefaultUnit = AreaUnit.SquareMeter; - Area squaremeter = Area.FromSquareMeters(1); - string squaremeterString = squaremeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter), squaremeterString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareCentimeterAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareCentimeter; - Area value = Area.From(1, AreaUnit.SquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareCentimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareDecimeterAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareDecimeter; - Area value = Area.From(1, AreaUnit.SquareDecimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareDecimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareFootAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareFoot; - Area value = Area.From(1, AreaUnit.SquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareFoot); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareInchAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareInch; - Area value = Area.From(1, AreaUnit.SquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareInch); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareKilometerAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareKilometer; - Area value = Area.From(1, AreaUnit.SquareKilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareKilometer); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMeter; - Area value = Area.From(1, AreaUnit.SquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareMicrometerAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMicrometer; - Area value = Area.From(1, AreaUnit.SquareMicrometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMicrometer); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareMileAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMile; - Area value = Area.From(1, AreaUnit.SquareMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMile); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareMillimeterAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareMillimeter; - Area value = Area.From(1, AreaUnit.SquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareMillimeter); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareYardAsDefualtUnit() - { - AreaUnit oldUnit = Area.ToStringDefaultUnit; - Area.ToStringDefaultUnit = AreaUnit.SquareYard; - Area value = Area.From(1, AreaUnit.SquareYard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(AreaUnit.SquareYard); - Area.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs index bf3a59d9e3..87a39ad9c6 100644 --- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs @@ -217,135 +217,5 @@ public void EqualsReturnsFalseOnNull() Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); Assert.IsFalse(kilogrampercubicmeter.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; - Density kilogrampercubicmeter = Density.FromKilogramsPerCubicMeter(1); - string kilogrampercubicmeterString = kilogrampercubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter), kilogrampercubicmeterString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicCentimeterAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicCentimeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicCentimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMeterAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerCubicMillimeterAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilogramPerCubicMillimeter; - Density value = Density.From(1, DensityUnit.KilogramPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilogramPerCubicMillimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicFootAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicFoot; - Density value = Density.From(1, DensityUnit.KilopoundPerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicFoot); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundPerCubicInchAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.KilopoundPerCubicInch; - Density value = Density.From(1, DensityUnit.KilopoundPerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.KilopoundPerCubicInch); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicFootAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicFoot; - Density value = Density.From(1, DensityUnit.PoundPerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicFoot); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundPerCubicInchAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.PoundPerCubicInch; - Density value = Density.From(1, DensityUnit.PoundPerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.PoundPerCubicInch); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicCentimeterAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicCentimeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicCentimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMeterAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonnePerCubicMillimeterAsDefualtUnit() - { - DensityUnit oldUnit = Density.ToStringDefaultUnit; - Density.ToStringDefaultUnit = DensityUnit.TonnePerCubicMillimeter; - Density value = Density.From(1, DensityUnit.TonnePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DensityUnit.TonnePerCubicMillimeter); - Density.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs index 27347daa39..3b134a6b08 100644 --- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs @@ -217,135 +217,5 @@ public void EqualsReturnsFalseOnNull() Duration second = Duration.FromSeconds(1); Assert.IsFalse(second.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Duration.ToStringDefaultUnit = DurationUnit.Second; - Duration second = Duration.FromSeconds(1); - string secondString = second.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second), secondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDayAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Day; - Duration value = Duration.From(1, DurationUnit.Day); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Day); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHourAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Hour; - Duration value = Duration.From(1, DurationUnit.Hour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Hour); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrosecondAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Microsecond; - Duration value = Duration.From(1, DurationUnit.Microsecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Microsecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillisecondAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Millisecond; - Duration value = Duration.From(1, DurationUnit.Millisecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Millisecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMinuteAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Minute; - Duration value = Duration.From(1, DurationUnit.Minute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Minute); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMonthAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Month; - Duration value = Duration.From(1, DurationUnit.Month); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Month); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanosecondAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Nanosecond; - Duration value = Duration.From(1, DurationUnit.Nanosecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Nanosecond); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSecondAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Second; - Duration value = Duration.From(1, DurationUnit.Second); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Second); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithWeekAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Week; - Duration value = Duration.From(1, DurationUnit.Week); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Week); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithYearAsDefualtUnit() - { - DurationUnit oldUnit = Duration.ToStringDefaultUnit; - Duration.ToStringDefaultUnit = DurationUnit.Year; - Duration value = Duration.From(1, DurationUnit.Year); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(DurationUnit.Year); - Duration.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs index 7f94115d0b..52f03bd23f 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs @@ -193,87 +193,5 @@ public void EqualsReturnsFalseOnNull() ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); Assert.IsFalse(ampere.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; - ElectricCurrent ampere = ElectricCurrent.FromAmperes(1); - string ampereString = ampere.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere), ampereString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithAmpereAsDefualtUnit() - { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Ampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Ampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Ampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKiloampereAsDefualtUnit() - { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Kiloampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Kiloampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Kiloampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegaampereAsDefualtUnit() - { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Megaampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Megaampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Megaampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicroampereAsDefualtUnit() - { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Microampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Microampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Microampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilliampereAsDefualtUnit() - { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Milliampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Milliampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Milliampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanoampereAsDefualtUnit() - { - ElectricCurrentUnit oldUnit = ElectricCurrent.ToStringDefaultUnit; - ElectricCurrent.ToStringDefaultUnit = ElectricCurrentUnit.Nanoampere; - ElectricCurrent value = ElectricCurrent.From(1, ElectricCurrentUnit.Nanoampere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricCurrentUnit.Nanoampere); - ElectricCurrent.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs index 8ff908da0a..319f56cacc 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs @@ -187,75 +187,5 @@ public void EqualsReturnsFalseOnNull() ElectricPotential volt = ElectricPotential.FromVolts(1); Assert.IsFalse(volt.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; - ElectricPotential volt = ElectricPotential.FromVolts(1); - string voltString = volt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt), voltString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilovoltAsDefualtUnit() - { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Kilovolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Kilovolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Kilovolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegavoltAsDefualtUnit() - { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Megavolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Megavolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Megavolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrovoltAsDefualtUnit() - { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Microvolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Microvolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Microvolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillivoltAsDefualtUnit() - { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Millivolt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Millivolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Millivolt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithVoltAsDefualtUnit() - { - ElectricPotentialUnit oldUnit = ElectricPotential.ToStringDefaultUnit; - ElectricPotential.ToStringDefaultUnit = ElectricPotentialUnit.Volt; - ElectricPotential value = ElectricPotential.From(1, ElectricPotentialUnit.Volt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricPotentialUnit.Volt); - ElectricPotential.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs index c14e0e43bc..a23d9028c1 100644 --- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs @@ -175,51 +175,5 @@ public void EqualsReturnsFalseOnNull() ElectricResistance ohm = ElectricResistance.FromOhms(1); Assert.IsFalse(ohm.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; - ElectricResistance ohm = ElectricResistance.FromOhms(1); - string ohmString = ohm.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm), ohmString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKiloohmAsDefualtUnit() - { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Kiloohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Kiloohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Kiloohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegaohmAsDefualtUnit() - { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Megaohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Megaohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Megaohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithOhmAsDefualtUnit() - { - ElectricResistanceUnit oldUnit = ElectricResistance.ToStringDefaultUnit; - ElectricResistance.ToStringDefaultUnit = ElectricResistanceUnit.Ohm; - ElectricResistance value = ElectricResistance.From(1, ElectricResistanceUnit.Ohm); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ElectricResistanceUnit.Ohm); - ElectricResistance.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs index 3f26d3abe3..e23f86a521 100644 --- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs @@ -235,171 +235,5 @@ public void EqualsReturnsFalseOnNull() Energy joule = Energy.FromJoules(1); Assert.IsFalse(joule.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Energy.ToStringDefaultUnit = EnergyUnit.Joule; - Energy joule = Energy.FromJoules(1); - string jouleString = joule.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule), jouleString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithBritishThermalUnitAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.BritishThermalUnit; - Energy value = Energy.From(1, EnergyUnit.BritishThermalUnit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.BritishThermalUnit); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCalorieAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Calorie; - Energy value = Energy.From(1, EnergyUnit.Calorie); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Calorie); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithElectronVoltAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.ElectronVolt; - Energy value = Energy.From(1, EnergyUnit.ElectronVolt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.ElectronVolt); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithErgAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Erg; - Energy value = Energy.From(1, EnergyUnit.Erg); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Erg); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithFootPoundAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.FootPound; - Energy value = Energy.From(1, EnergyUnit.FootPound); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.FootPound); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGigawattHourAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.GigawattHour; - Energy value = Energy.From(1, EnergyUnit.GigawattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.GigawattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithJouleAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Joule; - Energy value = Energy.From(1, EnergyUnit.Joule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Joule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilocalorieAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Kilocalorie; - Energy value = Energy.From(1, EnergyUnit.Kilocalorie); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilocalorie); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilojouleAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Kilojoule; - Energy value = Energy.From(1, EnergyUnit.Kilojoule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Kilojoule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.KilowattHour; - Energy value = Energy.From(1, EnergyUnit.KilowattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.KilowattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegajouleAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.Megajoule; - Energy value = Energy.From(1, EnergyUnit.Megajoule); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.Megajoule); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.MegawattHour; - Energy value = Energy.From(1, EnergyUnit.MegawattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.MegawattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithWattHourAsDefualtUnit() - { - EnergyUnit oldUnit = Energy.ToStringDefaultUnit; - Energy.ToStringDefaultUnit = EnergyUnit.WattHour; - Energy value = Energy.From(1, EnergyUnit.WattHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(EnergyUnit.WattHour); - Energy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index 2c7f5d4308..8287346863 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -193,87 +193,5 @@ public void EqualsReturnsFalseOnNull() Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); Assert.IsFalse(cubicmeterpersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; - Flow cubicmeterpersecond = Flow.FromCubicMetersPerSecond(1); - string cubicmeterpersecondString = cubicmeterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond), cubicmeterpersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicFootPerSecondAsDefualtUnit() - { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicFootPerSecond; - Flow value = Flow.From(1, FlowUnit.CubicFootPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicFootPerSecond); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerHourAsDefualtUnit() - { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerHour; - Flow value = Flow.From(1, FlowUnit.CubicMeterPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerHour); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterPerSecondAsDefualtUnit() - { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.CubicMeterPerSecond; - Flow value = Flow.From(1, FlowUnit.CubicMeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.CubicMeterPerSecond); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithLitersPerMinuteAsDefualtUnit() - { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.LitersPerMinute; - Flow value = Flow.From(1, FlowUnit.LitersPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.LitersPerMinute); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillionUsGallonsPerDayAsDefualtUnit() - { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.MillionUsGallonsPerDay; - Flow value = Flow.From(1, FlowUnit.MillionUsGallonsPerDay); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.MillionUsGallonsPerDay); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithUsGallonsPerMinuteAsDefualtUnit() - { - FlowUnit oldUnit = Flow.ToStringDefaultUnit; - Flow.ToStringDefaultUnit = FlowUnit.UsGallonsPerMinute; - Flow value = Flow.From(1, FlowUnit.UsGallonsPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FlowUnit.UsGallonsPerMinute); - Flow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs index ff2747f64a..c521f78f26 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs @@ -163,27 +163,5 @@ public void EqualsReturnsFalseOnNull() ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); Assert.IsFalse(newtonpersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; - ForceChangeRate newtonpersecond = ForceChangeRate.FromNewtonsPerSecond(1); - string newtonpersecondString = newtonpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond), newtonpersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSecondAsDefualtUnit() - { - ForceChangeRateUnit oldUnit = ForceChangeRate.ToStringDefaultUnit; - ForceChangeRate.ToStringDefaultUnit = ForceChangeRateUnit.NewtonPerSecond; - ForceChangeRate value = ForceChangeRate.From(1, ForceChangeRateUnit.NewtonPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceChangeRateUnit.NewtonPerSecond); - ForceChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs index 4d7445604e..94a60dbe77 100644 --- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs @@ -205,111 +205,5 @@ public void EqualsReturnsFalseOnNull() Force newton = Force.FromNewtons(1); Assert.IsFalse(newton.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Force.ToStringDefaultUnit = ForceUnit.Newton; - Force newton = Force.FromNewtons(1); - string newtonString = newton.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton), newtonString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDynAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Dyn; - Force value = Force.From(1, ForceUnit.Dyn); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Dyn); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.KilogramForce; - Force value = Force.From(1, ForceUnit.KilogramForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KilogramForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Kilonewton; - Force value = Force.From(1, ForceUnit.Kilonewton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Kilonewton); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKiloPondAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.KiloPond; - Force value = Force.From(1, ForceUnit.KiloPond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.KiloPond); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Newton; - Force value = Force.From(1, ForceUnit.Newton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Newton); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundalAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.Poundal; - Force value = Force.From(1, ForceUnit.Poundal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.Poundal); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForceAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.PoundForce; - Force value = Force.From(1, ForceUnit.PoundForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.PoundForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForceAsDefualtUnit() - { - ForceUnit oldUnit = Force.ToStringDefaultUnit; - Force.ToStringDefaultUnit = ForceUnit.TonneForce; - Force value = Force.From(1, ForceUnit.TonneForce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(ForceUnit.TonneForce); - Force.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs index d10b68778c..c01b961863 100644 --- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs @@ -205,111 +205,5 @@ public void EqualsReturnsFalseOnNull() Frequency hertz = Frequency.FromHertz(1); Assert.IsFalse(hertz.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; - Frequency hertz = Frequency.FromHertz(1); - string hertzString = hertz.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz), hertzString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCyclePerHourAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerHour; - Frequency value = Frequency.From(1, FrequencyUnit.CyclePerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerHour); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCyclePerMinuteAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.CyclePerMinute; - Frequency value = Frequency.From(1, FrequencyUnit.CyclePerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.CyclePerMinute); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGigahertzAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Gigahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Gigahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Gigahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHertzAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Hertz; - Frequency value = Frequency.From(1, FrequencyUnit.Hertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Hertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilohertzAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Kilohertz; - Frequency value = Frequency.From(1, FrequencyUnit.Kilohertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Kilohertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegahertzAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Megahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Megahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Megahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.RadianPerSecond; - Frequency value = Frequency.From(1, FrequencyUnit.RadianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.RadianPerSecond); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTerahertzAsDefualtUnit() - { - FrequencyUnit oldUnit = Frequency.ToStringDefaultUnit; - Frequency.ToStringDefaultUnit = FrequencyUnit.Terahertz; - Frequency value = Frequency.From(1, FrequencyUnit.Terahertz); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(FrequencyUnit.Terahertz); - Frequency.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs index 3fee97a04e..f740691f61 100644 --- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs @@ -313,327 +313,5 @@ public void EqualsReturnsFalseOnNull() Information bit = Information.FromBits(1); Assert.IsFalse(bit.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Information.ToStringDefaultUnit = InformationUnit.Bit; - Information bit = Information.FromBits(1); - string bitString = bit.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit), bitString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithBitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Bit; - Information value = Information.From(1, InformationUnit.Bit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Bit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithByteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Byte; - Information value = Information.From(1, InformationUnit.Byte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Byte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithExabitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exabit; - Information value = Information.From(1, InformationUnit.Exabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithExabyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exabyte; - Information value = Information.From(1, InformationUnit.Exabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithExbibitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exbibit; - Information value = Information.From(1, InformationUnit.Exbibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithExbibyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Exbibyte; - Information value = Information.From(1, InformationUnit.Exbibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Exbibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGibibitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gibibit; - Information value = Information.From(1, InformationUnit.Gibibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGibibyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gibibyte; - Information value = Information.From(1, InformationUnit.Gibibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gibibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGigabitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gigabit; - Information value = Information.From(1, InformationUnit.Gigabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGigabyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Gigabyte; - Information value = Information.From(1, InformationUnit.Gigabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Gigabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKibibitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kibibit; - Information value = Information.From(1, InformationUnit.Kibibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKibibyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kibibyte; - Information value = Information.From(1, InformationUnit.Kibibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kibibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilobitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kilobit; - Information value = Information.From(1, InformationUnit.Kilobit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilobyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Kilobyte; - Information value = Information.From(1, InformationUnit.Kilobyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Kilobyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMebibitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Mebibit; - Information value = Information.From(1, InformationUnit.Mebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMebibyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Mebibyte; - Information value = Information.From(1, InformationUnit.Mebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Mebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegabitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Megabit; - Information value = Information.From(1, InformationUnit.Megabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegabyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Megabyte; - Information value = Information.From(1, InformationUnit.Megabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Megabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPebibitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Pebibit; - Information value = Information.From(1, InformationUnit.Pebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPebibyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Pebibyte; - Information value = Information.From(1, InformationUnit.Pebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Pebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPetabitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Petabit; - Information value = Information.From(1, InformationUnit.Petabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPetabyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Petabyte; - Information value = Information.From(1, InformationUnit.Petabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Petabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTebibitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Tebibit; - Information value = Information.From(1, InformationUnit.Tebibit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTebibyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Tebibyte; - Information value = Information.From(1, InformationUnit.Tebibyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Tebibyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTerabitAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Terabit; - Information value = Information.From(1, InformationUnit.Terabit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabit); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTerabyteAsDefualtUnit() - { - InformationUnit oldUnit = Information.ToStringDefaultUnit; - Information.ToStringDefaultUnit = InformationUnit.Terabyte; - Information value = Information.From(1, InformationUnit.Terabyte); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(InformationUnit.Terabyte); - Information.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs index 1c9476bff4..b22eb12e06 100644 --- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs @@ -205,111 +205,5 @@ public void EqualsReturnsFalseOnNull() KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); Assert.IsFalse(squaremeterpersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; - KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1); - string squaremeterpersecondString = squaremeterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond), squaremeterpersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentistokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Centistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Centistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Centistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecistokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Decistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Decistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Decistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilostokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Kilostokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Kilostokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Kilostokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrostokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Microstokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Microstokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Microstokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillistokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Millistokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Millistokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Millistokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanostokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Nanostokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Nanostokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Nanostokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithSquareMeterPerSecondAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.SquareMeterPerSecond; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.SquareMeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.SquareMeterPerSecond); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithStokesAsDefualtUnit() - { - KinematicViscosityUnit oldUnit = KinematicViscosity.ToStringDefaultUnit; - KinematicViscosity.ToStringDefaultUnit = KinematicViscosityUnit.Stokes; - KinematicViscosity value = KinematicViscosity.From(1, KinematicViscosityUnit.Stokes); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(KinematicViscosityUnit.Stokes); - KinematicViscosity.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs index 0f8b20de2e..a247b5798b 100644 --- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs @@ -241,183 +241,5 @@ public void EqualsReturnsFalseOnNull() Length meter = Length.FromMeters(1); Assert.IsFalse(meter.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Length.ToStringDefaultUnit = LengthUnit.Meter; - Length meter = Length.FromMeters(1); - string meterString = meter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter), meterString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Centimeter; - Length value = Length.From(1, LengthUnit.Centimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Centimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecimeterAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Decimeter; - Length value = Length.From(1, LengthUnit.Decimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Decimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithFootAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Foot; - Length value = Length.From(1, LengthUnit.Foot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Foot); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithInchAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Inch; - Length value = Length.From(1, LengthUnit.Inch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Inch); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilometerAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Kilometer; - Length value = Length.From(1, LengthUnit.Kilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Kilometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMeterAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Meter; - Length value = Length.From(1, LengthUnit.Meter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Meter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicroinchAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Microinch; - Length value = Length.From(1, LengthUnit.Microinch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Microinch); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrometerAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Micrometer; - Length value = Length.From(1, LengthUnit.Micrometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Micrometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Mil; - Length value = Length.From(1, LengthUnit.Mil); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mil); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMileAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Mile; - Length value = Length.From(1, LengthUnit.Mile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Mile); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillimeterAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Millimeter; - Length value = Length.From(1, LengthUnit.Millimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Millimeter); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanometerAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Nanometer; - Length value = Length.From(1, LengthUnit.Nanometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Nanometer); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNauticalMileAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.NauticalMile; - Length value = Length.From(1, LengthUnit.NauticalMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.NauticalMile); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithYardAsDefualtUnit() - { - LengthUnit oldUnit = Length.ToStringDefaultUnit; - Length.ToStringDefaultUnit = LengthUnit.Yard; - Length value = Length.From(1, LengthUnit.Yard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LengthUnit.Yard); - Length.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs index 0d8ddee27e..dac295d95d 100644 --- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs @@ -173,39 +173,5 @@ public void EqualsReturnsFalseOnNull() Level decibel = Level.FromDecibels(1); Assert.IsFalse(decibel.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Level.ToStringDefaultUnit = LevelUnit.Decibel; - Level decibel = Level.FromDecibels(1); - string decibelString = decibel.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel), decibelString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibelAsDefualtUnit() - { - LevelUnit oldUnit = Level.ToStringDefaultUnit; - Level.ToStringDefaultUnit = LevelUnit.Decibel; - Level value = Level.From(1, LevelUnit.Decibel); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Decibel); - Level.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNeperAsDefualtUnit() - { - LevelUnit oldUnit = Level.ToStringDefaultUnit; - Level.ToStringDefaultUnit = LevelUnit.Neper; - Level value = Level.From(1, LevelUnit.Neper); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(LevelUnit.Neper); - Level.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs index 5899d94b1c..583c7cf5dc 100644 --- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs @@ -217,135 +217,5 @@ public void EqualsReturnsFalseOnNull() MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); Assert.IsFalse(grampersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; - MassFlow grampersecond = MassFlow.FromGramsPerSecond(1); - string grampersecondString = grampersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond), grampersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentigramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.CentigramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.CentigramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.CentigramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecagramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.DecagramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.DecagramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecagramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecigramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.DecigramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.DecigramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.DecigramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.GramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.GramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.GramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHectogramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.HectogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.HectogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.HectogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.KilogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.KilogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.KilogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrogramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.MicrogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.MicrogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MicrogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilligramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.MilligramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.MilligramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.MilligramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanogramPerSecondAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.NanogramPerSecond; - MassFlow value = MassFlow.From(1, MassFlowUnit.NanogramPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.NanogramPerSecond); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonnePerDayAsDefualtUnit() - { - MassFlowUnit oldUnit = MassFlow.ToStringDefaultUnit; - MassFlow.ToStringDefaultUnit = MassFlowUnit.TonnePerDay; - MassFlow value = MassFlow.From(1, MassFlowUnit.TonnePerDay); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassFlowUnit.TonnePerDay); - MassFlow.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs index a439829b6f..7775d245e0 100644 --- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs @@ -259,219 +259,5 @@ public void EqualsReturnsFalseOnNull() Mass kilogram = Mass.FromKilograms(1); Assert.IsFalse(kilogram.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Mass.ToStringDefaultUnit = MassUnit.Kilogram; - Mass kilogram = Mass.FromKilograms(1); - string kilogramString = kilogram.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram), kilogramString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentigramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Centigram; - Mass value = Mass.From(1, MassUnit.Centigram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Centigram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecagramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Decagram; - Mass value = Mass.From(1, MassUnit.Decagram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decagram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecigramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Decigram; - Mass value = Mass.From(1, MassUnit.Decigram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Decigram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Gram; - Mass value = Mass.From(1, MassUnit.Gram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Gram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHectogramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Hectogram; - Mass value = Mass.From(1, MassUnit.Hectogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Hectogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Kilogram; - Mass value = Mass.From(1, MassUnit.Kilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilotonneAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Kilotonne; - Mass value = Mass.From(1, MassUnit.Kilotonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Kilotonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithLongTonAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.LongTon; - Mass value = Mass.From(1, MassUnit.LongTon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.LongTon); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegatonneAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Megatonne; - Mass value = Mass.From(1, MassUnit.Megatonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Megatonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrogramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Microgram; - Mass value = Mass.From(1, MassUnit.Microgram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Microgram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilligramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Milligram; - Mass value = Mass.From(1, MassUnit.Milligram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Milligram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanogramAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Nanogram; - Mass value = Mass.From(1, MassUnit.Nanogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Nanogram); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithOunceAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Ounce; - Mass value = Mass.From(1, MassUnit.Ounce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Ounce); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Pound; - Mass value = Mass.From(1, MassUnit.Pound); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Pound); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithShortTonAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.ShortTon; - Mass value = Mass.From(1, MassUnit.ShortTon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.ShortTon); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithStoneAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Stone; - Mass value = Mass.From(1, MassUnit.Stone); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Stone); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneAsDefualtUnit() - { - MassUnit oldUnit = Mass.ToStringDefaultUnit; - Mass.ToStringDefaultUnit = MassUnit.Tonne; - Mass value = Mass.From(1, MassUnit.Tonne); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(MassUnit.Tonne); - Mass.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs index 0b043b1eeb..4c505d6c08 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs @@ -173,39 +173,5 @@ public void EqualsReturnsFalseOnNull() PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); Assert.IsFalse(decibelwatt.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; - PowerRatio decibelwatt = PowerRatio.FromDecibelWatts(1); - string decibelwattString = decibelwatt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt), decibelwattString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibelMilliwattAsDefualtUnit() - { - PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelMilliwatt; - PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelMilliwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelMilliwatt); - PowerRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibelWattAsDefualtUnit() - { - PowerRatioUnit oldUnit = PowerRatio.ToStringDefaultUnit; - PowerRatio.ToStringDefaultUnit = PowerRatioUnit.DecibelWatt; - PowerRatio value = PowerRatio.From(1, PowerRatioUnit.DecibelWatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerRatioUnit.DecibelWatt); - PowerRatio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs index c3f1ac1490..221ceaf04f 100644 --- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs @@ -253,207 +253,5 @@ public void EqualsReturnsFalseOnNull() Power watt = Power.FromWatts(1); Assert.IsFalse(watt.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Power.ToStringDefaultUnit = PowerUnit.Watt; - Power watt = Power.FromWatts(1); - string wattString = watt.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt), wattString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithBoilerHorsepowerAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.BoilerHorsepower; - Power value = Power.From(1, PowerUnit.BoilerHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.BoilerHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithElectricalHorsepowerAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.ElectricalHorsepower; - Power value = Power.From(1, PowerUnit.ElectricalHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.ElectricalHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithFemtowattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Femtowatt; - Power value = Power.From(1, PowerUnit.Femtowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Femtowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGigawattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Gigawatt; - Power value = Power.From(1, PowerUnit.Gigawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Gigawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHydraulicHorsepowerAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.HydraulicHorsepower; - Power value = Power.From(1, PowerUnit.HydraulicHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.HydraulicHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilowattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Kilowatt; - Power value = Power.From(1, PowerUnit.Kilowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Kilowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMechanicalHorsepowerAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.MechanicalHorsepower; - Power value = Power.From(1, PowerUnit.MechanicalHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MechanicalHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegawattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Megawatt; - Power value = Power.From(1, PowerUnit.Megawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Megawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMetricHorsepowerAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.MetricHorsepower; - Power value = Power.From(1, PowerUnit.MetricHorsepower); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.MetricHorsepower); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrowattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Microwatt; - Power value = Power.From(1, PowerUnit.Microwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Microwatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilliwattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Milliwatt; - Power value = Power.From(1, PowerUnit.Milliwatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Milliwatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanowattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Nanowatt; - Power value = Power.From(1, PowerUnit.Nanowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Nanowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPetawattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Petawatt; - Power value = Power.From(1, PowerUnit.Petawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Petawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPicowattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Picowatt; - Power value = Power.From(1, PowerUnit.Picowatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Picowatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTerawattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Terawatt; - Power value = Power.From(1, PowerUnit.Terawatt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Terawatt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithWattAsDefualtUnit() - { - PowerUnit oldUnit = Power.ToStringDefaultUnit; - Power.ToStringDefaultUnit = PowerUnit.Watt; - Power value = Power.From(1, PowerUnit.Watt); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PowerUnit.Watt); - Power.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs index 2690b00c01..f9200bb56a 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs @@ -181,63 +181,5 @@ public void EqualsReturnsFalseOnNull() PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); Assert.IsFalse(pascalpersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; - PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); - string pascalpersecondString = pascalpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond), pascalpersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithAtmospherePerSecondAsDefualtUnit() - { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.AtmospherePerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.AtmospherePerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.AtmospherePerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopascalPerSecondAsDefualtUnit() - { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.KilopascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.KilopascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegapascalPerSecondAsDefualtUnit() - { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.MegapascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.MegapascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPascalPerSecondAsDefualtUnit() - { - PressureChangeRateUnit oldUnit = PressureChangeRate.ToStringDefaultUnit; - PressureChangeRate.ToStringDefaultUnit = PressureChangeRateUnit.PascalPerSecond; - PressureChangeRate value = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureChangeRateUnit.PascalPerSecond); - PressureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs index c5cb303c56..cf3b489a71 100644 --- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs @@ -355,411 +355,5 @@ public void EqualsReturnsFalseOnNull() Pressure pascal = Pressure.FromPascals(1); Assert.IsFalse(pascal.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Pressure.ToStringDefaultUnit = PressureUnit.Pascal; - Pressure pascal = Pressure.FromPascals(1); - string pascalString = pascal.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal), pascalString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithAtmosphereAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Atmosphere; - Pressure value = Pressure.From(1, PressureUnit.Atmosphere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Atmosphere); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithBarAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Bar; - Pressure value = Pressure.From(1, PressureUnit.Bar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Bar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentibarAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Centibar; - Pressure value = Pressure.From(1, PressureUnit.Centibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Centibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecapascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Decapascal; - Pressure value = Pressure.From(1, PressureUnit.Decapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecibarAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Decibar; - Pressure value = Pressure.From(1, PressureUnit.Decibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Decibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithGigapascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Gigapascal; - Pressure value = Pressure.From(1, PressureUnit.Gigapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Gigapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHectopascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Hectopascal; - Pressure value = Pressure.From(1, PressureUnit.Hectopascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Hectopascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilobarAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Kilobar; - Pressure value = Pressure.From(1, PressureUnit.Kilobar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilobar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareCentimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerSquareMillimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilogramForcePerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.KilogramForcePerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilogramForcePerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareCentimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerSquareMillimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilonewtonPerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.KilonewtonPerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilonewtonPerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Kilopascal; - Pressure value = Pressure.From(1, PressureUnit.Kilopascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Kilopascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareFootAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareFoot; - Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareFoot); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerSquareInchAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.KilopoundForcePerSquareInch; - Pressure value = Pressure.From(1, PressureUnit.KilopoundForcePerSquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.KilopoundForcePerSquareInch); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegabarAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Megabar; - Pressure value = Pressure.From(1, PressureUnit.Megabar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megabar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegapascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Megapascal; - Pressure value = Pressure.From(1, PressureUnit.Megapascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Megapascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicropascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Micropascal; - Pressure value = Pressure.From(1, PressureUnit.Micropascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Micropascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillibarAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Millibar; - Pressure value = Pressure.From(1, PressureUnit.Millibar); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Millibar); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareCentimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerSquareMillimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.NewtonPerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.NewtonPerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.NewtonPerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPascalAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Pascal; - Pressure value = Pressure.From(1, PressureUnit.Pascal); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Pascal); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareFootAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareFoot; - Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareFoot); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerSquareInchAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.PoundForcePerSquareInch; - Pressure value = Pressure.From(1, PressureUnit.PoundForcePerSquareInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.PoundForcePerSquareInch); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPsiAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Psi; - Pressure value = Pressure.From(1, PressureUnit.Psi); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Psi); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTechnicalAtmosphereAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TechnicalAtmosphere; - Pressure value = Pressure.From(1, PressureUnit.TechnicalAtmosphere); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TechnicalAtmosphere); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareCentimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareCentimeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareCentimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerSquareMillimeterAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.TonneForcePerSquareMillimeter; - Pressure value = Pressure.From(1, PressureUnit.TonneForcePerSquareMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.TonneForcePerSquareMillimeter); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTorrAsDefualtUnit() - { - PressureUnit oldUnit = Pressure.ToStringDefaultUnit; - Pressure.ToStringDefaultUnit = PressureUnit.Torr; - Pressure value = Pressure.From(1, PressureUnit.Torr); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(PressureUnit.Torr); - Pressure.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs index b44ed6fc54..212682834e 100644 --- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs @@ -193,87 +193,5 @@ public void EqualsReturnsFalseOnNull() Ratio decimalfraction = Ratio.FromDecimalFractions(1); Assert.IsFalse(decimalfraction.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; - Ratio decimalfraction = Ratio.FromDecimalFractions(1); - string decimalfractionString = decimalfraction.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction), decimalfractionString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecimalFractionAsDefualtUnit() - { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.DecimalFraction; - Ratio value = Ratio.From(1, RatioUnit.DecimalFraction); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.DecimalFraction); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPartPerBillionAsDefualtUnit() - { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerBillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerBillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerBillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPartPerMillionAsDefualtUnit() - { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerMillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerMillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerMillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPartPerThousandAsDefualtUnit() - { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerThousand; - Ratio value = Ratio.From(1, RatioUnit.PartPerThousand); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerThousand); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPartPerTrillionAsDefualtUnit() - { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.PartPerTrillion; - Ratio value = Ratio.From(1, RatioUnit.PartPerTrillion); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.PartPerTrillion); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPercentAsDefualtUnit() - { - RatioUnit oldUnit = Ratio.ToStringDefaultUnit; - Ratio.ToStringDefaultUnit = RatioUnit.Percent; - Ratio value = Ratio.From(1, RatioUnit.Percent); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RatioUnit.Percent); - Ratio.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index c10f65f14a..552412d898 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -205,111 +205,5 @@ public void EqualsReturnsFalseOnNull() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.IsFalse(radianpersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; - RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); - string radianpersecondString = radianpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond), radianpersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentiradianPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.CentiradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.CentiradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDeciradianPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.DeciradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.DeciradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicroradianPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MicroradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MicroradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilliradianPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.MilliradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.MilliradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanoradianPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.NanoradianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.NanoradianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithRadianPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RadianPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RadianPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerMinuteAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerMinute; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerMinute); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithRevolutionPerSecondAsDefualtUnit() - { - RotationalSpeedUnit oldUnit = RotationalSpeed.ToStringDefaultUnit; - RotationalSpeed.ToStringDefaultUnit = RotationalSpeedUnit.RevolutionPerSecond; - RotationalSpeed value = RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(RotationalSpeedUnit.RevolutionPerSecond); - RotationalSpeed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs index c99bc3cc49..7a5ba37b27 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs @@ -205,111 +205,5 @@ public void EqualsReturnsFalseOnNull() SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); Assert.IsFalse(jouleperkilogram.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; - SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1); - string jouleperkilogramString = jouleperkilogram.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram), jouleperkilogramString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCaloriePerGramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.CaloriePerGram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.CaloriePerGram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithJoulePerKilogramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.JoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.JoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilocaloriePerGramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilocaloriePerGram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilocaloriePerGram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilojoulePerKilogramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilojoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilojoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilowattHourPerKilogramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.KilowattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.KilowattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegajoulePerKilogramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegajoulePerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegajoulePerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMegawattHourPerKilogramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.MegawattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.MegawattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithWattHourPerKilogramAsDefualtUnit() - { - SpecificEnergyUnit oldUnit = SpecificEnergy.ToStringDefaultUnit; - SpecificEnergy.ToStringDefaultUnit = SpecificEnergyUnit.WattHourPerKilogram; - SpecificEnergy value = SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificEnergyUnit.WattHourPerKilogram); - SpecificEnergy.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs index ba994878eb..52535a75d2 100644 --- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs @@ -253,207 +253,5 @@ public void EqualsReturnsFalseOnNull() SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); Assert.IsFalse(newtonpercubicmeter.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; - SpecificWeight newtonpercubicmeter = SpecificWeight.FromNewtonsPerCubicMeter(1); - string newtonpercubicmeterString = newtonpercubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter), newtonpercubicmeterString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicCentimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForcePerCubicMillimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilogramForcePerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilogramForcePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilogramForcePerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicCentimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonPerCubicMillimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilonewtonPerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilonewtonPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilonewtonPerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicFootAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicFoot; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicFoot); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForcePerCubicInchAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.KilopoundForcePerCubicInch; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.KilopoundForcePerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.KilopoundForcePerCubicInch); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicCentimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonPerCubicMillimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.NewtonPerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.NewtonPerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.NewtonPerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicFootAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicFoot; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicFoot); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForcePerCubicInchAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.PoundForcePerCubicInch; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.PoundForcePerCubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.PoundForcePerCubicInch); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicCentimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicCentimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicCentimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForcePerCubicMillimeterAsDefualtUnit() - { - SpecificWeightUnit oldUnit = SpecificWeight.ToStringDefaultUnit; - SpecificWeight.ToStringDefaultUnit = SpecificWeightUnit.TonneForcePerCubicMillimeter; - SpecificWeight value = SpecificWeight.From(1, SpecificWeightUnit.TonneForcePerCubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpecificWeightUnit.TonneForcePerCubicMillimeter); - SpecificWeight.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 6c19e0ba22..c87c6c8bb8 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -229,159 +229,5 @@ public void EqualsReturnsFalseOnNull() Speed meterpersecond = Speed.FromMetersPerSecond(1); Assert.IsFalse(meterpersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; - Speed meterpersecond = Speed.FromMetersPerSecond(1); - string meterpersecondString = meterpersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond), meterpersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentimeterPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.CentimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.CentimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.CentimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecimeterPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.DecimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.DecimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.DecimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithFootPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.FootPerSecond; - Speed value = Speed.From(1, SpeedUnit.FootPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.FootPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerHourAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerHour; - Speed value = Speed.From(1, SpeedUnit.KilometerPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilometerPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.KilometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.KilometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.KilometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKnotAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.Knot; - Speed value = Speed.From(1, SpeedUnit.Knot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.Knot); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMeterPerHourAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerHour; - Speed value = Speed.From(1, SpeedUnit.MeterPerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMeterPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.MeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrometerPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MicrometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.MicrometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MicrometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilePerHourAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MilePerHour; - Speed value = Speed.From(1, SpeedUnit.MilePerHour); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MilePerHour); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillimeterPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.MillimeterPerSecond; - Speed value = Speed.From(1, SpeedUnit.MillimeterPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.MillimeterPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanometerPerSecondAsDefualtUnit() - { - SpeedUnit oldUnit = Speed.ToStringDefaultUnit; - Speed.ToStringDefaultUnit = SpeedUnit.NanometerPerSecond; - Speed value = Speed.From(1, SpeedUnit.NanometerPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(SpeedUnit.NanometerPerSecond); - Speed.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs index 82eaad3f4f..e5b1a8daf6 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs @@ -211,123 +211,5 @@ public void EqualsReturnsFalseOnNull() TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); Assert.IsFalse(degreecelsiuspersecond.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; - TemperatureChangeRate degreecelsiuspersecond = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1); - string degreecelsiuspersecondString = degreecelsiuspersecond.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond), degreecelsiuspersecondString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentidegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecadegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDecidegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.DegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.DegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHectodegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilodegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMicrodegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMillidegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNanodegreeCelsiusPerSecondAsDefualtUnit() - { - TemperatureChangeRateUnit oldUnit = TemperatureChangeRate.ToStringDefaultUnit; - TemperatureChangeRate.ToStringDefaultUnit = TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond; - TemperatureChangeRate value = TemperatureChangeRate.From(1, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); - TemperatureChangeRate.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs index 03c910379b..874ea01916 100644 --- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs @@ -205,111 +205,5 @@ public void EqualsReturnsFalseOnNull() Temperature kelvin = Temperature.FromKelvins(1); Assert.IsFalse(kelvin.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; - Temperature kelvin = Temperature.FromKelvins(1); - string kelvinString = kelvin.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin), kelvinString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeCelsiusAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeCelsius; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeCelsius); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeCelsius); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeDelisleAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeDelisle; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeDelisle); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeDelisle); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeFahrenheitAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeFahrenheit; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeFahrenheit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeFahrenheit); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeNewtonAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeNewton; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeNewton); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeNewton); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeRankineAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRankine; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeRankine); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRankine); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeReaumurAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeReaumur; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeReaumur); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeReaumur); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDegreeRoemerAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.DegreeRoemer; - Temperature value = Temperature.From(1, TemperatureUnit.DegreeRoemer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.DegreeRoemer); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKelvinAsDefualtUnit() - { - TemperatureUnit oldUnit = Temperature.ToStringDefaultUnit; - Temperature.ToStringDefaultUnit = TemperatureUnit.Kelvin; - Temperature value = Temperature.From(1, TemperatureUnit.Kelvin); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TemperatureUnit.Kelvin); - Temperature.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs index 6e772f465f..8b7469ba75 100644 --- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs @@ -253,207 +253,5 @@ public void EqualsReturnsFalseOnNull() Torque newtonmeter = Torque.FromNewtonMeters(1); Assert.IsFalse(newtonmeter.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; - Torque newtonmeter = Torque.FromNewtonMeters(1); - string newtonmeterString = newtonmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter), newtonmeterString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceCentimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceCentimeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilogramForceMillimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilogramForceMillimeter; - Torque value = Torque.From(1, TorqueUnit.KilogramForceMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilogramForceMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonCentimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonCentimeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilonewtonMillimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilonewtonMillimeter; - Torque value = Torque.From(1, TorqueUnit.KilonewtonMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilonewtonMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceFootAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceFoot; - Torque value = Torque.From(1, TorqueUnit.KilopoundForceFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceFoot); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithKilopoundForceInchAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.KilopoundForceInch; - Torque value = Torque.From(1, TorqueUnit.KilopoundForceInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.KilopoundForceInch); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonCentimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonCentimeter; - Torque value = Torque.From(1, TorqueUnit.NewtonCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonMeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMeter; - Torque value = Torque.From(1, TorqueUnit.NewtonMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithNewtonMillimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.NewtonMillimeter; - Torque value = Torque.From(1, TorqueUnit.NewtonMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.NewtonMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForceFootAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.PoundForceFoot; - Torque value = Torque.From(1, TorqueUnit.PoundForceFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceFoot); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithPoundForceInchAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.PoundForceInch; - Torque value = Torque.From(1, TorqueUnit.PoundForceInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.PoundForceInch); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForceCentimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceCentimeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceCentimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTonneForceMillimeterAsDefualtUnit() - { - TorqueUnit oldUnit = Torque.ToStringDefaultUnit; - Torque.ToStringDefaultUnit = TorqueUnit.TonneForceMillimeter; - Torque value = Torque.From(1, TorqueUnit.TonneForceMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(TorqueUnit.TonneForceMillimeter); - Torque.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs index f46f5b4f89..f6c0f92814 100644 --- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs @@ -163,27 +163,5 @@ public void EqualsReturnsFalseOnNull() VitaminA internationalunit = VitaminA.FromInternationalUnits(1); Assert.IsFalse(internationalunit.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; - VitaminA internationalunit = VitaminA.FromInternationalUnits(1); - string internationalunitString = internationalunit.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit), internationalunitString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithInternationalUnitAsDefualtUnit() - { - VitaminAUnit oldUnit = VitaminA.ToStringDefaultUnit; - VitaminA.ToStringDefaultUnit = VitaminAUnit.InternationalUnit; - VitaminA value = VitaminA.From(1, VitaminAUnit.InternationalUnit); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VitaminAUnit.InternationalUnit); - VitaminA.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 48e3bcbe99..ff47f26b60 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -301,291 +301,5 @@ public void EqualsReturnsFalseOnNull() Volume cubicmeter = Volume.FromCubicMeters(1); Assert.IsFalse(cubicmeter.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; - Volume cubicmeter = Volume.FromCubicMeters(1); - string cubicmeterString = cubicmeter.ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter), cubicmeterString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCentiliterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Centiliter; - Volume value = Volume.From(1, VolumeUnit.Centiliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Centiliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicCentimeterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicCentimeter; - Volume value = Volume.From(1, VolumeUnit.CubicCentimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicCentimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicDecimeterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicDecimeter; - Volume value = Volume.From(1, VolumeUnit.CubicDecimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicDecimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicFootAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicFoot; - Volume value = Volume.From(1, VolumeUnit.CubicFoot); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicFoot); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicInchAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicInch; - Volume value = Volume.From(1, VolumeUnit.CubicInch); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicInch); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicKilometerAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicKilometer; - Volume value = Volume.From(1, VolumeUnit.CubicKilometer); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicKilometer); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicMeterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMeter; - Volume value = Volume.From(1, VolumeUnit.CubicMeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicMileAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMile; - Volume value = Volume.From(1, VolumeUnit.CubicMile); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMile); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicMillimeterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicMillimeter; - Volume value = Volume.From(1, VolumeUnit.CubicMillimeter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicMillimeter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithCubicYardAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.CubicYard; - Volume value = Volume.From(1, VolumeUnit.CubicYard); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.CubicYard); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDeciliterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Deciliter; - Volume value = Volume.From(1, VolumeUnit.Deciliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Deciliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithHectoliterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Hectoliter; - Volume value = Volume.From(1, VolumeUnit.Hectoliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Hectoliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithImperialGallonAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.ImperialGallon; - Volume value = Volume.From(1, VolumeUnit.ImperialGallon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialGallon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithImperialOunceAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.ImperialOunce; - Volume value = Volume.From(1, VolumeUnit.ImperialOunce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.ImperialOunce); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithLiterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Liter; - Volume value = Volume.From(1, VolumeUnit.Liter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Liter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMetricCupAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.MetricCup; - Volume value = Volume.From(1, VolumeUnit.MetricCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.MetricCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithMilliliterAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Milliliter; - Volume value = Volume.From(1, VolumeUnit.Milliliter); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Milliliter); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTablespoonAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Tablespoon; - Volume value = Volume.From(1, VolumeUnit.Tablespoon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Tablespoon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithTeaspoonAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.Teaspoon; - Volume value = Volume.From(1, VolumeUnit.Teaspoon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.Teaspoon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithUsCustomaryCupAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsCustomaryCup; - Volume value = Volume.From(1, VolumeUnit.UsCustomaryCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsCustomaryCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithUsGallonAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsGallon; - Volume value = Volume.From(1, VolumeUnit.UsGallon); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsGallon); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithUsLegalCupAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsLegalCup; - Volume value = Volume.From(1, VolumeUnit.UsLegalCup); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsLegalCup); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithUsOunceAsDefualtUnit() - { - VolumeUnit oldUnit = Volume.ToStringDefaultUnit; - Volume.ToStringDefaultUnit = VolumeUnit.UsOunce; - Volume value = Volume.From(1, VolumeUnit.UsOunce); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation(VolumeUnit.UsOunce); - Volume.ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - } } diff --git a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs index f25926111b..fb530ed0cd 100644 --- a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs +++ b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs @@ -20,6 +20,7 @@ // THE SOFTWARE. using System; +using System.Diagnostics; using System.Globalization; using UnitsNet.Units; diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 index d6a8f60550..3eadcdfb21 100644 --- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 @@ -194,31 +194,7 @@ namespace UnitsNet.Tests $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); Assert.IsFalse($baseUnitVariableName.Equals(null)); } - - [Test] - public void ToStringReturnsCorrectNumberAndUnitWithDefaultUnit() - { - $className.ToStringDefaultUnit = $($unitEnumName).$($baseUnit.SingularName); - $className $baseUnitVariableName = $className.From$baseUnitPluralName(1); - string $($baseUnitVariableName)String = $($baseUnitVariableName).ToString(); - Assert.AreEqual("1 " + UnitSystem.GetCached(null).GetDefaultAbbreviation($($className)Unit.$($baseUnit.SingularName)), $($baseUnitVariableName)String); - } - -"@; foreach ($unit in $units) {@" - [Test] - public void ToStringReturnsCorrectNumberAndUnitWith$($unit.SingularName)AsDefualtUnit() - { - $($unitEnumName) oldUnit = $($className).ToStringDefaultUnit; - $($className).ToStringDefaultUnit = $($unitEnumName).$($unit.SingularName); - $($className) value = $($className).From(1, $($unitEnumName).$($unit.SingularName)); - string valueString = value.ToString(); - string unitString = UnitSystem.GetCached(null).GetDefaultAbbreviation($($unitEnumName).$($unit.SingularName)); - $($className).ToStringDefaultUnit = oldUnit; - Assert.AreEqual("1 " + unitString, valueString); - } - -"@; }@" } } "@; -} \ No newline at end of file +}