CompressibilityTestsBase.g.cs

//------------------------------------------------------------------------------
// <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 (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using UnitsNet.Tests.TestsBase;
using UnitsNet.Units;
using Xunit;

// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else?
#pragma warning disable 1718

// ReSharper disable once CheckNamespace
namespace UnitsNet.Tests
{
    /// <summary>
    /// Test of Compressibility.
    /// </summary>
// ReSharper disable once PartialTypeWithSinglePart
    public abstract partial class CompressibilityTestsBase : QuantityTestsBase
    {
        protected abstract double InverseAtmospheresInOneInversePascal { get; }
        protected abstract double InverseBarsInOneInversePascal { get; }
        protected abstract double InverseKilopascalsInOneInversePascal { get; }
        protected abstract double InverseMegapascalsInOneInversePascal { get; }
        protected abstract double InverseMillibarsInOneInversePascal { get; }
        protected abstract double InversePascalsInOneInversePascal { get; }
        protected abstract double InversePoundsForcePerSquareInchInOneInversePascal { get; }

// ReSharper disable VirtualMemberNeverOverriden.Global
        protected virtual double InverseAtmospheresTolerance { get { return 1e-5; } }
        protected virtual double InverseBarsTolerance { get { return 1e-5; } }
        protected virtual double InverseKilopascalsTolerance { get { return 1e-5; } }
        protected virtual double InverseMegapascalsTolerance { get { return 1e-5; } }
        protected virtual double InverseMillibarsTolerance { get { return 1e-5; } }
        protected virtual double InversePascalsTolerance { get { return 1e-5; } }
        protected virtual double InversePoundsForcePerSquareInchTolerance { get { return 1e-5; } }
// ReSharper restore VirtualMemberNeverOverriden.Global

        protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(CompressibilityUnit unit)
        {
            return unit switch
            {
                CompressibilityUnit.InverseAtmosphere => (InverseAtmospheresInOneInversePascal, InverseAtmospheresTolerance),
                CompressibilityUnit.InverseBar => (InverseBarsInOneInversePascal, InverseBarsTolerance),
                CompressibilityUnit.InverseKilopascal => (InverseKilopascalsInOneInversePascal, InverseKilopascalsTolerance),
                CompressibilityUnit.InverseMegapascal => (InverseMegapascalsInOneInversePascal, InverseMegapascalsTolerance),
                CompressibilityUnit.InverseMillibar => (InverseMillibarsInOneInversePascal, InverseMillibarsTolerance),
                CompressibilityUnit.InversePascal => (InversePascalsInOneInversePascal, InversePascalsTolerance),
                CompressibilityUnit.InversePoundForcePerSquareInch => (InversePoundsForcePerSquareInchInOneInversePascal, InversePoundsForcePerSquareInchTolerance),
                _ => throw new NotSupportedException()
            };
        }

        public static IEnumerable<object[]> UnitTypes = new List<object[]>
        {
            new object[] { CompressibilityUnit.InverseAtmosphere },
            new object[] { CompressibilityUnit.InverseBar },
            new object[] { CompressibilityUnit.InverseKilopascal },
            new object[] { CompressibilityUnit.InverseMegapascal },
            new object[] { CompressibilityUnit.InverseMillibar },
            new object[] { CompressibilityUnit.InversePascal },
            new object[] { CompressibilityUnit.InversePoundForcePerSquareInch },
        };

        [Fact]
        public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
        {
            var quantity = new Compressibility();
            Assert.Equal(0, quantity.Value);
            Assert.Equal(CompressibilityUnit.InversePascal, quantity.Unit);
        }

        [Fact]
        public void Ctor_WithInfinityValue_ThrowsArgumentException()
        {
            Assert.Throws<ArgumentException>(() => new Compressibility(double.PositiveInfinity, CompressibilityUnit.InversePascal));
            Assert.Throws<ArgumentException>(() => new Compressibility(double.NegativeInfinity, CompressibilityUnit.InversePascal));
        }

        [Fact]
        public void Ctor_WithNaNValue_ThrowsArgumentException()
        {
            Assert.Throws<ArgumentException>(() => new Compressibility(double.NaN, CompressibilityUnit.InversePascal));
        }

        [Fact]
        public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new Compressibility(value: 1, unitSystem: null));
        }

        [Fact]
        public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
        {
            Func<object> TestCode = () => new Compressibility(value: 1, unitSystem: UnitSystem.SI);
            if (SupportsSIUnitSystem)
            {
                var quantity = (Compressibility) TestCode();
                Assert.Equal(1, quantity.Value);
            }
            else
            {
                Assert.Throws<ArgumentException>(TestCode);
            }
        }

        [Fact]
        public void Compressibility_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
        {
            var quantity = new Compressibility(1, CompressibilityUnit.InversePascal);

            QuantityInfo<CompressibilityUnit> quantityInfo = quantity.QuantityInfo;

            Assert.Equal(Compressibility.Zero, quantityInfo.Zero);
            Assert.Equal("Compressibility", quantityInfo.Name);

            var units = EnumUtils.GetEnumValues<CompressibilityUnit>().OrderBy(x => x.ToString()).ToArray();
            var unitNames = units.Select(x => x.ToString());
        }

        [Fact]
        public void InversePascalToCompressibilityUnits()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            AssertEx.EqualTolerance(InverseAtmospheresInOneInversePascal, inversepascal.InverseAtmospheres, InverseAtmospheresTolerance);
            AssertEx.EqualTolerance(InverseBarsInOneInversePascal, inversepascal.InverseBars, InverseBarsTolerance);
            AssertEx.EqualTolerance(InverseKilopascalsInOneInversePascal, inversepascal.InverseKilopascals, InverseKilopascalsTolerance);
            AssertEx.EqualTolerance(InverseMegapascalsInOneInversePascal, inversepascal.InverseMegapascals, InverseMegapascalsTolerance);
            AssertEx.EqualTolerance(InverseMillibarsInOneInversePascal, inversepascal.InverseMillibars, InverseMillibarsTolerance);
            AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(InversePoundsForcePerSquareInchInOneInversePascal, inversepascal.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance);
        }

        [Fact]
        public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
        {
            var quantity00 = Compressibility.From(1, CompressibilityUnit.InverseAtmosphere);
            AssertEx.EqualTolerance(1, quantity00.InverseAtmospheres, InverseAtmospheresTolerance);
            Assert.Equal(CompressibilityUnit.InverseAtmosphere, quantity00.Unit);

            var quantity01 = Compressibility.From(1, CompressibilityUnit.InverseBar);
            AssertEx.EqualTolerance(1, quantity01.InverseBars, InverseBarsTolerance);
            Assert.Equal(CompressibilityUnit.InverseBar, quantity01.Unit);

            var quantity02 = Compressibility.From(1, CompressibilityUnit.InverseKilopascal);
            AssertEx.EqualTolerance(1, quantity02.InverseKilopascals, InverseKilopascalsTolerance);
            Assert.Equal(CompressibilityUnit.InverseKilopascal, quantity02.Unit);

            var quantity03 = Compressibility.From(1, CompressibilityUnit.InverseMegapascal);
            AssertEx.EqualTolerance(1, quantity03.InverseMegapascals, InverseMegapascalsTolerance);
            Assert.Equal(CompressibilityUnit.InverseMegapascal, quantity03.Unit);

            var quantity04 = Compressibility.From(1, CompressibilityUnit.InverseMillibar);
            AssertEx.EqualTolerance(1, quantity04.InverseMillibars, InverseMillibarsTolerance);
            Assert.Equal(CompressibilityUnit.InverseMillibar, quantity04.Unit);

            var quantity05 = Compressibility.From(1, CompressibilityUnit.InversePascal);
            AssertEx.EqualTolerance(1, quantity05.InversePascals, InversePascalsTolerance);
            Assert.Equal(CompressibilityUnit.InversePascal, quantity05.Unit);

            var quantity06 = Compressibility.From(1, CompressibilityUnit.InversePoundForcePerSquareInch);
            AssertEx.EqualTolerance(1, quantity06.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance);
            Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, quantity06.Unit);

        }

        [Fact]
        public void FromInversePascals_WithInfinityValue_ThrowsArgumentException()
        {
            Assert.Throws<ArgumentException>(() => Compressibility.FromInversePascals(double.PositiveInfinity));
            Assert.Throws<ArgumentException>(() => Compressibility.FromInversePascals(double.NegativeInfinity));
        }

        [Fact]
        public void FromInversePascals_WithNanValue_ThrowsArgumentException()
        {
            Assert.Throws<ArgumentException>(() => Compressibility.FromInversePascals(double.NaN));
        }

        [Fact]
        public void As()
        {
            var inversepascal = Compressibility.FromInversePascals(1);
            AssertEx.EqualTolerance(InverseAtmospheresInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseAtmosphere), InverseAtmospheresTolerance);
            AssertEx.EqualTolerance(InverseBarsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseBar), InverseBarsTolerance);
            AssertEx.EqualTolerance(InverseKilopascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseKilopascal), InverseKilopascalsTolerance);
            AssertEx.EqualTolerance(InverseMegapascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseMegapascal), InverseMegapascalsTolerance);
            AssertEx.EqualTolerance(InverseMillibarsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseMillibar), InverseMillibarsTolerance);
            AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePascal), InversePascalsTolerance);
            AssertEx.EqualTolerance(InversePoundsForcePerSquareInchInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePoundForcePerSquareInch), InversePoundsForcePerSquareInchTolerance);
        }

        [Fact]
        public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported()
        {
            var quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit);
            Func<object> AsWithSIUnitSystem = () => quantity.As(UnitSystem.SI);

            if (SupportsSIUnitSystem)
            {
                var value = (double) AsWithSIUnitSystem();
                Assert.Equal(1, value);
            }
            else
            {
                Assert.Throws<ArgumentException>(AsWithSIUnitSystem);
            }
        }

        [Fact]
        public void Parse()
        {
            try
            {
                var parsed = Compressibility.Parse("1 atm⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseAtmospheres, InverseAtmospheresTolerance);
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/atm", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseAtmospheres, InverseAtmospheresTolerance);
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 bar⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseBars, InverseBarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseBar, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/bar", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseBars, InverseBarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseBar, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 kPa⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseKilopascals, InverseKilopascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/kPa", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseKilopascals, InverseKilopascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 MPa⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseMegapascals, InverseMegapascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/MPa", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseMegapascals, InverseMegapascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 mbar⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseMillibars, InverseMillibarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/mbar", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InverseMillibars, InverseMillibarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 Pa⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InversePascals, InversePascalsTolerance);
                Assert.Equal(CompressibilityUnit.InversePascal, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/Pa", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InversePascals, InversePascalsTolerance);
                Assert.Equal(CompressibilityUnit.InversePascal, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 psi⁻¹", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance);
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsed = Compressibility.Parse("1 1/psi", CultureInfo.GetCultureInfo("en-US"));
                AssertEx.EqualTolerance(1, parsed.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance);
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsed.Unit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

        }

        [Fact]
        public void TryParse()
        {
            {
                Assert.True(Compressibility.TryParse("1 atm⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseAtmospheres, InverseAtmospheresTolerance);
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/atm", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseAtmospheres, InverseAtmospheresTolerance);
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 bar⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseBars, InverseBarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseBar, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/bar", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseBars, InverseBarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseBar, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 kPa⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseKilopascals, InverseKilopascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/kPa", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseKilopascals, InverseKilopascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 MPa⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseMegapascals, InverseMegapascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/MPa", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseMegapascals, InverseMegapascalsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 mbar⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseMillibars, InverseMillibarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/mbar", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InverseMillibars, InverseMillibarsTolerance);
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 Pa⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InversePascals, InversePascalsTolerance);
                Assert.Equal(CompressibilityUnit.InversePascal, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/Pa", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InversePascals, InversePascalsTolerance);
                Assert.Equal(CompressibilityUnit.InversePascal, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 psi⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance);
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsed.Unit);
            }

            {
                Assert.True(Compressibility.TryParse("1 1/psi", CultureInfo.GetCultureInfo("en-US"), out var parsed));
                AssertEx.EqualTolerance(1, parsed.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance);
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsed.Unit);
            }

        }

        [Fact]
        public void ParseUnit()
        {
            try
            {
                var parsedUnit = Compressibility.ParseUnit("atm⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/atm", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("bar⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseBar, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/bar", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseBar, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("kPa⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/kPa", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("MPa⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/MPa", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("mbar⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/mbar", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("Pa⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InversePascal, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/Pa", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InversePascal, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("psi⁻¹", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

            try
            {
                var parsedUnit = Compressibility.ParseUnit("1/psi", CultureInfo.GetCultureInfo("en-US"));
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsedUnit);
            } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ }

        }

        [Fact]
        public void TryParseUnit()
        {
            {
                Assert.True(Compressibility.TryParseUnit("atm⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/atm", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseAtmosphere, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("bar⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseBar, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/bar", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseBar, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("kPa⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/kPa", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseKilopascal, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("MPa⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/MPa", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseMegapascal, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("mbar⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/mbar", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InverseMillibar, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("Pa⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InversePascal, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/Pa", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InversePascal, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("psi⁻¹", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsedUnit);
            }

            {
                Assert.True(Compressibility.TryParseUnit("1/psi", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit));
                Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, parsedUnit);
            }

        }

        [Theory]
        [MemberData(nameof(UnitTypes))]
        public void ToUnit(CompressibilityUnit unit)
        {
            var inBaseUnits = Compressibility.From(1.0, Compressibility.BaseUnit);
            var converted = inBaseUnits.ToUnit(unit);

            var conversionFactor = GetConversionFactor(unit);
            AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, converted.Value, conversionFactor.Tolerence);
            Assert.Equal(unit, converted.Unit);
        }

        [Theory]
        [MemberData(nameof(UnitTypes))]
        public void ToUnit_WithSameUnits_AreEqual(CompressibilityUnit unit)
        {
            var quantity = Compressibility.From(3.0, unit);
            var toUnitWithSameUnit = quantity.ToUnit(unit);
            Assert.Equal(quantity, toUnitWithSameUnit);
        }

        [Theory]
        [MemberData(nameof(UnitTypes))]
        public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(CompressibilityUnit unit)
        {
            // See if there is a unit available that is not the base unit, fallback to base unit if it has only a single unit.
            var fromUnit = Compressibility.Units.First(u => u != Compressibility.BaseUnit);

            var quantity = Compressibility.From(3.0, fromUnit);
            var converted = quantity.ToUnit(unit);
            Assert.Equal(converted.Unit, unit);
        }

        [Theory]
        [MemberData(nameof(UnitTypes))]
        public virtual void ToUnit_FromDefaultQuantity_ReturnsQuantityWithGivenUnit(CompressibilityUnit unit)
        {
            var quantity = default(Compressibility);
            var converted = quantity.ToUnit(unit);
            Assert.Equal(converted.Unit, unit);
        }

        [Fact]
        public void ConversionRoundTrip()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            AssertEx.EqualTolerance(1, Compressibility.FromInverseAtmospheres(inversepascal.InverseAtmospheres).InversePascals, InverseAtmospheresTolerance);
            AssertEx.EqualTolerance(1, Compressibility.FromInverseBars(inversepascal.InverseBars).InversePascals, InverseBarsTolerance);
            AssertEx.EqualTolerance(1, Compressibility.FromInverseKilopascals(inversepascal.InverseKilopascals).InversePascals, InverseKilopascalsTolerance);
            AssertEx.EqualTolerance(1, Compressibility.FromInverseMegapascals(inversepascal.InverseMegapascals).InversePascals, InverseMegapascalsTolerance);
            AssertEx.EqualTolerance(1, Compressibility.FromInverseMillibars(inversepascal.InverseMillibars).InversePascals, InverseMillibarsTolerance);
            AssertEx.EqualTolerance(1, Compressibility.FromInversePascals(inversepascal.InversePascals).InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(1, Compressibility.FromInversePoundsForcePerSquareInch(inversepascal.InversePoundsForcePerSquareInch).InversePascals, InversePoundsForcePerSquareInchTolerance);
        }

        [Fact]
        public void ArithmeticOperators()
        {
            Compressibility v = Compressibility.FromInversePascals(1);
            AssertEx.EqualTolerance(-1, -v.InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(2, (Compressibility.FromInversePascals(3)-v).InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(2, (v + v).InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(10, (v*10).InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(10, (10*v).InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(2, (Compressibility.FromInversePascals(10)/5).InversePascals, InversePascalsTolerance);
            AssertEx.EqualTolerance(2, Compressibility.FromInversePascals(10)/Compressibility.FromInversePascals(5), InversePascalsTolerance);
        }

        [Fact]
        public void ComparisonOperators()
        {
            Compressibility oneInversePascal = Compressibility.FromInversePascals(1);
            Compressibility twoInversePascals = Compressibility.FromInversePascals(2);

            Assert.True(oneInversePascal < twoInversePascals);
            Assert.True(oneInversePascal <= twoInversePascals);
            Assert.True(twoInversePascals > oneInversePascal);
            Assert.True(twoInversePascals >= oneInversePascal);

            Assert.False(oneInversePascal > twoInversePascals);
            Assert.False(oneInversePascal >= twoInversePascals);
            Assert.False(twoInversePascals < oneInversePascal);
            Assert.False(twoInversePascals <= oneInversePascal);
        }

        [Fact]
        public void CompareToIsImplemented()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            Assert.Equal(0, inversepascal.CompareTo(inversepascal));
            Assert.True(inversepascal.CompareTo(Compressibility.Zero) > 0);
            Assert.True(Compressibility.Zero.CompareTo(inversepascal) < 0);
        }

        [Fact]
        public void CompareToThrowsOnTypeMismatch()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            Assert.Throws<ArgumentException>(() => inversepascal.CompareTo(new object()));
        }

        [Fact]
        public void CompareToThrowsOnNull()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            Assert.Throws<ArgumentNullException>(() => inversepascal.CompareTo(null));
        }

        [Theory]
        [InlineData(1, CompressibilityUnit.InversePascal, 1, CompressibilityUnit.InversePascal, true)]  // Same value and unit.
        [InlineData(1, CompressibilityUnit.InversePascal, 2, CompressibilityUnit.InversePascal, false)] // Different value.
        [InlineData(2, CompressibilityUnit.InversePascal, 1, CompressibilityUnit.InverseAtmosphere, false)] // Different value and unit.
        [InlineData(1, CompressibilityUnit.InversePascal, 1, CompressibilityUnit.InverseAtmosphere, false)] // Different unit.
        public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, CompressibilityUnit unitA, double valueB, CompressibilityUnit unitB, bool expectEqual)
        {
            var a = new Compressibility(valueA, unitA);
            var b = new Compressibility(valueB, unitB);

            // Operator overloads.
            Assert.Equal(expectEqual, a == b);
            Assert.Equal(expectEqual, b == a);
            Assert.Equal(!expectEqual, a != b);
            Assert.Equal(!expectEqual, b != a);

            // IEquatable<T>
            Assert.Equal(expectEqual, a.Equals(b));
            Assert.Equal(expectEqual, b.Equals(a));

            // IEquatable
            Assert.Equal(expectEqual, a.Equals((object)b));
            Assert.Equal(expectEqual, b.Equals((object)a));
        }

        [Fact]
        public void Equals_Null_ReturnsFalse()
        {
            var a = Compressibility.Zero;

            Assert.False(a.Equals((object)null));

            // "The result of the expression is always 'false'..."
            #pragma warning disable CS8073
            Assert.False(a == null);
            Assert.False(null == a);
            Assert.True(a != null);
            Assert.True(null != a);
            #pragma warning restore CS8073
        }

        [Fact]
        public void Equals_RelativeTolerance_IsImplemented()
        {
            var v = Compressibility.FromInversePascals(1);
            Assert.True(v.Equals(Compressibility.FromInversePascals(1), InversePascalsTolerance, ComparisonType.Relative));
            Assert.False(v.Equals(Compressibility.Zero, InversePascalsTolerance, ComparisonType.Relative));
        }

        [Fact]
        public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
        {
            var v = Compressibility.FromInversePascals(1);
            Assert.Throws<ArgumentOutOfRangeException>(() => v.Equals(Compressibility.FromInversePascals(1), -1, ComparisonType.Relative));
        }

        [Fact]
        public void EqualsReturnsFalseOnTypeMismatch()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            Assert.False(inversepascal.Equals(new object()));
        }

        [Fact]
        public void EqualsReturnsFalseOnNull()
        {
            Compressibility inversepascal = Compressibility.FromInversePascals(1);
            Assert.False(inversepascal.Equals(null));
        }

        [Fact]
        public void HasAtLeastOneAbbreviationSpecified()
        {
            var units = Enum.GetValues(typeof(CompressibilityUnit)).Cast<CompressibilityUnit>();
            foreach (var unit in units)
            {
                var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit);
            }
        }

        [Fact]
        public void BaseDimensionsShouldNeverBeNull()
        {
            Assert.False(Compressibility.BaseDimensions is null);
        }

        [Fact]
        public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
        {
            var prevCulture = Thread.CurrentThread.CurrentCulture;
            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
            try {
                Assert.Equal("1 atm⁻¹", new Compressibility(1, CompressibilityUnit.InverseAtmosphere).ToString());
                Assert.Equal("1 bar⁻¹", new Compressibility(1, CompressibilityUnit.InverseBar).ToString());
                Assert.Equal("1 kPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseKilopascal).ToString());
                Assert.Equal("1 MPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseMegapascal).ToString());
                Assert.Equal("1 mbar⁻¹", new Compressibility(1, CompressibilityUnit.InverseMillibar).ToString());
                Assert.Equal("1 Pa⁻¹", new Compressibility(1, CompressibilityUnit.InversePascal).ToString());
                Assert.Equal("1 psi⁻¹", new Compressibility(1, CompressibilityUnit.InversePoundForcePerSquareInch).ToString());
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = prevCulture;
            }
        }

        [Fact]
        public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings()
        {
            // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback.
            var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");

            Assert.Equal("1 atm⁻¹", new Compressibility(1, CompressibilityUnit.InverseAtmosphere).ToString(swedishCulture));
            Assert.Equal("1 bar⁻¹", new Compressibility(1, CompressibilityUnit.InverseBar).ToString(swedishCulture));
            Assert.Equal("1 kPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseKilopascal).ToString(swedishCulture));
            Assert.Equal("1 MPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseMegapascal).ToString(swedishCulture));
            Assert.Equal("1 mbar⁻¹", new Compressibility(1, CompressibilityUnit.InverseMillibar).ToString(swedishCulture));
            Assert.Equal("1 Pa⁻¹", new Compressibility(1, CompressibilityUnit.InversePascal).ToString(swedishCulture));
            Assert.Equal("1 psi⁻¹", new Compressibility(1, CompressibilityUnit.InversePoundForcePerSquareInch).ToString(swedishCulture));
        }

        [Fact]
        public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture()
        {
            var oldCulture = CultureInfo.CurrentCulture;
            try
            {
                CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
                Assert.Equal("0.1 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s1"));
                Assert.Equal("0.12 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s2"));
                Assert.Equal("0.123 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s3"));
                Assert.Equal("0.1235 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s4"));
            }
            finally
            {
                CultureInfo.CurrentCulture = oldCulture;
            }
        }

        [Fact]
        public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
        {
            var culture = CultureInfo.InvariantCulture;
            Assert.Equal("0.1 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s1", culture));
            Assert.Equal("0.12 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s2", culture));
            Assert.Equal("0.123 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s3", culture));
            Assert.Equal("0.1235 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s4", culture));
        }

        [Theory]
        [InlineData(null)]
        [InlineData("en-US")]
        public void ToString_NullFormat_DefaultsToGeneralFormat(string cultureName)
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            CultureInfo formatProvider = cultureName == null
                ? null
                : CultureInfo.GetCultureInfo(cultureName);

            Assert.Equal(quantity.ToString("G", formatProvider), quantity.ToString(null, formatProvider));
        }

        [Theory]
        [InlineData(null)]
        [InlineData("g")]
        public void ToString_NullProvider_EqualsCurrentCulture(string format)
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(quantity.ToString(format, CultureInfo.CurrentCulture), quantity.ToString(format, null));
        }

        [Fact]
        public void Convert_ToBool_ThrowsInvalidCastException()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Throws<InvalidCastException>(() => Convert.ToBoolean(quantity));
        }

        [Fact]
        public void Convert_ToByte_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
           Assert.Equal((byte)quantity.Value, Convert.ToByte(quantity));
        }

        [Fact]
        public void Convert_ToChar_ThrowsInvalidCastException()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Throws<InvalidCastException>(() => Convert.ToChar(quantity));
        }

        [Fact]
        public void Convert_ToDateTime_ThrowsInvalidCastException()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Throws<InvalidCastException>(() => Convert.ToDateTime(quantity));
        }

        [Fact]
        public void Convert_ToDecimal_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
        }

        [Fact]
        public void Convert_ToDouble_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity));
        }

        [Fact]
        public void Convert_ToInt16_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity));
        }

        [Fact]
        public void Convert_ToInt32_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
        }

        [Fact]
        public void Convert_ToInt64_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((long)quantity.Value, Convert.ToInt64(quantity));
        }

        [Fact]
        public void Convert_ToSByte_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity));
        }

        [Fact]
        public void Convert_ToSingle_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
        }

        [Fact]
        public void Convert_ToString_EqualsToString()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
        }

        [Fact]
        public void Convert_ToUInt16_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((ushort)quantity.Value, Convert.ToUInt16(quantity));
        }

        [Fact]
        public void Convert_ToUInt32_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((uint)quantity.Value, Convert.ToUInt32(quantity));
        }

        [Fact]
        public void Convert_ToUInt64_EqualsValueAsSameType()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
        }

        [Fact]
        public void Convert_ChangeType_SelfType_EqualsSelf()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(Compressibility)));
        }

        [Fact]
        public void Convert_ChangeType_UnitType_EqualsUnit()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(CompressibilityUnit)));
        }

        [Fact]
        public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(Compressibility.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
        }

        [Fact]
        public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(Compressibility.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
        }

        [Fact]
        public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Throws<InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
        }

        [Fact]
        public void GetHashCode_Equals()
        {
            var quantity = Compressibility.FromInversePascals(1.0);
            Assert.Equal(new {Compressibility.Info.Name, quantity.Value, quantity.Unit}.GetHashCode(), quantity.GetHashCode());
        }

        [Theory]
        [InlineData(1.0)]
        [InlineData(-1.0)]
        public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
        {
            var quantity = Compressibility.FromInversePascals(value);
            Assert.Equal(Compressibility.FromInversePascals(-value), -quantity);
        }
    }
}