Conversion between pressure measurement references

CodeGen/CodeGen.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.1</TargetFramework>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

UnitsNet.Serialization.JsonNet.CompatibilityTests/UnitsNet.Serialization.JsonNet.CompatibilityTests.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
     <RootNamespace>UnitsNet.Serialization.JsonNet.CompatibilityTests</RootNamespace>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>latest</LangVersion>
     <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>

UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
     <RootNamespace>UnitsNet.Serialization.JsonNet.Tests</RootNamespace>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>latest</LangVersion>
     <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>

UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj

@@ -19,7 +19,7 @@
   <!-- Assembly and msbuild properties -->
   <PropertyGroup>
     <AssemblyVersion>4.0.0.0</AssemblyVersion> <!-- Should reflect major part of Version -->
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>latest</LangVersion>
     <RootNamespace>UnitsNet.Serialization.JsonNet</RootNamespace>
     <TargetFrameworks>netstandard2.0;net40</TargetFrameworks>
     <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>

UnitsNet.Tests/CustomCode/PressureTests.cs

@@ -1,13 +1,16 @@
 // Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
 
+using System;
+using UnitsNet.CustomCode.Units;
+using UnitsNet.CustomCode.Wrappers;
 using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class PressureTests : PressureTestsBase
     {
-        protected override double AtmospheresInOnePascal => 9.8692*1E-6;
+        protected override double AtmospheresInOnePascal => 9.8692 * 1E-6;
 
         protected override double BarsInOnePascal => 1E-5;
 
@@ -47,15 +50,15 @@ public class PressureTests : PressureTestsBase
 
         protected override double PoundsForcePerSquareInchInOnePascal => 1.450377377302092e-4;
 
-        protected override double TechnicalAtmospheresInOnePascal => 1.0197*1E-5;
+        protected override double TechnicalAtmospheresInOnePascal => 1.0197 * 1E-5;
 
         protected override double TonnesForcePerSquareCentimeterInOnePascal => 1.019716212977928e-8;
 
         protected override double TonnesForcePerSquareMeterInOnePascal => 1.019716212977928e-4;
 
         protected override double TonnesForcePerSquareMillimeterInOnePascal => 1.019716212977928e-10;
 
-        protected override double TorrsInOnePascal => 7.5006*1E-3;
+        protected override double TorrsInOnePascal => 7.5006 * 1E-3;
 
         protected override double CentibarsInOnePascal => 1e-3;
 
@@ -90,32 +93,144 @@ public class PressureTests : PressureTestsBase
 
         protected override double MillipascalsInOnePascal => 1e3;
 
+        [Fact]
+        public void Absolute_WithAbsolutePressureReference_IsEqual()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3), PressureReference.Absolute);
+            AssertEx.EqualTolerance(3, refPressure.Absolute.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Absolute_WithDefaultPressureReference_IsEqual()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3));
+            AssertEx.EqualTolerance(3, refPressure.Absolute.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Absolute_WithGaugePressureReference_IsOneMore()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3), PressureReference.Gauge);
+            AssertEx.EqualTolerance(4, refPressure.Absolute.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Absolute_WithNegativeAbsolutePressureReference_ThrowsArgumentOutOfRangeException()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(-3), PressureReference.Absolute);
+            Assert.Throws<ArgumentOutOfRangeException>(() => refPressure.Absolute.Atmospheres);
+        }
+
+        [Fact]
+        public void Absolute_WithNegativeGaugePressureReference_ThrowsArgumentOutOfRangeException()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(-3), PressureReference.Gauge);
+            Assert.Throws<ArgumentOutOfRangeException>(() => refPressure.Absolute.Atmospheres);
+        }
+
+        [Fact]
+        public void Absolute_WithVacuumPressureReference_IsOneLessAtmosphereNegative()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(1), PressureReference.Vacuum);
+            AssertEx.EqualTolerance(0, refPressure.Absolute.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Absolute_WithVacuumPressureReference_ThrowsArgumentOutOfRangeException()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3), PressureReference.Vacuum);
+            Assert.Throws<ArgumentOutOfRangeException>(() => refPressure.Absolute.Atmospheres);
+        }
+
         [Fact]
         public void AreaTimesPressureEqualsForce()
         {
-            Force force = Area.FromSquareMeters(3)*Pressure.FromPascals(20);
+            var force = Area.FromSquareMeters(3) * Pressure.FromPascals(20);
             Assert.Equal(force, Force.FromNewtons(60));
         }
 
         [Fact]
-        public void PressureTimesAreaEqualsForce()
+        public void Gauge_WithDefaultPressureReference_IsOneLessAtmosphere()
         {
-            Force force = Pressure.FromPascals(20)*Area.FromSquareMeters(3);
-            Assert.Equal(force, Force.FromNewtons(60));
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3));
+            AssertEx.EqualTolerance(2, refPressure.Gauge.Atmospheres, AtmospheresTolerance);
         }
 
         [Fact]
-        public void PressureDividedBySpecificWeightEqualsLength()
+        public void Gauge_WithGaugePressureReference_IsEqual()
         {
-            Length length = Pressure.FromPascals(20) / SpecificWeight.FromNewtonsPerCubicMeter(2);
-            Assert.Equal(Length.FromMeters(10), length);
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3), PressureReference.Gauge);
+            AssertEx.EqualTolerance(3, refPressure.Gauge.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Gauge_WithVacuumPressureReference_IsNegative()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(1), PressureReference.Vacuum);
+            AssertEx.EqualTolerance(-1, refPressure.Gauge.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Gauge_WithVacuumPressureReference_ThrowsArgumentOutOfRangeException()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3), PressureReference.Vacuum);
+            Assert.Throws<ArgumentOutOfRangeException>(() => refPressure.Gauge.Atmospheres);
         }
 
         [Fact]
         public void PressureDividedByLengthEqualsSpecificWeight()
         {
-            SpecificWeight specificWeight = Pressure.FromPascals(20) / Length.FromMeters(2);
+            var specificWeight = Pressure.FromPascals(20) / Length.FromMeters(2);
             Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(10), specificWeight);
         }
+
+        [Fact]
+        public void PressureDividedBySpecificWeightEqualsLength()
+        {
+            var length = Pressure.FromPascals(20) / SpecificWeight.FromNewtonsPerCubicMeter(2);
+            Assert.Equal(Length.FromMeters(10), length);
+        }
+
+        [Fact]
+        public void PressureTimesAreaEqualsForce()
+        {
+            var force = Pressure.FromPascals(20) * Area.FromSquareMeters(3);
+            Assert.Equal(force, Force.FromNewtons(60));
+        }
+
+        // Pressure Measurement References
+        [Fact]
+        public void Reference_WithDefaultPressureReference_IsAbsolute()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3));
+            Equals(PressureReference.Absolute, refPressure.Reference);
+        }
+
+        [Fact]
+        public void ReferencesDoesNotContainUndefined()
+        {
+            Assert.DoesNotContain(PressureReference.Undefined, ReferencePressure.References);
+        }
+
+        [Fact]
+        public void Vacuum_WithDefaultPressureReference_IsOneLessAtmosphereNegative()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3));
+            AssertEx.EqualTolerance(-2, refPressure.Vacuum.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Vacuum_WithGaugePressureReference_IsNegative()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(3), PressureReference.Gauge);
+            AssertEx.EqualTolerance(-3, refPressure.Vacuum.Atmospheres, AtmospheresTolerance);
+        }
+
+        [Fact]
+        public void Vacuum_WithVacuumPressureReference_IsEqual()
+        {
+            var refPressure = new ReferencePressure(Pressure.FromAtmospheres(1), PressureReference.Vacuum);
+            AssertEx.EqualTolerance(1, refPressure.Vacuum.Atmospheres, AtmospheresTolerance);
+        }
     }
 }

UnitsNet.Tests/UnitsNet.Tests.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
     <RootNamespace>UnitsNet.Tests</RootNamespace>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>latest</LangVersion>
     <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>

UnitsNet/CustomCode/Units/PressureReference.cs

@@ -0,0 +1,34 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
+
+// ReSharper disable once CheckNamespace
+namespace UnitsNet.CustomCode.Units
+{
+    // Disable missing XML comment warnings for the generated unit enums.
+    #pragma warning disable 1591
+
+    public enum PressureReference
+    {
+        Undefined = 0,
+        Absolute,
+        Gauge,
+        Vacuum,
+    }
+#pragma warning restore 1591
+}