Merge pull request #164 from eriove/feature/minandmaxvalue

Add Min and MaxValue to unit classes

Author: angularsen

UnitsNet.Tests/CustomCode/InformationTests.cs

@@ -84,5 +84,17 @@ public void OneKBHas1000Bytes()
         {
             Assert.AreEqual(1000, Information.FromKilobytes(1).Bytes);
         }
+
+        [Test]
+        public void MaxValueIsCorrectForUnitWithBaseTypeDecimal()
+        {
+            Assert.AreEqual(decimal.MaxValue, Information.MaxValue.Bits);
+        }
+
+        [Test]
+        public void MinValueIsCorrectForUnitWithBaseTypeDecimal()
+        {
+            Assert.AreEqual(decimal.MinValue, Information.MinValue.Bits);
+        }
     }
 }

UnitsNet.Tests/CustomCode/LengthTests.cs

@@ -123,5 +123,17 @@ public void ToStringReturnsCorrectNumberAndUnitWithCentimeterAsDefualtUnit()
             Length.ToStringDefaultUnit = oldUnit;
             Assert.AreEqual("2 cm", valueString);
         }
+
+        [Test]
+        public void MaxValueIsCorrectForUnitWithBaseTypeDouble()
+        {
+            Assert.AreEqual(double.MaxValue, Length.MaxValue.Meters);
+        }
+
+        [Test]
+        public void MinValueIsCorrectForUnitWithBaseTypeDouble()
+        {
+            Assert.AreEqual(double.MinValue, Length.MinValue.Meters);
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/Acceleration.g.cs

@@ -828,5 +828,27 @@ public string ToString(AccelerationUnit unit, [CanBeNull] Culture culture, [NotN
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of Acceleration
+        /// </summary>
+        public static Acceleration MaxValue
+        {
+            get
+            {
+                return new Acceleration(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of Acceleration
+        /// </summary>
+        public static Acceleration MinValue
+        {
+            get
+            {
+                return new Acceleration(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/AmplitudeRatio.g.cs

@@ -688,5 +688,27 @@ public string ToString(AmplitudeRatioUnit unit, [CanBeNull] Culture culture, [No
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of AmplitudeRatio
+        /// </summary>
+        public static AmplitudeRatio MaxValue
+        {
+            get
+            {
+                return new AmplitudeRatio(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of AmplitudeRatio
+        /// </summary>
+        public static AmplitudeRatio MinValue
+        {
+            get
+            {
+                return new AmplitudeRatio(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs

@@ -1050,5 +1050,27 @@ public string ToString(AngleUnit unit, [CanBeNull] Culture culture, [NotNull] st
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of Angle
+        /// </summary>
+        public static Angle MaxValue
+        {
+            get
+            {
+                return new Angle(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of Angle
+        /// </summary>
+        public static Angle MinValue
+        {
+            get
+            {
+                return new Angle(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/Area.g.cs

@@ -939,5 +939,27 @@ public string ToString(AreaUnit unit, [CanBeNull] Culture culture, [NotNull] str
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of Area
+        /// </summary>
+        public static Area MaxValue
+        {
+            get
+            {
+                return new Area(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of Area
+        /// </summary>
+        public static Area MinValue
+        {
+            get
+            {
+                return new Area(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/BrakeSpecificFuelConsumption.g.cs

@@ -680,5 +680,27 @@ public string ToString(BrakeSpecificFuelConsumptionUnit unit, [CanBeNull] Cultur
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of BrakeSpecificFuelConsumption
+        /// </summary>
+        public static BrakeSpecificFuelConsumption MaxValue
+        {
+            get
+            {
+                return new BrakeSpecificFuelConsumption(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of BrakeSpecificFuelConsumption
+        /// </summary>
+        public static BrakeSpecificFuelConsumption MinValue
+        {
+            get
+            {
+                return new BrakeSpecificFuelConsumption(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/Density.g.cs

@@ -939,5 +939,27 @@ public string ToString(DensityUnit unit, [CanBeNull] Culture culture, [NotNull]
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of Density
+        /// </summary>
+        public static Density MaxValue
+        {
+            get
+            {
+                return new Density(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of Density
+        /// </summary>
+        public static Density MinValue
+        {
+            get
+            {
+                return new Density(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/Duration.g.cs

@@ -939,5 +939,27 @@ public string ToString(DurationUnit unit, [CanBeNull] Culture culture, [NotNull]
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of Duration
+        /// </summary>
+        public static Duration MaxValue
+        {
+            get
+            {
+                return new Duration(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of Duration
+        /// </summary>
+        public static Duration MinValue
+        {
+            get
+            {
+                return new Duration(double.MinValue);
+            }
+        }
     }
 }

UnitsNet/GeneratedCode/UnitClasses/DynamicViscosity.g.cs

@@ -754,5 +754,27 @@ public string ToString(DynamicViscosityUnit unit, [CanBeNull] Culture culture, [
             object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
             return string.Format(formatProvider, format, formatArgs);
         }
+
+        /// <summary>
+        /// Represents the largest possible value of DynamicViscosity
+        /// </summary>
+        public static DynamicViscosity MaxValue
+        {
+            get
+            {
+                return new DynamicViscosity(double.MaxValue);
+            }
+        }
+
+        /// <summary>
+        /// Represents the smallest possible value of DynamicViscosity
+        /// </summary>
+        public static DynamicViscosity MinValue
+        {
+            get
+            {
+                return new DynamicViscosity(double.MinValue);
+            }
+        }
     }
 }