diff --git a/Common/UnitDefinitions/BitRate.json b/Common/UnitDefinitions/BitRate.json index d5c1b97fa6..5a8e93102e 100644 --- a/Common/UnitDefinitions/BitRate.json +++ b/Common/UnitDefinitions/BitRate.json @@ -35,6 +35,19 @@ "Abbreviations": [ "B/s" ] } ] + }, + { + "SingularName": "OctetPerSecond", + "PluralName": "OctetsPerSecond", + "FromUnitToBaseFunc": "{x} * 8", + "FromBaseToUnitFunc": "{x} / 8", + "Prefixes": [ "Kilo", "Mega", "Giga", "Tera", "Peta", "Exa", "Kibi", "Mebi", "Gibi", "Tebi", "Pebi", "Exbi" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "o/s" ] + } + ] } ] } diff --git a/Common/UnitDefinitions/Information.json b/Common/UnitDefinitions/Information.json index f327f00ca5..1bccbd8cb1 100644 --- a/Common/UnitDefinitions/Information.json +++ b/Common/UnitDefinitions/Information.json @@ -16,6 +16,19 @@ } ] }, + { + "SingularName": "Octet", + "PluralName": "Octets", + "FromUnitToBaseFunc": "{x} * 8", + "FromBaseToUnitFunc": "{x} / 8", + "Prefixes": [ "Kilo", "Mega", "Giga", "Tera", "Peta", "Exa", "Kibi", "Mebi", "Gibi", "Tebi", "Pebi", "Exbi" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "o" ] + } + ] + }, { "SingularName": "Bit", "PluralName": "Bits", diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json index ca73979277..f50485b3d7 100644 --- a/Common/UnitEnumValues.g.json +++ b/Common/UnitEnumValues.g.json @@ -122,7 +122,20 @@ "TebibitPerSecond": 23, "TebibytePerSecond": 24, "TerabitPerSecond": 25, - "TerabytePerSecond": 26 + "TerabytePerSecond": 26, + "ExaoctetPerSecond": 29, + "ExbioctetPerSecond": 31, + "GibioctetPerSecond": 32, + "GigaoctetPerSecond": 35, + "KibioctetPerSecond": 30, + "KilooctetPerSecond": 27, + "MebioctetPerSecond": 36, + "MegaoctetPerSecond": 34, + "OctetPerSecond": 28, + "PebioctetPerSecond": 33, + "PetaoctetPerSecond": 46, + "TebioctetPerSecond": 42, + "TeraoctetPerSecond": 40 }, "BrakeSpecificFuelConsumption": { "GramPerKiloWattHour": 1, @@ -595,7 +608,20 @@ "Tebibit": 23, "Tebibyte": 24, "Terabit": 25, - "Terabyte": 26 + "Terabyte": 26, + "Exaoctet": 33, + "Exbioctet": 35, + "Gibioctet": 27, + "Gigaoctet": 28, + "Kibioctet": 30, + "Kilooctet": 32, + "Mebioctet": 36, + "Megaoctet": 34, + "Octet": 31, + "Pebioctet": 29, + "Petaoctet": 39, + "Tebioctet": 43, + "Teraoctet": 40 }, "Irradiance": { "KilowattPerSquareCentimeter": 1, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs index 894d66b3b4..79d95bd6c2 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/BitRate.g.cs @@ -101,6 +101,11 @@ public BitRate(double value, BitRateUnit unit) /// public double ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double ExaoctetsPerSecond => As(BitRateUnit.ExaoctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -111,6 +116,11 @@ public BitRate(double value, BitRateUnit unit) /// public double ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double ExbioctetsPerSecond => As(BitRateUnit.ExbioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -121,6 +131,11 @@ public BitRate(double value, BitRateUnit unit) /// public double GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double GibioctetsPerSecond => As(BitRateUnit.GibioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -131,6 +146,11 @@ public BitRate(double value, BitRateUnit unit) /// public double GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double GigaoctetsPerSecond => As(BitRateUnit.GigaoctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -141,6 +161,11 @@ public BitRate(double value, BitRateUnit unit) /// public double KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double KibioctetsPerSecond => As(BitRateUnit.KibioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -151,6 +176,11 @@ public BitRate(double value, BitRateUnit unit) /// public double KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double KilooctetsPerSecond => As(BitRateUnit.KilooctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -161,6 +191,11 @@ public BitRate(double value, BitRateUnit unit) /// public double MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MebioctetsPerSecond => As(BitRateUnit.MebioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -171,6 +206,16 @@ public BitRate(double value, BitRateUnit unit) /// public double MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MegaoctetsPerSecond => As(BitRateUnit.MegaoctetPerSecond); + + /// + /// Gets a value of this quantity converted into + /// + public double OctetsPerSecond => As(BitRateUnit.OctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -181,6 +226,11 @@ public BitRate(double value, BitRateUnit unit) /// public double PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double PebioctetsPerSecond => As(BitRateUnit.PebioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -191,6 +241,11 @@ public BitRate(double value, BitRateUnit unit) /// public double PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double PetaoctetsPerSecond => As(BitRateUnit.PetaoctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -201,6 +256,11 @@ public BitRate(double value, BitRateUnit unit) /// public double TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double TebioctetsPerSecond => As(BitRateUnit.TebioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -211,6 +271,11 @@ public BitRate(double value, BitRateUnit unit) /// public double TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double TeraoctetsPerSecond => As(BitRateUnit.TeraoctetPerSecond); + #endregion #region Static Factory Methods @@ -235,6 +300,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromExabytesPerSecond(double exabytespersecond) => new BitRate(exabytespersecond, BitRateUnit.ExabytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromExaoctetsPerSecond(double exaoctetspersecond) => new BitRate(exaoctetspersecond, BitRateUnit.ExaoctetPerSecond); + /// /// Creates a from . /// @@ -245,6 +315,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromExbibytesPerSecond(double exbibytespersecond) => new BitRate(exbibytespersecond, BitRateUnit.ExbibytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromExbioctetsPerSecond(double exbioctetspersecond) => new BitRate(exbioctetspersecond, BitRateUnit.ExbioctetPerSecond); + /// /// Creates a from . /// @@ -255,6 +330,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromGibibytesPerSecond(double gibibytespersecond) => new BitRate(gibibytespersecond, BitRateUnit.GibibytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromGibioctetsPerSecond(double gibioctetspersecond) => new BitRate(gibioctetspersecond, BitRateUnit.GibioctetPerSecond); + /// /// Creates a from . /// @@ -265,6 +345,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromGigabytesPerSecond(double gigabytespersecond) => new BitRate(gigabytespersecond, BitRateUnit.GigabytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromGigaoctetsPerSecond(double gigaoctetspersecond) => new BitRate(gigaoctetspersecond, BitRateUnit.GigaoctetPerSecond); + /// /// Creates a from . /// @@ -275,6 +360,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromKibibytesPerSecond(double kibibytespersecond) => new BitRate(kibibytespersecond, BitRateUnit.KibibytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromKibioctetsPerSecond(double kibioctetspersecond) => new BitRate(kibioctetspersecond, BitRateUnit.KibioctetPerSecond); + /// /// Creates a from . /// @@ -285,6 +375,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromKilobytesPerSecond(double kilobytespersecond) => new BitRate(kilobytespersecond, BitRateUnit.KilobytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromKilooctetsPerSecond(double kilooctetspersecond) => new BitRate(kilooctetspersecond, BitRateUnit.KilooctetPerSecond); + /// /// Creates a from . /// @@ -295,6 +390,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromMebibytesPerSecond(double mebibytespersecond) => new BitRate(mebibytespersecond, BitRateUnit.MebibytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromMebioctetsPerSecond(double mebioctetspersecond) => new BitRate(mebioctetspersecond, BitRateUnit.MebioctetPerSecond); + /// /// Creates a from . /// @@ -305,6 +405,16 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromMegabytesPerSecond(double megabytespersecond) => new BitRate(megabytespersecond, BitRateUnit.MegabytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromMegaoctetsPerSecond(double megaoctetspersecond) => new BitRate(megaoctetspersecond, BitRateUnit.MegaoctetPerSecond); + + /// + /// Creates a from . + /// + public static BitRate FromOctetsPerSecond(double octetspersecond) => new BitRate(octetspersecond, BitRateUnit.OctetPerSecond); + /// /// Creates a from . /// @@ -315,6 +425,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromPebibytesPerSecond(double pebibytespersecond) => new BitRate(pebibytespersecond, BitRateUnit.PebibytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromPebioctetsPerSecond(double pebioctetspersecond) => new BitRate(pebioctetspersecond, BitRateUnit.PebioctetPerSecond); + /// /// Creates a from . /// @@ -325,6 +440,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromPetabytesPerSecond(double petabytespersecond) => new BitRate(petabytespersecond, BitRateUnit.PetabytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromPetaoctetsPerSecond(double petaoctetspersecond) => new BitRate(petaoctetspersecond, BitRateUnit.PetaoctetPerSecond); + /// /// Creates a from . /// @@ -335,6 +455,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromTebibytesPerSecond(double tebibytespersecond) => new BitRate(tebibytespersecond, BitRateUnit.TebibytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromTebioctetsPerSecond(double tebioctetspersecond) => new BitRate(tebioctetspersecond, BitRateUnit.TebioctetPerSecond); + /// /// Creates a from . /// @@ -345,6 +470,11 @@ public BitRate(double value, BitRateUnit unit) /// public static BitRate FromTerabytesPerSecond(double terabytespersecond) => new BitRate(terabytespersecond, BitRateUnit.TerabytePerSecond); + /// + /// Creates a from . + /// + public static BitRate FromTeraoctetsPerSecond(double teraoctetspersecond) => new BitRate(teraoctetspersecond, BitRateUnit.TeraoctetPerSecond); + /// /// Dynamically convert from value and unit enum to . /// @@ -389,28 +519,41 @@ private double GetValueInBaseUnit() BitRateUnit.BytePerSecond => _value * 8, BitRateUnit.ExabitPerSecond => (_value) * 1e18d, BitRateUnit.ExabytePerSecond => (_value * 8) * 1e18d, + BitRateUnit.ExaoctetPerSecond => (_value * 8) * 1e18d, BitRateUnit.ExbibitPerSecond => (_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbibytePerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), + BitRateUnit.ExbioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.GibibitPerSecond => (_value) * (1024d * 1024 * 1024), BitRateUnit.GibibytePerSecond => (_value * 8) * (1024d * 1024 * 1024), + BitRateUnit.GibioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024), BitRateUnit.GigabitPerSecond => (_value) * 1e9d, BitRateUnit.GigabytePerSecond => (_value * 8) * 1e9d, + BitRateUnit.GigaoctetPerSecond => (_value * 8) * 1e9d, BitRateUnit.KibibitPerSecond => (_value) * 1024d, BitRateUnit.KibibytePerSecond => (_value * 8) * 1024d, + BitRateUnit.KibioctetPerSecond => (_value * 8) * 1024d, BitRateUnit.KilobitPerSecond => (_value) * 1e3d, BitRateUnit.KilobytePerSecond => (_value * 8) * 1e3d, + BitRateUnit.KilooctetPerSecond => (_value * 8) * 1e3d, BitRateUnit.MebibitPerSecond => (_value) * (1024d * 1024), BitRateUnit.MebibytePerSecond => (_value * 8) * (1024d * 1024), + BitRateUnit.MebioctetPerSecond => (_value * 8) * (1024d * 1024), BitRateUnit.MegabitPerSecond => (_value) * 1e6d, BitRateUnit.MegabytePerSecond => (_value * 8) * 1e6d, + BitRateUnit.MegaoctetPerSecond => (_value * 8) * 1e6d, + BitRateUnit.OctetPerSecond => _value * 8, BitRateUnit.PebibitPerSecond => (_value) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebibytePerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), + BitRateUnit.PebioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PetabitPerSecond => (_value) * 1e15d, BitRateUnit.PetabytePerSecond => (_value * 8) * 1e15d, + BitRateUnit.PetaoctetPerSecond => (_value * 8) * 1e15d, BitRateUnit.TebibitPerSecond => (_value) * (1024d * 1024 * 1024 * 1024), BitRateUnit.TebibytePerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024), + BitRateUnit.TebioctetPerSecond => (_value * 8) * (1024d * 1024 * 1024 * 1024), BitRateUnit.TerabitPerSecond => (_value) * 1e12d, BitRateUnit.TerabytePerSecond => (_value * 8) * 1e12d, + BitRateUnit.TeraoctetPerSecond => (_value * 8) * 1e12d, _ => throw new NotImplementedException($"Can not convert {Unit} to base units.") }; } @@ -428,28 +571,41 @@ private double GetValueAs(BitRateUnit unit) BitRateUnit.BytePerSecond => baseUnitValue / 8, BitRateUnit.ExabitPerSecond => (baseUnitValue) / 1e18d, BitRateUnit.ExabytePerSecond => (baseUnitValue / 8) / 1e18d, + BitRateUnit.ExaoctetPerSecond => (baseUnitValue / 8) / 1e18d, BitRateUnit.ExbibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), + BitRateUnit.ExbioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.GibibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024), BitRateUnit.GibibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024), + BitRateUnit.GibioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024), BitRateUnit.GigabitPerSecond => (baseUnitValue) / 1e9d, BitRateUnit.GigabytePerSecond => (baseUnitValue / 8) / 1e9d, + BitRateUnit.GigaoctetPerSecond => (baseUnitValue / 8) / 1e9d, BitRateUnit.KibibitPerSecond => (baseUnitValue) / 1024d, BitRateUnit.KibibytePerSecond => (baseUnitValue / 8) / 1024d, + BitRateUnit.KibioctetPerSecond => (baseUnitValue / 8) / 1024d, BitRateUnit.KilobitPerSecond => (baseUnitValue) / 1e3d, BitRateUnit.KilobytePerSecond => (baseUnitValue / 8) / 1e3d, + BitRateUnit.KilooctetPerSecond => (baseUnitValue / 8) / 1e3d, BitRateUnit.MebibitPerSecond => (baseUnitValue) / (1024d * 1024), BitRateUnit.MebibytePerSecond => (baseUnitValue / 8) / (1024d * 1024), + BitRateUnit.MebioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024), BitRateUnit.MegabitPerSecond => (baseUnitValue) / 1e6d, BitRateUnit.MegabytePerSecond => (baseUnitValue / 8) / 1e6d, + BitRateUnit.MegaoctetPerSecond => (baseUnitValue / 8) / 1e6d, + BitRateUnit.OctetPerSecond => baseUnitValue / 8, BitRateUnit.PebibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024), + BitRateUnit.PebioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PetabitPerSecond => (baseUnitValue) / 1e15d, BitRateUnit.PetabytePerSecond => (baseUnitValue / 8) / 1e15d, + BitRateUnit.PetaoctetPerSecond => (baseUnitValue / 8) / 1e15d, BitRateUnit.TebibitPerSecond => (baseUnitValue) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebibytePerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024), + BitRateUnit.TebioctetPerSecond => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TerabitPerSecond => (baseUnitValue) / 1e12d, BitRateUnit.TerabytePerSecond => (baseUnitValue / 8) / 1e12d, + BitRateUnit.TeraoctetPerSecond => (baseUnitValue / 8) / 1e12d, _ => throw new NotImplementedException($"Can not convert {Unit} to {unit}.") }; } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs index 16fc03f972..ef567c37aa 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Information.g.cs @@ -98,6 +98,11 @@ public Information(double value, InformationUnit unit) /// public double Exabytes => As(InformationUnit.Exabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Exaoctets => As(InformationUnit.Exaoctet); + /// /// Gets a value of this quantity converted into /// @@ -108,6 +113,11 @@ public Information(double value, InformationUnit unit) /// public double Exbibytes => As(InformationUnit.Exbibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Exbioctets => As(InformationUnit.Exbioctet); + /// /// Gets a value of this quantity converted into /// @@ -118,6 +128,11 @@ public Information(double value, InformationUnit unit) /// public double Gibibytes => As(InformationUnit.Gibibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Gibioctets => As(InformationUnit.Gibioctet); + /// /// Gets a value of this quantity converted into /// @@ -128,6 +143,11 @@ public Information(double value, InformationUnit unit) /// public double Gigabytes => As(InformationUnit.Gigabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Gigaoctets => As(InformationUnit.Gigaoctet); + /// /// Gets a value of this quantity converted into /// @@ -138,6 +158,11 @@ public Information(double value, InformationUnit unit) /// public double Kibibytes => As(InformationUnit.Kibibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Kibioctets => As(InformationUnit.Kibioctet); + /// /// Gets a value of this quantity converted into /// @@ -148,6 +173,11 @@ public Information(double value, InformationUnit unit) /// public double Kilobytes => As(InformationUnit.Kilobyte); + /// + /// Gets a value of this quantity converted into + /// + public double Kilooctets => As(InformationUnit.Kilooctet); + /// /// Gets a value of this quantity converted into /// @@ -158,6 +188,11 @@ public Information(double value, InformationUnit unit) /// public double Mebibytes => As(InformationUnit.Mebibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Mebioctets => As(InformationUnit.Mebioctet); + /// /// Gets a value of this quantity converted into /// @@ -168,6 +203,16 @@ public Information(double value, InformationUnit unit) /// public double Megabytes => As(InformationUnit.Megabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Megaoctets => As(InformationUnit.Megaoctet); + + /// + /// Gets a value of this quantity converted into + /// + public double Octets => As(InformationUnit.Octet); + /// /// Gets a value of this quantity converted into /// @@ -178,6 +223,11 @@ public Information(double value, InformationUnit unit) /// public double Pebibytes => As(InformationUnit.Pebibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Pebioctets => As(InformationUnit.Pebioctet); + /// /// Gets a value of this quantity converted into /// @@ -188,6 +238,11 @@ public Information(double value, InformationUnit unit) /// public double Petabytes => As(InformationUnit.Petabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Petaoctets => As(InformationUnit.Petaoctet); + /// /// Gets a value of this quantity converted into /// @@ -198,6 +253,11 @@ public Information(double value, InformationUnit unit) /// public double Tebibytes => As(InformationUnit.Tebibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Tebioctets => As(InformationUnit.Tebioctet); + /// /// Gets a value of this quantity converted into /// @@ -208,6 +268,11 @@ public Information(double value, InformationUnit unit) /// public double Terabytes => As(InformationUnit.Terabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Teraoctets => As(InformationUnit.Teraoctet); + #endregion #region Static Factory Methods @@ -232,6 +297,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromExabytes(double exabytes) => new Information(exabytes, InformationUnit.Exabyte); + /// + /// Creates a from . + /// + public static Information FromExaoctets(double exaoctets) => new Information(exaoctets, InformationUnit.Exaoctet); + /// /// Creates a from . /// @@ -242,6 +312,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromExbibytes(double exbibytes) => new Information(exbibytes, InformationUnit.Exbibyte); + /// + /// Creates a from . + /// + public static Information FromExbioctets(double exbioctets) => new Information(exbioctets, InformationUnit.Exbioctet); + /// /// Creates a from . /// @@ -252,6 +327,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromGibibytes(double gibibytes) => new Information(gibibytes, InformationUnit.Gibibyte); + /// + /// Creates a from . + /// + public static Information FromGibioctets(double gibioctets) => new Information(gibioctets, InformationUnit.Gibioctet); + /// /// Creates a from . /// @@ -262,6 +342,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromGigabytes(double gigabytes) => new Information(gigabytes, InformationUnit.Gigabyte); + /// + /// Creates a from . + /// + public static Information FromGigaoctets(double gigaoctets) => new Information(gigaoctets, InformationUnit.Gigaoctet); + /// /// Creates a from . /// @@ -272,6 +357,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromKibibytes(double kibibytes) => new Information(kibibytes, InformationUnit.Kibibyte); + /// + /// Creates a from . + /// + public static Information FromKibioctets(double kibioctets) => new Information(kibioctets, InformationUnit.Kibioctet); + /// /// Creates a from . /// @@ -282,6 +372,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromKilobytes(double kilobytes) => new Information(kilobytes, InformationUnit.Kilobyte); + /// + /// Creates a from . + /// + public static Information FromKilooctets(double kilooctets) => new Information(kilooctets, InformationUnit.Kilooctet); + /// /// Creates a from . /// @@ -292,6 +387,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromMebibytes(double mebibytes) => new Information(mebibytes, InformationUnit.Mebibyte); + /// + /// Creates a from . + /// + public static Information FromMebioctets(double mebioctets) => new Information(mebioctets, InformationUnit.Mebioctet); + /// /// Creates a from . /// @@ -302,6 +402,16 @@ public Information(double value, InformationUnit unit) /// public static Information FromMegabytes(double megabytes) => new Information(megabytes, InformationUnit.Megabyte); + /// + /// Creates a from . + /// + public static Information FromMegaoctets(double megaoctets) => new Information(megaoctets, InformationUnit.Megaoctet); + + /// + /// Creates a from . + /// + public static Information FromOctets(double octets) => new Information(octets, InformationUnit.Octet); + /// /// Creates a from . /// @@ -312,6 +422,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromPebibytes(double pebibytes) => new Information(pebibytes, InformationUnit.Pebibyte); + /// + /// Creates a from . + /// + public static Information FromPebioctets(double pebioctets) => new Information(pebioctets, InformationUnit.Pebioctet); + /// /// Creates a from . /// @@ -322,6 +437,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromPetabytes(double petabytes) => new Information(petabytes, InformationUnit.Petabyte); + /// + /// Creates a from . + /// + public static Information FromPetaoctets(double petaoctets) => new Information(petaoctets, InformationUnit.Petaoctet); + /// /// Creates a from . /// @@ -332,6 +452,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromTebibytes(double tebibytes) => new Information(tebibytes, InformationUnit.Tebibyte); + /// + /// Creates a from . + /// + public static Information FromTebioctets(double tebioctets) => new Information(tebioctets, InformationUnit.Tebioctet); + /// /// Creates a from . /// @@ -342,6 +467,11 @@ public Information(double value, InformationUnit unit) /// public static Information FromTerabytes(double terabytes) => new Information(terabytes, InformationUnit.Terabyte); + /// + /// Creates a from . + /// + public static Information FromTeraoctets(double teraoctets) => new Information(teraoctets, InformationUnit.Teraoctet); + /// /// Dynamically convert from value and unit enum to . /// @@ -386,28 +516,41 @@ private double GetValueInBaseUnit() InformationUnit.Byte => _value * 8, InformationUnit.Exabit => (_value) * 1e18d, InformationUnit.Exabyte => (_value * 8) * 1e18d, + InformationUnit.Exaoctet => (_value * 8) * 1e18d, InformationUnit.Exbibit => (_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbibyte => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), + InformationUnit.Exbioctet => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Gibibit => (_value) * (1024d * 1024 * 1024), InformationUnit.Gibibyte => (_value * 8) * (1024d * 1024 * 1024), + InformationUnit.Gibioctet => (_value * 8) * (1024d * 1024 * 1024), InformationUnit.Gigabit => (_value) * 1e9d, InformationUnit.Gigabyte => (_value * 8) * 1e9d, + InformationUnit.Gigaoctet => (_value * 8) * 1e9d, InformationUnit.Kibibit => (_value) * 1024d, InformationUnit.Kibibyte => (_value * 8) * 1024d, + InformationUnit.Kibioctet => (_value * 8) * 1024d, InformationUnit.Kilobit => (_value) * 1e3d, InformationUnit.Kilobyte => (_value * 8) * 1e3d, + InformationUnit.Kilooctet => (_value * 8) * 1e3d, InformationUnit.Mebibit => (_value) * (1024d * 1024), InformationUnit.Mebibyte => (_value * 8) * (1024d * 1024), + InformationUnit.Mebioctet => (_value * 8) * (1024d * 1024), InformationUnit.Megabit => (_value) * 1e6d, InformationUnit.Megabyte => (_value * 8) * 1e6d, + InformationUnit.Megaoctet => (_value * 8) * 1e6d, + InformationUnit.Octet => _value * 8, InformationUnit.Pebibit => (_value) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebibyte => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), + InformationUnit.Pebioctet => (_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Petabit => (_value) * 1e15d, InformationUnit.Petabyte => (_value * 8) * 1e15d, + InformationUnit.Petaoctet => (_value * 8) * 1e15d, InformationUnit.Tebibit => (_value) * (1024d * 1024 * 1024 * 1024), InformationUnit.Tebibyte => (_value * 8) * (1024d * 1024 * 1024 * 1024), + InformationUnit.Tebioctet => (_value * 8) * (1024d * 1024 * 1024 * 1024), InformationUnit.Terabit => (_value) * 1e12d, InformationUnit.Terabyte => (_value * 8) * 1e12d, + InformationUnit.Teraoctet => (_value * 8) * 1e12d, _ => throw new NotImplementedException($"Can not convert {Unit} to base units.") }; } @@ -425,28 +568,41 @@ private double GetValueAs(InformationUnit unit) InformationUnit.Byte => baseUnitValue / 8, InformationUnit.Exabit => (baseUnitValue) / 1e18d, InformationUnit.Exabyte => (baseUnitValue / 8) / 1e18d, + InformationUnit.Exaoctet => (baseUnitValue / 8) / 1e18d, InformationUnit.Exbibit => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), + InformationUnit.Exbioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Gibibit => (baseUnitValue) / (1024d * 1024 * 1024), InformationUnit.Gibibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024), + InformationUnit.Gibioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024), InformationUnit.Gigabit => (baseUnitValue) / 1e9d, InformationUnit.Gigabyte => (baseUnitValue / 8) / 1e9d, + InformationUnit.Gigaoctet => (baseUnitValue / 8) / 1e9d, InformationUnit.Kibibit => (baseUnitValue) / 1024d, InformationUnit.Kibibyte => (baseUnitValue / 8) / 1024d, + InformationUnit.Kibioctet => (baseUnitValue / 8) / 1024d, InformationUnit.Kilobit => (baseUnitValue) / 1e3d, InformationUnit.Kilobyte => (baseUnitValue / 8) / 1e3d, + InformationUnit.Kilooctet => (baseUnitValue / 8) / 1e3d, InformationUnit.Mebibit => (baseUnitValue) / (1024d * 1024), InformationUnit.Mebibyte => (baseUnitValue / 8) / (1024d * 1024), + InformationUnit.Mebioctet => (baseUnitValue / 8) / (1024d * 1024), InformationUnit.Megabit => (baseUnitValue) / 1e6d, InformationUnit.Megabyte => (baseUnitValue / 8) / 1e6d, + InformationUnit.Megaoctet => (baseUnitValue / 8) / 1e6d, + InformationUnit.Octet => baseUnitValue / 8, InformationUnit.Pebibit => (baseUnitValue) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024), + InformationUnit.Pebioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Petabit => (baseUnitValue) / 1e15d, InformationUnit.Petabyte => (baseUnitValue / 8) / 1e15d, + InformationUnit.Petaoctet => (baseUnitValue / 8) / 1e15d, InformationUnit.Tebibit => (baseUnitValue) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebibyte => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024), + InformationUnit.Tebioctet => (baseUnitValue / 8) / (1024d * 1024 * 1024 * 1024), InformationUnit.Terabit => (baseUnitValue) / 1e12d, InformationUnit.Terabyte => (baseUnitValue / 8) / 1e12d, + InformationUnit.Teraoctet => (baseUnitValue / 8) / 1e12d, _ => throw new NotImplementedException($"Can not convert {Unit} to {unit}.") }; } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs index 6a3760ef6b..ebfb72662d 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/BitRateUnit.g.cs @@ -29,28 +29,41 @@ public enum BitRateUnit BytePerSecond = 2, ExabitPerSecond = 3, ExabytePerSecond = 4, + ExaoctetPerSecond = 29, ExbibitPerSecond = 5, ExbibytePerSecond = 6, + ExbioctetPerSecond = 31, GibibitPerSecond = 7, GibibytePerSecond = 8, + GibioctetPerSecond = 32, GigabitPerSecond = 9, GigabytePerSecond = 10, + GigaoctetPerSecond = 35, KibibitPerSecond = 11, KibibytePerSecond = 12, + KibioctetPerSecond = 30, KilobitPerSecond = 13, KilobytePerSecond = 14, + KilooctetPerSecond = 27, MebibitPerSecond = 15, MebibytePerSecond = 16, + MebioctetPerSecond = 36, MegabitPerSecond = 17, MegabytePerSecond = 18, + MegaoctetPerSecond = 34, + OctetPerSecond = 28, PebibitPerSecond = 19, PebibytePerSecond = 20, + PebioctetPerSecond = 33, PetabitPerSecond = 21, PetabytePerSecond = 22, + PetaoctetPerSecond = 46, TebibitPerSecond = 23, TebibytePerSecond = 24, + TebioctetPerSecond = 42, TerabitPerSecond = 25, TerabytePerSecond = 26, + TeraoctetPerSecond = 40, } #pragma warning restore 1591 diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs index fd72b621c2..ca0b4e2d4b 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/InformationUnit.g.cs @@ -29,28 +29,41 @@ public enum InformationUnit Byte = 2, Exabit = 3, Exabyte = 4, + Exaoctet = 33, Exbibit = 5, Exbibyte = 6, + Exbioctet = 35, Gibibit = 7, Gibibyte = 8, + Gibioctet = 27, Gigabit = 9, Gigabyte = 10, + Gigaoctet = 28, Kibibit = 11, Kibibyte = 12, + Kibioctet = 30, Kilobit = 13, Kilobyte = 14, + Kilooctet = 32, Mebibit = 15, Mebibyte = 16, + Mebioctet = 36, Megabit = 17, Megabyte = 18, + Megaoctet = 34, + Octet = 31, Pebibit = 19, Pebibyte = 20, + Pebioctet = 29, Petabit = 21, Petabyte = 22, + Petaoctet = 39, Tebibit = 23, Tebibyte = 24, + Tebioctet = 43, Terabit = 25, Terabyte = 26, + Teraoctet = 40, } #pragma warning restore 1591 diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs index 65ebc26692..9a91370325 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs @@ -40,6 +40,10 @@ public void NumberToExabitsPerSecondTest() => public void NumberToExabytesPerSecondTest() => Assert.Equal(BitRate.FromExabytesPerSecond(2), 2.ExabytesPerSecond()); + [Fact] + public void NumberToExaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromExaoctetsPerSecond(2), 2.ExaoctetsPerSecond()); + [Fact] public void NumberToExbibitsPerSecondTest() => Assert.Equal(BitRate.FromExbibitsPerSecond(2), 2.ExbibitsPerSecond()); @@ -48,6 +52,10 @@ public void NumberToExbibitsPerSecondTest() => public void NumberToExbibytesPerSecondTest() => Assert.Equal(BitRate.FromExbibytesPerSecond(2), 2.ExbibytesPerSecond()); + [Fact] + public void NumberToExbioctetsPerSecondTest() => + Assert.Equal(BitRate.FromExbioctetsPerSecond(2), 2.ExbioctetsPerSecond()); + [Fact] public void NumberToGibibitsPerSecondTest() => Assert.Equal(BitRate.FromGibibitsPerSecond(2), 2.GibibitsPerSecond()); @@ -56,6 +64,10 @@ public void NumberToGibibitsPerSecondTest() => public void NumberToGibibytesPerSecondTest() => Assert.Equal(BitRate.FromGibibytesPerSecond(2), 2.GibibytesPerSecond()); + [Fact] + public void NumberToGibioctetsPerSecondTest() => + Assert.Equal(BitRate.FromGibioctetsPerSecond(2), 2.GibioctetsPerSecond()); + [Fact] public void NumberToGigabitsPerSecondTest() => Assert.Equal(BitRate.FromGigabitsPerSecond(2), 2.GigabitsPerSecond()); @@ -64,6 +76,10 @@ public void NumberToGigabitsPerSecondTest() => public void NumberToGigabytesPerSecondTest() => Assert.Equal(BitRate.FromGigabytesPerSecond(2), 2.GigabytesPerSecond()); + [Fact] + public void NumberToGigaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromGigaoctetsPerSecond(2), 2.GigaoctetsPerSecond()); + [Fact] public void NumberToKibibitsPerSecondTest() => Assert.Equal(BitRate.FromKibibitsPerSecond(2), 2.KibibitsPerSecond()); @@ -72,6 +88,10 @@ public void NumberToKibibitsPerSecondTest() => public void NumberToKibibytesPerSecondTest() => Assert.Equal(BitRate.FromKibibytesPerSecond(2), 2.KibibytesPerSecond()); + [Fact] + public void NumberToKibioctetsPerSecondTest() => + Assert.Equal(BitRate.FromKibioctetsPerSecond(2), 2.KibioctetsPerSecond()); + [Fact] public void NumberToKilobitsPerSecondTest() => Assert.Equal(BitRate.FromKilobitsPerSecond(2), 2.KilobitsPerSecond()); @@ -80,6 +100,10 @@ public void NumberToKilobitsPerSecondTest() => public void NumberToKilobytesPerSecondTest() => Assert.Equal(BitRate.FromKilobytesPerSecond(2), 2.KilobytesPerSecond()); + [Fact] + public void NumberToKilooctetsPerSecondTest() => + Assert.Equal(BitRate.FromKilooctetsPerSecond(2), 2.KilooctetsPerSecond()); + [Fact] public void NumberToMebibitsPerSecondTest() => Assert.Equal(BitRate.FromMebibitsPerSecond(2), 2.MebibitsPerSecond()); @@ -88,6 +112,10 @@ public void NumberToMebibitsPerSecondTest() => public void NumberToMebibytesPerSecondTest() => Assert.Equal(BitRate.FromMebibytesPerSecond(2), 2.MebibytesPerSecond()); + [Fact] + public void NumberToMebioctetsPerSecondTest() => + Assert.Equal(BitRate.FromMebioctetsPerSecond(2), 2.MebioctetsPerSecond()); + [Fact] public void NumberToMegabitsPerSecondTest() => Assert.Equal(BitRate.FromMegabitsPerSecond(2), 2.MegabitsPerSecond()); @@ -96,6 +124,14 @@ public void NumberToMegabitsPerSecondTest() => public void NumberToMegabytesPerSecondTest() => Assert.Equal(BitRate.FromMegabytesPerSecond(2), 2.MegabytesPerSecond()); + [Fact] + public void NumberToMegaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromMegaoctetsPerSecond(2), 2.MegaoctetsPerSecond()); + + [Fact] + public void NumberToOctetsPerSecondTest() => + Assert.Equal(BitRate.FromOctetsPerSecond(2), 2.OctetsPerSecond()); + [Fact] public void NumberToPebibitsPerSecondTest() => Assert.Equal(BitRate.FromPebibitsPerSecond(2), 2.PebibitsPerSecond()); @@ -104,6 +140,10 @@ public void NumberToPebibitsPerSecondTest() => public void NumberToPebibytesPerSecondTest() => Assert.Equal(BitRate.FromPebibytesPerSecond(2), 2.PebibytesPerSecond()); + [Fact] + public void NumberToPebioctetsPerSecondTest() => + Assert.Equal(BitRate.FromPebioctetsPerSecond(2), 2.PebioctetsPerSecond()); + [Fact] public void NumberToPetabitsPerSecondTest() => Assert.Equal(BitRate.FromPetabitsPerSecond(2), 2.PetabitsPerSecond()); @@ -112,6 +152,10 @@ public void NumberToPetabitsPerSecondTest() => public void NumberToPetabytesPerSecondTest() => Assert.Equal(BitRate.FromPetabytesPerSecond(2), 2.PetabytesPerSecond()); + [Fact] + public void NumberToPetaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromPetaoctetsPerSecond(2), 2.PetaoctetsPerSecond()); + [Fact] public void NumberToTebibitsPerSecondTest() => Assert.Equal(BitRate.FromTebibitsPerSecond(2), 2.TebibitsPerSecond()); @@ -120,6 +164,10 @@ public void NumberToTebibitsPerSecondTest() => public void NumberToTebibytesPerSecondTest() => Assert.Equal(BitRate.FromTebibytesPerSecond(2), 2.TebibytesPerSecond()); + [Fact] + public void NumberToTebioctetsPerSecondTest() => + Assert.Equal(BitRate.FromTebioctetsPerSecond(2), 2.TebioctetsPerSecond()); + [Fact] public void NumberToTerabitsPerSecondTest() => Assert.Equal(BitRate.FromTerabitsPerSecond(2), 2.TerabitsPerSecond()); @@ -128,5 +176,9 @@ public void NumberToTerabitsPerSecondTest() => public void NumberToTerabytesPerSecondTest() => Assert.Equal(BitRate.FromTerabytesPerSecond(2), 2.TerabytesPerSecond()); + [Fact] + public void NumberToTeraoctetsPerSecondTest() => + Assert.Equal(BitRate.FromTeraoctetsPerSecond(2), 2.TeraoctetsPerSecond()); + } } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs index 3a68490cd9..01259ce16b 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs @@ -40,6 +40,10 @@ public void NumberToExabitsTest() => public void NumberToExabytesTest() => Assert.Equal(Information.FromExabytes(2), 2.Exabytes()); + [Fact] + public void NumberToExaoctetsTest() => + Assert.Equal(Information.FromExaoctets(2), 2.Exaoctets()); + [Fact] public void NumberToExbibitsTest() => Assert.Equal(Information.FromExbibits(2), 2.Exbibits()); @@ -48,6 +52,10 @@ public void NumberToExbibitsTest() => public void NumberToExbibytesTest() => Assert.Equal(Information.FromExbibytes(2), 2.Exbibytes()); + [Fact] + public void NumberToExbioctetsTest() => + Assert.Equal(Information.FromExbioctets(2), 2.Exbioctets()); + [Fact] public void NumberToGibibitsTest() => Assert.Equal(Information.FromGibibits(2), 2.Gibibits()); @@ -56,6 +64,10 @@ public void NumberToGibibitsTest() => public void NumberToGibibytesTest() => Assert.Equal(Information.FromGibibytes(2), 2.Gibibytes()); + [Fact] + public void NumberToGibioctetsTest() => + Assert.Equal(Information.FromGibioctets(2), 2.Gibioctets()); + [Fact] public void NumberToGigabitsTest() => Assert.Equal(Information.FromGigabits(2), 2.Gigabits()); @@ -64,6 +76,10 @@ public void NumberToGigabitsTest() => public void NumberToGigabytesTest() => Assert.Equal(Information.FromGigabytes(2), 2.Gigabytes()); + [Fact] + public void NumberToGigaoctetsTest() => + Assert.Equal(Information.FromGigaoctets(2), 2.Gigaoctets()); + [Fact] public void NumberToKibibitsTest() => Assert.Equal(Information.FromKibibits(2), 2.Kibibits()); @@ -72,6 +88,10 @@ public void NumberToKibibitsTest() => public void NumberToKibibytesTest() => Assert.Equal(Information.FromKibibytes(2), 2.Kibibytes()); + [Fact] + public void NumberToKibioctetsTest() => + Assert.Equal(Information.FromKibioctets(2), 2.Kibioctets()); + [Fact] public void NumberToKilobitsTest() => Assert.Equal(Information.FromKilobits(2), 2.Kilobits()); @@ -80,6 +100,10 @@ public void NumberToKilobitsTest() => public void NumberToKilobytesTest() => Assert.Equal(Information.FromKilobytes(2), 2.Kilobytes()); + [Fact] + public void NumberToKilooctetsTest() => + Assert.Equal(Information.FromKilooctets(2), 2.Kilooctets()); + [Fact] public void NumberToMebibitsTest() => Assert.Equal(Information.FromMebibits(2), 2.Mebibits()); @@ -88,6 +112,10 @@ public void NumberToMebibitsTest() => public void NumberToMebibytesTest() => Assert.Equal(Information.FromMebibytes(2), 2.Mebibytes()); + [Fact] + public void NumberToMebioctetsTest() => + Assert.Equal(Information.FromMebioctets(2), 2.Mebioctets()); + [Fact] public void NumberToMegabitsTest() => Assert.Equal(Information.FromMegabits(2), 2.Megabits()); @@ -96,6 +124,14 @@ public void NumberToMegabitsTest() => public void NumberToMegabytesTest() => Assert.Equal(Information.FromMegabytes(2), 2.Megabytes()); + [Fact] + public void NumberToMegaoctetsTest() => + Assert.Equal(Information.FromMegaoctets(2), 2.Megaoctets()); + + [Fact] + public void NumberToOctetsTest() => + Assert.Equal(Information.FromOctets(2), 2.Octets()); + [Fact] public void NumberToPebibitsTest() => Assert.Equal(Information.FromPebibits(2), 2.Pebibits()); @@ -104,6 +140,10 @@ public void NumberToPebibitsTest() => public void NumberToPebibytesTest() => Assert.Equal(Information.FromPebibytes(2), 2.Pebibytes()); + [Fact] + public void NumberToPebioctetsTest() => + Assert.Equal(Information.FromPebioctets(2), 2.Pebioctets()); + [Fact] public void NumberToPetabitsTest() => Assert.Equal(Information.FromPetabits(2), 2.Petabits()); @@ -112,6 +152,10 @@ public void NumberToPetabitsTest() => public void NumberToPetabytesTest() => Assert.Equal(Information.FromPetabytes(2), 2.Petabytes()); + [Fact] + public void NumberToPetaoctetsTest() => + Assert.Equal(Information.FromPetaoctets(2), 2.Petaoctets()); + [Fact] public void NumberToTebibitsTest() => Assert.Equal(Information.FromTebibits(2), 2.Tebibits()); @@ -120,6 +164,10 @@ public void NumberToTebibitsTest() => public void NumberToTebibytesTest() => Assert.Equal(Information.FromTebibytes(2), 2.Tebibytes()); + [Fact] + public void NumberToTebioctetsTest() => + Assert.Equal(Information.FromTebioctets(2), 2.Tebioctets()); + [Fact] public void NumberToTerabitsTest() => Assert.Equal(Information.FromTerabits(2), 2.Terabits()); @@ -128,5 +176,9 @@ public void NumberToTerabitsTest() => public void NumberToTerabytesTest() => Assert.Equal(Information.FromTerabytes(2), 2.Terabytes()); + [Fact] + public void NumberToTeraoctetsTest() => + Assert.Equal(Information.FromTeraoctets(2), 2.Teraoctets()); + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs index 7269671d09..e747c0aef6 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs @@ -76,6 +76,17 @@ public static BitRate ExabytesPerSecond(this T value) => BitRate.FromExabytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate ExaoctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromExaoctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromExaoctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate ExbibitsPerSecond(this T value) where T : notnull @@ -98,6 +109,17 @@ public static BitRate ExbibytesPerSecond(this T value) => BitRate.FromExbibytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate ExbioctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromExbioctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromExbioctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate GibibitsPerSecond(this T value) where T : notnull @@ -120,6 +142,17 @@ public static BitRate GibibytesPerSecond(this T value) => BitRate.FromGibibytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate GibioctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromGibioctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromGibioctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate GigabitsPerSecond(this T value) where T : notnull @@ -142,6 +175,17 @@ public static BitRate GigabytesPerSecond(this T value) => BitRate.FromGigabytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate GigaoctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromGigaoctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromGigaoctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate KibibitsPerSecond(this T value) where T : notnull @@ -164,6 +208,17 @@ public static BitRate KibibytesPerSecond(this T value) => BitRate.FromKibibytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate KibioctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromKibioctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromKibioctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate KilobitsPerSecond(this T value) where T : notnull @@ -186,6 +241,17 @@ public static BitRate KilobytesPerSecond(this T value) => BitRate.FromKilobytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate KilooctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromKilooctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromKilooctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate MebibitsPerSecond(this T value) where T : notnull @@ -208,6 +274,17 @@ public static BitRate MebibytesPerSecond(this T value) => BitRate.FromMebibytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate MebioctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromMebioctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromMebioctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate MegabitsPerSecond(this T value) where T : notnull @@ -230,6 +307,28 @@ public static BitRate MegabytesPerSecond(this T value) => BitRate.FromMegabytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate MegaoctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromMegaoctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromMegaoctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public static BitRate OctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromOctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromOctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate PebibitsPerSecond(this T value) where T : notnull @@ -252,6 +351,17 @@ public static BitRate PebibytesPerSecond(this T value) => BitRate.FromPebibytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate PebioctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromPebioctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromPebioctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate PetabitsPerSecond(this T value) where T : notnull @@ -274,6 +384,17 @@ public static BitRate PetabytesPerSecond(this T value) => BitRate.FromPetabytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate PetaoctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromPetaoctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromPetaoctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate TebibitsPerSecond(this T value) where T : notnull @@ -296,6 +417,17 @@ public static BitRate TebibytesPerSecond(this T value) => BitRate.FromTebibytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate TebioctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromTebioctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromTebioctetsPerSecond(value.ToDouble(null)); +#endif + /// public static BitRate TerabitsPerSecond(this T value) where T : notnull @@ -318,5 +450,16 @@ public static BitRate TerabytesPerSecond(this T value) => BitRate.FromTerabytesPerSecond(value.ToDouble(null)); #endif + /// + public static BitRate TeraoctetsPerSecond(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => BitRate.FromTeraoctetsPerSecond(double.CreateChecked(value)); +#else + , IConvertible + => BitRate.FromTeraoctetsPerSecond(value.ToDouble(null)); +#endif + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs index 580bbcb755..3158412758 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs @@ -76,6 +76,17 @@ public static Information Exabytes(this T value) => Information.FromExabytes(value.ToDouble(null)); #endif + /// + public static Information Exaoctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromExaoctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromExaoctets(value.ToDouble(null)); +#endif + /// public static Information Exbibits(this T value) where T : notnull @@ -98,6 +109,17 @@ public static Information Exbibytes(this T value) => Information.FromExbibytes(value.ToDouble(null)); #endif + /// + public static Information Exbioctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromExbioctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromExbioctets(value.ToDouble(null)); +#endif + /// public static Information Gibibits(this T value) where T : notnull @@ -120,6 +142,17 @@ public static Information Gibibytes(this T value) => Information.FromGibibytes(value.ToDouble(null)); #endif + /// + public static Information Gibioctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromGibioctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromGibioctets(value.ToDouble(null)); +#endif + /// public static Information Gigabits(this T value) where T : notnull @@ -142,6 +175,17 @@ public static Information Gigabytes(this T value) => Information.FromGigabytes(value.ToDouble(null)); #endif + /// + public static Information Gigaoctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromGigaoctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromGigaoctets(value.ToDouble(null)); +#endif + /// public static Information Kibibits(this T value) where T : notnull @@ -164,6 +208,17 @@ public static Information Kibibytes(this T value) => Information.FromKibibytes(value.ToDouble(null)); #endif + /// + public static Information Kibioctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromKibioctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromKibioctets(value.ToDouble(null)); +#endif + /// public static Information Kilobits(this T value) where T : notnull @@ -186,6 +241,17 @@ public static Information Kilobytes(this T value) => Information.FromKilobytes(value.ToDouble(null)); #endif + /// + public static Information Kilooctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromKilooctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromKilooctets(value.ToDouble(null)); +#endif + /// public static Information Mebibits(this T value) where T : notnull @@ -208,6 +274,17 @@ public static Information Mebibytes(this T value) => Information.FromMebibytes(value.ToDouble(null)); #endif + /// + public static Information Mebioctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromMebioctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromMebioctets(value.ToDouble(null)); +#endif + /// public static Information Megabits(this T value) where T : notnull @@ -230,6 +307,28 @@ public static Information Megabytes(this T value) => Information.FromMegabytes(value.ToDouble(null)); #endif + /// + public static Information Megaoctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromMegaoctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromMegaoctets(value.ToDouble(null)); +#endif + + /// + public static Information Octets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromOctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromOctets(value.ToDouble(null)); +#endif + /// public static Information Pebibits(this T value) where T : notnull @@ -252,6 +351,17 @@ public static Information Pebibytes(this T value) => Information.FromPebibytes(value.ToDouble(null)); #endif + /// + public static Information Pebioctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromPebioctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromPebioctets(value.ToDouble(null)); +#endif + /// public static Information Petabits(this T value) where T : notnull @@ -274,6 +384,17 @@ public static Information Petabytes(this T value) => Information.FromPetabytes(value.ToDouble(null)); #endif + /// + public static Information Petaoctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromPetaoctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromPetaoctets(value.ToDouble(null)); +#endif + /// public static Information Tebibits(this T value) where T : notnull @@ -296,6 +417,17 @@ public static Information Tebibytes(this T value) => Information.FromTebibytes(value.ToDouble(null)); #endif + /// + public static Information Tebioctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromTebioctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromTebioctets(value.ToDouble(null)); +#endif + /// public static Information Terabits(this T value) where T : notnull @@ -318,5 +450,16 @@ public static Information Terabytes(this T value) => Information.FromTerabytes(value.ToDouble(null)); #endif + /// + public static Information Teraoctets(this T value) + where T : notnull +#if NET7_0_OR_GREATER + , INumber + => Information.FromTeraoctets(double.CreateChecked(value)); +#else + , IConvertible + => Information.FromTeraoctets(value.ToDouble(null)); +#endif + } } diff --git a/UnitsNet.Tests/CustomCode/BitRateTests.cs b/UnitsNet.Tests/CustomCode/BitRateTests.cs index ad711f6d76..8a7f25e800 100644 --- a/UnitsNet.Tests/CustomCode/BitRateTests.cs +++ b/UnitsNet.Tests/CustomCode/BitRateTests.cs @@ -29,35 +29,48 @@ public class BitRateTests : BitRateTestsBase { protected override double BitsPerSecondInOneBitPerSecond => 1; protected override double BytesPerSecondInOneBitPerSecond => 1.25E-1; + protected override double OctetsPerSecondInOneBitPerSecond => 1.25E-1; protected override double KilobitsPerSecondInOneBitPerSecond => 1E-3; protected override double KilobytesPerSecondInOneBitPerSecond => 1.25E-4; + protected override double KilooctetsPerSecondInOneBitPerSecond => 1.25E-4; protected override double KibibitsPerSecondInOneBitPerSecond => 0.0009765625; protected override double KibibytesPerSecondInOneBitPerSecond => 0.0001220703125; + protected override double KibioctetsPerSecondInOneBitPerSecond => 0.0001220703125; protected override double MegabitsPerSecondInOneBitPerSecond => 1E-6; protected override double MegabytesPerSecondInOneBitPerSecond => 1.25E-07; + protected override double MegaoctetsPerSecondInOneBitPerSecond => 1.25E-07; protected override double MebibitsPerSecondInOneBitPerSecond => 9.5367431640625E-07; protected override double MebibytesPerSecondInOneBitPerSecond => 1.19209289550781E-07; + protected override double MebioctetsPerSecondInOneBitPerSecond => 1.19209289550781E-07; protected override double GigabitsPerSecondInOneBitPerSecond => 1E-9; protected override double GigabytesPerSecondInOneBitPerSecond => 1.25E-10; + protected override double GigaoctetsPerSecondInOneBitPerSecond => 1.25E-10; protected override double GibibitsPerSecondInOneBitPerSecond => 9.31322574615479E-10; protected override double GibibytesPerSecondInOneBitPerSecond => 1.16415321826935E-10; + protected override double GibioctetsPerSecondInOneBitPerSecond => 1.16415321826935E-10; protected override double TerabitsPerSecondInOneBitPerSecond => 1E-12; protected override double TerabytesPerSecondInOneBitPerSecond => 1.25E-13; + protected override double TeraoctetsPerSecondInOneBitPerSecond => 1.25E-13; protected override double TebibitsPerSecondInOneBitPerSecond => 9.09494701772928E-13; protected override double TebibytesPerSecondInOneBitPerSecond => 1.13686837721616E-13; + protected override double TebioctetsPerSecondInOneBitPerSecond => 1.13686837721616E-13; protected override double PetabitsPerSecondInOneBitPerSecond => 1E-15; protected override double PetabytesPerSecondInOneBitPerSecond => 1.25E-16; + protected override double PetaoctetsPerSecondInOneBitPerSecond => 1.25E-16; protected override double PebibitsPerSecondInOneBitPerSecond => 8.88178419700125E-16; protected override double PebibytesPerSecondInOneBitPerSecond => 1.11022302462516E-16; + protected override double PebioctetsPerSecondInOneBitPerSecond => 1.11022302462516E-16; protected override double ExabitsPerSecondInOneBitPerSecond => 1E-18; protected override double ExabytesPerSecondInOneBitPerSecond => 1.25E-19; + protected override double ExaoctetsPerSecondInOneBitPerSecond => 1.25E-19; protected override double ExbibitsPerSecondInOneBitPerSecond => 8.67361738E-19; protected override double ExbibytesPerSecondInOneBitPerSecond => 1.0842021724855E-19; + protected override double ExbioctetsPerSecondInOneBitPerSecond => 1.0842021724855E-19; } } diff --git a/UnitsNet.Tests/CustomCode/InformationTests.cs b/UnitsNet.Tests/CustomCode/InformationTests.cs index 354a4919a1..3cd13ab2c4 100644 --- a/UnitsNet.Tests/CustomCode/InformationTests.cs +++ b/UnitsNet.Tests/CustomCode/InformationTests.cs @@ -12,54 +12,80 @@ public class InformationTests : InformationTestsBase protected override double BytesInOneBit => 0.125; + protected override double OctetsInOneBit => 0.125; + protected override double ExabitsInOneBit => 1e-18; protected override double ExabytesInOneBit => 0.125*1e-18; + protected override double ExaoctetsInOneBit => 0.125*1e-18; + protected override double ExbibitsInOneBit => 1d/Math.Pow(1024, 6); protected override double ExbibytesInOneBit => 1d/8/Math.Pow(1024, 6); + protected override double ExbioctetsInOneBit => 1d/8/Math.Pow(1024, 6); + protected override double GibibitsInOneBit => 1d/Math.Pow(1024, 3); protected override double GibibytesInOneBit => 1d/8/Math.Pow(1024, 3); + protected override double GibioctetsInOneBit => 1d/8/Math.Pow(1024, 3); + protected override double GigabitsInOneBit => 1e-9; protected override double GigabytesInOneBit => 0.125*1e-9; + protected override double GigaoctetsInOneBit => 0.125*1e-9; + protected override double KibibitsInOneBit => 1d/1024; protected override double KibibytesInOneBit => 1d/8/1024; + protected override double KibioctetsInOneBit => 1d/8/1024; + protected override double KilobitsInOneBit => 0.001; protected override double KilobytesInOneBit => 0.000125; + protected override double KilooctetsInOneBit => 0.000125; + protected override double MebibitsInOneBit => 1d/Math.Pow(1024, 2); protected override double MebibytesInOneBit => 1d/8/Math.Pow(1024, 2); + protected override double MebioctetsInOneBit => 1d/8/Math.Pow(1024, 2); + protected override double MegabitsInOneBit => 1e-6; protected override double MegabytesInOneBit => 0.125*1e-6; + protected override double MegaoctetsInOneBit => 0.125*1e-6; + protected override double PebibitsInOneBit => 1d/Math.Pow(1024, 5); protected override double PebibytesInOneBit => 1d/8/Math.Pow(1024, 5); + protected override double PebioctetsInOneBit => 1d/8/Math.Pow(1024, 5); + protected override double PetabitsInOneBit => 1e-15; protected override double PetabytesInOneBit => 0.125*1e-15; + protected override double PetaoctetsInOneBit => 0.125*1e-15; + protected override double TebibitsInOneBit => 1d/Math.Pow(1024, 4); protected override double TebibytesInOneBit => 1d/8/Math.Pow(1024, 4); + protected override double TebioctetsInOneBit => 1d/8/Math.Pow(1024, 4); + protected override double TerabitsInOneBit => 1e-12; protected override double TerabytesInOneBit => 0.125*1e-12; + protected override double TeraoctetsInOneBit => 0.125*1e-12; + [Fact] public void OneKBHas1000Bytes() { diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 9786abc302..d7ba519990 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -42,7 +42,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, AreaUnit.UsSurveySquareFoot, Quantity.From(3, AreaUnit.UsSurveySquareFoot)); Assertion(3, AreaDensityUnit.MilligramPerSquareMeter, Quantity.From(3, AreaDensityUnit.MilligramPerSquareMeter)); Assertion(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth, Quantity.From(3, AreaMomentOfInertiaUnit.MillimeterToTheFourth)); - Assertion(3, BitRateUnit.TerabytePerSecond, Quantity.From(3, BitRateUnit.TerabytePerSecond)); + Assertion(3, BitRateUnit.TeraoctetPerSecond, Quantity.From(3, BitRateUnit.TeraoctetPerSecond)); Assertion(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour, Quantity.From(3, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour)); Assertion(3, CoefficientOfThermalExpansionUnit.PpmPerKelvin, Quantity.From(3, CoefficientOfThermalExpansionUnit.PpmPerKelvin)); Assertion(3, CompressibilityUnit.InversePoundForcePerSquareInch, Quantity.From(3, CompressibilityUnit.InversePoundForcePerSquareInch)); @@ -86,7 +86,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin, Quantity.From(3, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin)); Assertion(3, IlluminanceUnit.Millilux, Quantity.From(3, IlluminanceUnit.Millilux)); Assertion(3, ImpulseUnit.SlugFootPerSecond, Quantity.From(3, ImpulseUnit.SlugFootPerSecond)); - Assertion(3, InformationUnit.Terabyte, Quantity.From(3, InformationUnit.Terabyte)); + Assertion(3, InformationUnit.Teraoctet, Quantity.From(3, InformationUnit.Teraoctet)); Assertion(3, IrradianceUnit.WattPerSquareMeter, Quantity.From(3, IrradianceUnit.WattPerSquareMeter)); Assertion(3, IrradiationUnit.WattHourPerSquareMeter, Quantity.From(3, IrradiationUnit.WattHourPerSquareMeter)); Assertion(3, JerkUnit.StandardGravitiesPerSecond, Quantity.From(3, JerkUnit.StandardGravitiesPerSecond)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs index 430c1f4f32..7f8b159915 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/BitRateTestsBase.g.cs @@ -43,56 +43,82 @@ public abstract partial class BitRateTestsBase : QuantityTestsBase protected abstract double BytesPerSecondInOneBitPerSecond { get; } protected abstract double ExabitsPerSecondInOneBitPerSecond { get; } protected abstract double ExabytesPerSecondInOneBitPerSecond { get; } + protected abstract double ExaoctetsPerSecondInOneBitPerSecond { get; } protected abstract double ExbibitsPerSecondInOneBitPerSecond { get; } protected abstract double ExbibytesPerSecondInOneBitPerSecond { get; } + protected abstract double ExbioctetsPerSecondInOneBitPerSecond { get; } protected abstract double GibibitsPerSecondInOneBitPerSecond { get; } protected abstract double GibibytesPerSecondInOneBitPerSecond { get; } + protected abstract double GibioctetsPerSecondInOneBitPerSecond { get; } protected abstract double GigabitsPerSecondInOneBitPerSecond { get; } protected abstract double GigabytesPerSecondInOneBitPerSecond { get; } + protected abstract double GigaoctetsPerSecondInOneBitPerSecond { get; } protected abstract double KibibitsPerSecondInOneBitPerSecond { get; } protected abstract double KibibytesPerSecondInOneBitPerSecond { get; } + protected abstract double KibioctetsPerSecondInOneBitPerSecond { get; } protected abstract double KilobitsPerSecondInOneBitPerSecond { get; } protected abstract double KilobytesPerSecondInOneBitPerSecond { get; } + protected abstract double KilooctetsPerSecondInOneBitPerSecond { get; } protected abstract double MebibitsPerSecondInOneBitPerSecond { get; } protected abstract double MebibytesPerSecondInOneBitPerSecond { get; } + protected abstract double MebioctetsPerSecondInOneBitPerSecond { get; } protected abstract double MegabitsPerSecondInOneBitPerSecond { get; } protected abstract double MegabytesPerSecondInOneBitPerSecond { get; } + protected abstract double MegaoctetsPerSecondInOneBitPerSecond { get; } + protected abstract double OctetsPerSecondInOneBitPerSecond { get; } protected abstract double PebibitsPerSecondInOneBitPerSecond { get; } protected abstract double PebibytesPerSecondInOneBitPerSecond { get; } + protected abstract double PebioctetsPerSecondInOneBitPerSecond { get; } protected abstract double PetabitsPerSecondInOneBitPerSecond { get; } protected abstract double PetabytesPerSecondInOneBitPerSecond { get; } + protected abstract double PetaoctetsPerSecondInOneBitPerSecond { get; } protected abstract double TebibitsPerSecondInOneBitPerSecond { get; } protected abstract double TebibytesPerSecondInOneBitPerSecond { get; } + protected abstract double TebioctetsPerSecondInOneBitPerSecond { get; } protected abstract double TerabitsPerSecondInOneBitPerSecond { get; } protected abstract double TerabytesPerSecondInOneBitPerSecond { get; } + protected abstract double TeraoctetsPerSecondInOneBitPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double BitsPerSecondTolerance { get { return 1e-5; } } protected virtual double BytesPerSecondTolerance { get { return 1e-5; } } protected virtual double ExabitsPerSecondTolerance { get { return 1e-5; } } protected virtual double ExabytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double ExaoctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double ExbibitsPerSecondTolerance { get { return 1e-5; } } protected virtual double ExbibytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double ExbioctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double GibibitsPerSecondTolerance { get { return 1e-5; } } protected virtual double GibibytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double GibioctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double GigabitsPerSecondTolerance { get { return 1e-5; } } protected virtual double GigabytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double GigaoctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double KibibitsPerSecondTolerance { get { return 1e-5; } } protected virtual double KibibytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double KibioctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double KilobitsPerSecondTolerance { get { return 1e-5; } } protected virtual double KilobytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double KilooctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double MebibitsPerSecondTolerance { get { return 1e-5; } } protected virtual double MebibytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double MebioctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double MegabitsPerSecondTolerance { get { return 1e-5; } } protected virtual double MegabytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double MegaoctetsPerSecondTolerance { get { return 1e-5; } } + protected virtual double OctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double PebibitsPerSecondTolerance { get { return 1e-5; } } protected virtual double PebibytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double PebioctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double PetabitsPerSecondTolerance { get { return 1e-5; } } protected virtual double PetabytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double PetaoctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double TebibitsPerSecondTolerance { get { return 1e-5; } } protected virtual double TebibytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double TebioctetsPerSecondTolerance { get { return 1e-5; } } protected virtual double TerabitsPerSecondTolerance { get { return 1e-5; } } protected virtual double TerabytesPerSecondTolerance { get { return 1e-5; } } + protected virtual double TeraoctetsPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(BitRateUnit unit) @@ -103,28 +129,41 @@ public abstract partial class BitRateTestsBase : QuantityTestsBase BitRateUnit.BytePerSecond => (BytesPerSecondInOneBitPerSecond, BytesPerSecondTolerance), BitRateUnit.ExabitPerSecond => (ExabitsPerSecondInOneBitPerSecond, ExabitsPerSecondTolerance), BitRateUnit.ExabytePerSecond => (ExabytesPerSecondInOneBitPerSecond, ExabytesPerSecondTolerance), + BitRateUnit.ExaoctetPerSecond => (ExaoctetsPerSecondInOneBitPerSecond, ExaoctetsPerSecondTolerance), BitRateUnit.ExbibitPerSecond => (ExbibitsPerSecondInOneBitPerSecond, ExbibitsPerSecondTolerance), BitRateUnit.ExbibytePerSecond => (ExbibytesPerSecondInOneBitPerSecond, ExbibytesPerSecondTolerance), + BitRateUnit.ExbioctetPerSecond => (ExbioctetsPerSecondInOneBitPerSecond, ExbioctetsPerSecondTolerance), BitRateUnit.GibibitPerSecond => (GibibitsPerSecondInOneBitPerSecond, GibibitsPerSecondTolerance), BitRateUnit.GibibytePerSecond => (GibibytesPerSecondInOneBitPerSecond, GibibytesPerSecondTolerance), + BitRateUnit.GibioctetPerSecond => (GibioctetsPerSecondInOneBitPerSecond, GibioctetsPerSecondTolerance), BitRateUnit.GigabitPerSecond => (GigabitsPerSecondInOneBitPerSecond, GigabitsPerSecondTolerance), BitRateUnit.GigabytePerSecond => (GigabytesPerSecondInOneBitPerSecond, GigabytesPerSecondTolerance), + BitRateUnit.GigaoctetPerSecond => (GigaoctetsPerSecondInOneBitPerSecond, GigaoctetsPerSecondTolerance), BitRateUnit.KibibitPerSecond => (KibibitsPerSecondInOneBitPerSecond, KibibitsPerSecondTolerance), BitRateUnit.KibibytePerSecond => (KibibytesPerSecondInOneBitPerSecond, KibibytesPerSecondTolerance), + BitRateUnit.KibioctetPerSecond => (KibioctetsPerSecondInOneBitPerSecond, KibioctetsPerSecondTolerance), BitRateUnit.KilobitPerSecond => (KilobitsPerSecondInOneBitPerSecond, KilobitsPerSecondTolerance), BitRateUnit.KilobytePerSecond => (KilobytesPerSecondInOneBitPerSecond, KilobytesPerSecondTolerance), + BitRateUnit.KilooctetPerSecond => (KilooctetsPerSecondInOneBitPerSecond, KilooctetsPerSecondTolerance), BitRateUnit.MebibitPerSecond => (MebibitsPerSecondInOneBitPerSecond, MebibitsPerSecondTolerance), BitRateUnit.MebibytePerSecond => (MebibytesPerSecondInOneBitPerSecond, MebibytesPerSecondTolerance), + BitRateUnit.MebioctetPerSecond => (MebioctetsPerSecondInOneBitPerSecond, MebioctetsPerSecondTolerance), BitRateUnit.MegabitPerSecond => (MegabitsPerSecondInOneBitPerSecond, MegabitsPerSecondTolerance), BitRateUnit.MegabytePerSecond => (MegabytesPerSecondInOneBitPerSecond, MegabytesPerSecondTolerance), + BitRateUnit.MegaoctetPerSecond => (MegaoctetsPerSecondInOneBitPerSecond, MegaoctetsPerSecondTolerance), + BitRateUnit.OctetPerSecond => (OctetsPerSecondInOneBitPerSecond, OctetsPerSecondTolerance), BitRateUnit.PebibitPerSecond => (PebibitsPerSecondInOneBitPerSecond, PebibitsPerSecondTolerance), BitRateUnit.PebibytePerSecond => (PebibytesPerSecondInOneBitPerSecond, PebibytesPerSecondTolerance), + BitRateUnit.PebioctetPerSecond => (PebioctetsPerSecondInOneBitPerSecond, PebioctetsPerSecondTolerance), BitRateUnit.PetabitPerSecond => (PetabitsPerSecondInOneBitPerSecond, PetabitsPerSecondTolerance), BitRateUnit.PetabytePerSecond => (PetabytesPerSecondInOneBitPerSecond, PetabytesPerSecondTolerance), + BitRateUnit.PetaoctetPerSecond => (PetaoctetsPerSecondInOneBitPerSecond, PetaoctetsPerSecondTolerance), BitRateUnit.TebibitPerSecond => (TebibitsPerSecondInOneBitPerSecond, TebibitsPerSecondTolerance), BitRateUnit.TebibytePerSecond => (TebibytesPerSecondInOneBitPerSecond, TebibytesPerSecondTolerance), + BitRateUnit.TebioctetPerSecond => (TebioctetsPerSecondInOneBitPerSecond, TebioctetsPerSecondTolerance), BitRateUnit.TerabitPerSecond => (TerabitsPerSecondInOneBitPerSecond, TerabitsPerSecondTolerance), BitRateUnit.TerabytePerSecond => (TerabytesPerSecondInOneBitPerSecond, TerabytesPerSecondTolerance), + BitRateUnit.TeraoctetPerSecond => (TeraoctetsPerSecondInOneBitPerSecond, TeraoctetsPerSecondTolerance), _ => throw new NotSupportedException() }; } @@ -135,28 +174,41 @@ public abstract partial class BitRateTestsBase : QuantityTestsBase new object[] { BitRateUnit.BytePerSecond }, new object[] { BitRateUnit.ExabitPerSecond }, new object[] { BitRateUnit.ExabytePerSecond }, + new object[] { BitRateUnit.ExaoctetPerSecond }, new object[] { BitRateUnit.ExbibitPerSecond }, new object[] { BitRateUnit.ExbibytePerSecond }, + new object[] { BitRateUnit.ExbioctetPerSecond }, new object[] { BitRateUnit.GibibitPerSecond }, new object[] { BitRateUnit.GibibytePerSecond }, + new object[] { BitRateUnit.GibioctetPerSecond }, new object[] { BitRateUnit.GigabitPerSecond }, new object[] { BitRateUnit.GigabytePerSecond }, + new object[] { BitRateUnit.GigaoctetPerSecond }, new object[] { BitRateUnit.KibibitPerSecond }, new object[] { BitRateUnit.KibibytePerSecond }, + new object[] { BitRateUnit.KibioctetPerSecond }, new object[] { BitRateUnit.KilobitPerSecond }, new object[] { BitRateUnit.KilobytePerSecond }, + new object[] { BitRateUnit.KilooctetPerSecond }, new object[] { BitRateUnit.MebibitPerSecond }, new object[] { BitRateUnit.MebibytePerSecond }, + new object[] { BitRateUnit.MebioctetPerSecond }, new object[] { BitRateUnit.MegabitPerSecond }, new object[] { BitRateUnit.MegabytePerSecond }, + new object[] { BitRateUnit.MegaoctetPerSecond }, + new object[] { BitRateUnit.OctetPerSecond }, new object[] { BitRateUnit.PebibitPerSecond }, new object[] { BitRateUnit.PebibytePerSecond }, + new object[] { BitRateUnit.PebioctetPerSecond }, new object[] { BitRateUnit.PetabitPerSecond }, new object[] { BitRateUnit.PetabytePerSecond }, + new object[] { BitRateUnit.PetaoctetPerSecond }, new object[] { BitRateUnit.TebibitPerSecond }, new object[] { BitRateUnit.TebibytePerSecond }, + new object[] { BitRateUnit.TebioctetPerSecond }, new object[] { BitRateUnit.TerabitPerSecond }, new object[] { BitRateUnit.TerabytePerSecond }, + new object[] { BitRateUnit.TeraoctetPerSecond }, }; [Fact] @@ -228,28 +280,41 @@ public void BitPerSecondToBitRateUnits() AssertEx.EqualTolerance(BytesPerSecondInOneBitPerSecond, bitpersecond.BytesPerSecond, BytesPerSecondTolerance); AssertEx.EqualTolerance(ExabitsPerSecondInOneBitPerSecond, bitpersecond.ExabitsPerSecond, ExabitsPerSecondTolerance); AssertEx.EqualTolerance(ExabytesPerSecondInOneBitPerSecond, bitpersecond.ExabytesPerSecond, ExabytesPerSecondTolerance); + AssertEx.EqualTolerance(ExaoctetsPerSecondInOneBitPerSecond, bitpersecond.ExaoctetsPerSecond, ExaoctetsPerSecondTolerance); AssertEx.EqualTolerance(ExbibitsPerSecondInOneBitPerSecond, bitpersecond.ExbibitsPerSecond, ExbibitsPerSecondTolerance); AssertEx.EqualTolerance(ExbibytesPerSecondInOneBitPerSecond, bitpersecond.ExbibytesPerSecond, ExbibytesPerSecondTolerance); + AssertEx.EqualTolerance(ExbioctetsPerSecondInOneBitPerSecond, bitpersecond.ExbioctetsPerSecond, ExbioctetsPerSecondTolerance); AssertEx.EqualTolerance(GibibitsPerSecondInOneBitPerSecond, bitpersecond.GibibitsPerSecond, GibibitsPerSecondTolerance); AssertEx.EqualTolerance(GibibytesPerSecondInOneBitPerSecond, bitpersecond.GibibytesPerSecond, GibibytesPerSecondTolerance); + AssertEx.EqualTolerance(GibioctetsPerSecondInOneBitPerSecond, bitpersecond.GibioctetsPerSecond, GibioctetsPerSecondTolerance); AssertEx.EqualTolerance(GigabitsPerSecondInOneBitPerSecond, bitpersecond.GigabitsPerSecond, GigabitsPerSecondTolerance); AssertEx.EqualTolerance(GigabytesPerSecondInOneBitPerSecond, bitpersecond.GigabytesPerSecond, GigabytesPerSecondTolerance); + AssertEx.EqualTolerance(GigaoctetsPerSecondInOneBitPerSecond, bitpersecond.GigaoctetsPerSecond, GigaoctetsPerSecondTolerance); AssertEx.EqualTolerance(KibibitsPerSecondInOneBitPerSecond, bitpersecond.KibibitsPerSecond, KibibitsPerSecondTolerance); AssertEx.EqualTolerance(KibibytesPerSecondInOneBitPerSecond, bitpersecond.KibibytesPerSecond, KibibytesPerSecondTolerance); + AssertEx.EqualTolerance(KibioctetsPerSecondInOneBitPerSecond, bitpersecond.KibioctetsPerSecond, KibioctetsPerSecondTolerance); AssertEx.EqualTolerance(KilobitsPerSecondInOneBitPerSecond, bitpersecond.KilobitsPerSecond, KilobitsPerSecondTolerance); AssertEx.EqualTolerance(KilobytesPerSecondInOneBitPerSecond, bitpersecond.KilobytesPerSecond, KilobytesPerSecondTolerance); + AssertEx.EqualTolerance(KilooctetsPerSecondInOneBitPerSecond, bitpersecond.KilooctetsPerSecond, KilooctetsPerSecondTolerance); AssertEx.EqualTolerance(MebibitsPerSecondInOneBitPerSecond, bitpersecond.MebibitsPerSecond, MebibitsPerSecondTolerance); AssertEx.EqualTolerance(MebibytesPerSecondInOneBitPerSecond, bitpersecond.MebibytesPerSecond, MebibytesPerSecondTolerance); + AssertEx.EqualTolerance(MebioctetsPerSecondInOneBitPerSecond, bitpersecond.MebioctetsPerSecond, MebioctetsPerSecondTolerance); AssertEx.EqualTolerance(MegabitsPerSecondInOneBitPerSecond, bitpersecond.MegabitsPerSecond, MegabitsPerSecondTolerance); AssertEx.EqualTolerance(MegabytesPerSecondInOneBitPerSecond, bitpersecond.MegabytesPerSecond, MegabytesPerSecondTolerance); + AssertEx.EqualTolerance(MegaoctetsPerSecondInOneBitPerSecond, bitpersecond.MegaoctetsPerSecond, MegaoctetsPerSecondTolerance); + AssertEx.EqualTolerance(OctetsPerSecondInOneBitPerSecond, bitpersecond.OctetsPerSecond, OctetsPerSecondTolerance); AssertEx.EqualTolerance(PebibitsPerSecondInOneBitPerSecond, bitpersecond.PebibitsPerSecond, PebibitsPerSecondTolerance); AssertEx.EqualTolerance(PebibytesPerSecondInOneBitPerSecond, bitpersecond.PebibytesPerSecond, PebibytesPerSecondTolerance); + AssertEx.EqualTolerance(PebioctetsPerSecondInOneBitPerSecond, bitpersecond.PebioctetsPerSecond, PebioctetsPerSecondTolerance); AssertEx.EqualTolerance(PetabitsPerSecondInOneBitPerSecond, bitpersecond.PetabitsPerSecond, PetabitsPerSecondTolerance); AssertEx.EqualTolerance(PetabytesPerSecondInOneBitPerSecond, bitpersecond.PetabytesPerSecond, PetabytesPerSecondTolerance); + AssertEx.EqualTolerance(PetaoctetsPerSecondInOneBitPerSecond, bitpersecond.PetaoctetsPerSecond, PetaoctetsPerSecondTolerance); AssertEx.EqualTolerance(TebibitsPerSecondInOneBitPerSecond, bitpersecond.TebibitsPerSecond, TebibitsPerSecondTolerance); AssertEx.EqualTolerance(TebibytesPerSecondInOneBitPerSecond, bitpersecond.TebibytesPerSecond, TebibytesPerSecondTolerance); + AssertEx.EqualTolerance(TebioctetsPerSecondInOneBitPerSecond, bitpersecond.TebioctetsPerSecond, TebioctetsPerSecondTolerance); AssertEx.EqualTolerance(TerabitsPerSecondInOneBitPerSecond, bitpersecond.TerabitsPerSecond, TerabitsPerSecondTolerance); AssertEx.EqualTolerance(TerabytesPerSecondInOneBitPerSecond, bitpersecond.TerabytesPerSecond, TerabytesPerSecondTolerance); + AssertEx.EqualTolerance(TeraoctetsPerSecondInOneBitPerSecond, bitpersecond.TeraoctetsPerSecond, TeraoctetsPerSecondTolerance); } [Fact] @@ -271,93 +336,145 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity03.ExabytesPerSecond, ExabytesPerSecondTolerance); Assert.Equal(BitRateUnit.ExabytePerSecond, quantity03.Unit); - var quantity04 = BitRate.From(1, BitRateUnit.ExbibitPerSecond); - AssertEx.EqualTolerance(1, quantity04.ExbibitsPerSecond, ExbibitsPerSecondTolerance); - Assert.Equal(BitRateUnit.ExbibitPerSecond, quantity04.Unit); + var quantity04 = BitRate.From(1, BitRateUnit.ExaoctetPerSecond); + AssertEx.EqualTolerance(1, quantity04.ExaoctetsPerSecond, ExaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExaoctetPerSecond, quantity04.Unit); - var quantity05 = BitRate.From(1, BitRateUnit.ExbibytePerSecond); - AssertEx.EqualTolerance(1, quantity05.ExbibytesPerSecond, ExbibytesPerSecondTolerance); - Assert.Equal(BitRateUnit.ExbibytePerSecond, quantity05.Unit); + var quantity05 = BitRate.From(1, BitRateUnit.ExbibitPerSecond); + AssertEx.EqualTolerance(1, quantity05.ExbibitsPerSecond, ExbibitsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExbibitPerSecond, quantity05.Unit); - var quantity06 = BitRate.From(1, BitRateUnit.GibibitPerSecond); - AssertEx.EqualTolerance(1, quantity06.GibibitsPerSecond, GibibitsPerSecondTolerance); - Assert.Equal(BitRateUnit.GibibitPerSecond, quantity06.Unit); + var quantity06 = BitRate.From(1, BitRateUnit.ExbibytePerSecond); + AssertEx.EqualTolerance(1, quantity06.ExbibytesPerSecond, ExbibytesPerSecondTolerance); + Assert.Equal(BitRateUnit.ExbibytePerSecond, quantity06.Unit); - var quantity07 = BitRate.From(1, BitRateUnit.GibibytePerSecond); - AssertEx.EqualTolerance(1, quantity07.GibibytesPerSecond, GibibytesPerSecondTolerance); - Assert.Equal(BitRateUnit.GibibytePerSecond, quantity07.Unit); + var quantity07 = BitRate.From(1, BitRateUnit.ExbioctetPerSecond); + AssertEx.EqualTolerance(1, quantity07.ExbioctetsPerSecond, ExbioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExbioctetPerSecond, quantity07.Unit); - var quantity08 = BitRate.From(1, BitRateUnit.GigabitPerSecond); - AssertEx.EqualTolerance(1, quantity08.GigabitsPerSecond, GigabitsPerSecondTolerance); - Assert.Equal(BitRateUnit.GigabitPerSecond, quantity08.Unit); + var quantity08 = BitRate.From(1, BitRateUnit.GibibitPerSecond); + AssertEx.EqualTolerance(1, quantity08.GibibitsPerSecond, GibibitsPerSecondTolerance); + Assert.Equal(BitRateUnit.GibibitPerSecond, quantity08.Unit); - var quantity09 = BitRate.From(1, BitRateUnit.GigabytePerSecond); - AssertEx.EqualTolerance(1, quantity09.GigabytesPerSecond, GigabytesPerSecondTolerance); - Assert.Equal(BitRateUnit.GigabytePerSecond, quantity09.Unit); + var quantity09 = BitRate.From(1, BitRateUnit.GibibytePerSecond); + AssertEx.EqualTolerance(1, quantity09.GibibytesPerSecond, GibibytesPerSecondTolerance); + Assert.Equal(BitRateUnit.GibibytePerSecond, quantity09.Unit); - var quantity10 = BitRate.From(1, BitRateUnit.KibibitPerSecond); - AssertEx.EqualTolerance(1, quantity10.KibibitsPerSecond, KibibitsPerSecondTolerance); - Assert.Equal(BitRateUnit.KibibitPerSecond, quantity10.Unit); + var quantity10 = BitRate.From(1, BitRateUnit.GibioctetPerSecond); + AssertEx.EqualTolerance(1, quantity10.GibioctetsPerSecond, GibioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.GibioctetPerSecond, quantity10.Unit); - var quantity11 = BitRate.From(1, BitRateUnit.KibibytePerSecond); - AssertEx.EqualTolerance(1, quantity11.KibibytesPerSecond, KibibytesPerSecondTolerance); - Assert.Equal(BitRateUnit.KibibytePerSecond, quantity11.Unit); + var quantity11 = BitRate.From(1, BitRateUnit.GigabitPerSecond); + AssertEx.EqualTolerance(1, quantity11.GigabitsPerSecond, GigabitsPerSecondTolerance); + Assert.Equal(BitRateUnit.GigabitPerSecond, quantity11.Unit); - var quantity12 = BitRate.From(1, BitRateUnit.KilobitPerSecond); - AssertEx.EqualTolerance(1, quantity12.KilobitsPerSecond, KilobitsPerSecondTolerance); - Assert.Equal(BitRateUnit.KilobitPerSecond, quantity12.Unit); + var quantity12 = BitRate.From(1, BitRateUnit.GigabytePerSecond); + AssertEx.EqualTolerance(1, quantity12.GigabytesPerSecond, GigabytesPerSecondTolerance); + Assert.Equal(BitRateUnit.GigabytePerSecond, quantity12.Unit); - var quantity13 = BitRate.From(1, BitRateUnit.KilobytePerSecond); - AssertEx.EqualTolerance(1, quantity13.KilobytesPerSecond, KilobytesPerSecondTolerance); - Assert.Equal(BitRateUnit.KilobytePerSecond, quantity13.Unit); + var quantity13 = BitRate.From(1, BitRateUnit.GigaoctetPerSecond); + AssertEx.EqualTolerance(1, quantity13.GigaoctetsPerSecond, GigaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.GigaoctetPerSecond, quantity13.Unit); - var quantity14 = BitRate.From(1, BitRateUnit.MebibitPerSecond); - AssertEx.EqualTolerance(1, quantity14.MebibitsPerSecond, MebibitsPerSecondTolerance); - Assert.Equal(BitRateUnit.MebibitPerSecond, quantity14.Unit); + var quantity14 = BitRate.From(1, BitRateUnit.KibibitPerSecond); + AssertEx.EqualTolerance(1, quantity14.KibibitsPerSecond, KibibitsPerSecondTolerance); + Assert.Equal(BitRateUnit.KibibitPerSecond, quantity14.Unit); - var quantity15 = BitRate.From(1, BitRateUnit.MebibytePerSecond); - AssertEx.EqualTolerance(1, quantity15.MebibytesPerSecond, MebibytesPerSecondTolerance); - Assert.Equal(BitRateUnit.MebibytePerSecond, quantity15.Unit); + var quantity15 = BitRate.From(1, BitRateUnit.KibibytePerSecond); + AssertEx.EqualTolerance(1, quantity15.KibibytesPerSecond, KibibytesPerSecondTolerance); + Assert.Equal(BitRateUnit.KibibytePerSecond, quantity15.Unit); - var quantity16 = BitRate.From(1, BitRateUnit.MegabitPerSecond); - AssertEx.EqualTolerance(1, quantity16.MegabitsPerSecond, MegabitsPerSecondTolerance); - Assert.Equal(BitRateUnit.MegabitPerSecond, quantity16.Unit); + var quantity16 = BitRate.From(1, BitRateUnit.KibioctetPerSecond); + AssertEx.EqualTolerance(1, quantity16.KibioctetsPerSecond, KibioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.KibioctetPerSecond, quantity16.Unit); - var quantity17 = BitRate.From(1, BitRateUnit.MegabytePerSecond); - AssertEx.EqualTolerance(1, quantity17.MegabytesPerSecond, MegabytesPerSecondTolerance); - Assert.Equal(BitRateUnit.MegabytePerSecond, quantity17.Unit); + var quantity17 = BitRate.From(1, BitRateUnit.KilobitPerSecond); + AssertEx.EqualTolerance(1, quantity17.KilobitsPerSecond, KilobitsPerSecondTolerance); + Assert.Equal(BitRateUnit.KilobitPerSecond, quantity17.Unit); - var quantity18 = BitRate.From(1, BitRateUnit.PebibitPerSecond); - AssertEx.EqualTolerance(1, quantity18.PebibitsPerSecond, PebibitsPerSecondTolerance); - Assert.Equal(BitRateUnit.PebibitPerSecond, quantity18.Unit); + var quantity18 = BitRate.From(1, BitRateUnit.KilobytePerSecond); + AssertEx.EqualTolerance(1, quantity18.KilobytesPerSecond, KilobytesPerSecondTolerance); + Assert.Equal(BitRateUnit.KilobytePerSecond, quantity18.Unit); - var quantity19 = BitRate.From(1, BitRateUnit.PebibytePerSecond); - AssertEx.EqualTolerance(1, quantity19.PebibytesPerSecond, PebibytesPerSecondTolerance); - Assert.Equal(BitRateUnit.PebibytePerSecond, quantity19.Unit); + var quantity19 = BitRate.From(1, BitRateUnit.KilooctetPerSecond); + AssertEx.EqualTolerance(1, quantity19.KilooctetsPerSecond, KilooctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.KilooctetPerSecond, quantity19.Unit); - var quantity20 = BitRate.From(1, BitRateUnit.PetabitPerSecond); - AssertEx.EqualTolerance(1, quantity20.PetabitsPerSecond, PetabitsPerSecondTolerance); - Assert.Equal(BitRateUnit.PetabitPerSecond, quantity20.Unit); + var quantity20 = BitRate.From(1, BitRateUnit.MebibitPerSecond); + AssertEx.EqualTolerance(1, quantity20.MebibitsPerSecond, MebibitsPerSecondTolerance); + Assert.Equal(BitRateUnit.MebibitPerSecond, quantity20.Unit); - var quantity21 = BitRate.From(1, BitRateUnit.PetabytePerSecond); - AssertEx.EqualTolerance(1, quantity21.PetabytesPerSecond, PetabytesPerSecondTolerance); - Assert.Equal(BitRateUnit.PetabytePerSecond, quantity21.Unit); + var quantity21 = BitRate.From(1, BitRateUnit.MebibytePerSecond); + AssertEx.EqualTolerance(1, quantity21.MebibytesPerSecond, MebibytesPerSecondTolerance); + Assert.Equal(BitRateUnit.MebibytePerSecond, quantity21.Unit); - var quantity22 = BitRate.From(1, BitRateUnit.TebibitPerSecond); - AssertEx.EqualTolerance(1, quantity22.TebibitsPerSecond, TebibitsPerSecondTolerance); - Assert.Equal(BitRateUnit.TebibitPerSecond, quantity22.Unit); + var quantity22 = BitRate.From(1, BitRateUnit.MebioctetPerSecond); + AssertEx.EqualTolerance(1, quantity22.MebioctetsPerSecond, MebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.MebioctetPerSecond, quantity22.Unit); - var quantity23 = BitRate.From(1, BitRateUnit.TebibytePerSecond); - AssertEx.EqualTolerance(1, quantity23.TebibytesPerSecond, TebibytesPerSecondTolerance); - Assert.Equal(BitRateUnit.TebibytePerSecond, quantity23.Unit); + var quantity23 = BitRate.From(1, BitRateUnit.MegabitPerSecond); + AssertEx.EqualTolerance(1, quantity23.MegabitsPerSecond, MegabitsPerSecondTolerance); + Assert.Equal(BitRateUnit.MegabitPerSecond, quantity23.Unit); - var quantity24 = BitRate.From(1, BitRateUnit.TerabitPerSecond); - AssertEx.EqualTolerance(1, quantity24.TerabitsPerSecond, TerabitsPerSecondTolerance); - Assert.Equal(BitRateUnit.TerabitPerSecond, quantity24.Unit); + var quantity24 = BitRate.From(1, BitRateUnit.MegabytePerSecond); + AssertEx.EqualTolerance(1, quantity24.MegabytesPerSecond, MegabytesPerSecondTolerance); + Assert.Equal(BitRateUnit.MegabytePerSecond, quantity24.Unit); - var quantity25 = BitRate.From(1, BitRateUnit.TerabytePerSecond); - AssertEx.EqualTolerance(1, quantity25.TerabytesPerSecond, TerabytesPerSecondTolerance); - Assert.Equal(BitRateUnit.TerabytePerSecond, quantity25.Unit); + var quantity25 = BitRate.From(1, BitRateUnit.MegaoctetPerSecond); + AssertEx.EqualTolerance(1, quantity25.MegaoctetsPerSecond, MegaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.MegaoctetPerSecond, quantity25.Unit); + + var quantity26 = BitRate.From(1, BitRateUnit.OctetPerSecond); + AssertEx.EqualTolerance(1, quantity26.OctetsPerSecond, OctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.OctetPerSecond, quantity26.Unit); + + var quantity27 = BitRate.From(1, BitRateUnit.PebibitPerSecond); + AssertEx.EqualTolerance(1, quantity27.PebibitsPerSecond, PebibitsPerSecondTolerance); + Assert.Equal(BitRateUnit.PebibitPerSecond, quantity27.Unit); + + var quantity28 = BitRate.From(1, BitRateUnit.PebibytePerSecond); + AssertEx.EqualTolerance(1, quantity28.PebibytesPerSecond, PebibytesPerSecondTolerance); + Assert.Equal(BitRateUnit.PebibytePerSecond, quantity28.Unit); + + var quantity29 = BitRate.From(1, BitRateUnit.PebioctetPerSecond); + AssertEx.EqualTolerance(1, quantity29.PebioctetsPerSecond, PebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.PebioctetPerSecond, quantity29.Unit); + + var quantity30 = BitRate.From(1, BitRateUnit.PetabitPerSecond); + AssertEx.EqualTolerance(1, quantity30.PetabitsPerSecond, PetabitsPerSecondTolerance); + Assert.Equal(BitRateUnit.PetabitPerSecond, quantity30.Unit); + + var quantity31 = BitRate.From(1, BitRateUnit.PetabytePerSecond); + AssertEx.EqualTolerance(1, quantity31.PetabytesPerSecond, PetabytesPerSecondTolerance); + Assert.Equal(BitRateUnit.PetabytePerSecond, quantity31.Unit); + + var quantity32 = BitRate.From(1, BitRateUnit.PetaoctetPerSecond); + AssertEx.EqualTolerance(1, quantity32.PetaoctetsPerSecond, PetaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.PetaoctetPerSecond, quantity32.Unit); + + var quantity33 = BitRate.From(1, BitRateUnit.TebibitPerSecond); + AssertEx.EqualTolerance(1, quantity33.TebibitsPerSecond, TebibitsPerSecondTolerance); + Assert.Equal(BitRateUnit.TebibitPerSecond, quantity33.Unit); + + var quantity34 = BitRate.From(1, BitRateUnit.TebibytePerSecond); + AssertEx.EqualTolerance(1, quantity34.TebibytesPerSecond, TebibytesPerSecondTolerance); + Assert.Equal(BitRateUnit.TebibytePerSecond, quantity34.Unit); + + var quantity35 = BitRate.From(1, BitRateUnit.TebioctetPerSecond); + AssertEx.EqualTolerance(1, quantity35.TebioctetsPerSecond, TebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.TebioctetPerSecond, quantity35.Unit); + + var quantity36 = BitRate.From(1, BitRateUnit.TerabitPerSecond); + AssertEx.EqualTolerance(1, quantity36.TerabitsPerSecond, TerabitsPerSecondTolerance); + Assert.Equal(BitRateUnit.TerabitPerSecond, quantity36.Unit); + + var quantity37 = BitRate.From(1, BitRateUnit.TerabytePerSecond); + AssertEx.EqualTolerance(1, quantity37.TerabytesPerSecond, TerabytesPerSecondTolerance); + Assert.Equal(BitRateUnit.TerabytePerSecond, quantity37.Unit); + + var quantity38 = BitRate.From(1, BitRateUnit.TeraoctetPerSecond); + AssertEx.EqualTolerance(1, quantity38.TeraoctetsPerSecond, TeraoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.TeraoctetPerSecond, quantity38.Unit); } @@ -387,28 +504,41 @@ public void As() AssertEx.EqualTolerance(BytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.BytePerSecond), BytesPerSecondTolerance); AssertEx.EqualTolerance(ExabitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExabitPerSecond), ExabitsPerSecondTolerance); AssertEx.EqualTolerance(ExabytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExabytePerSecond), ExabytesPerSecondTolerance); + AssertEx.EqualTolerance(ExaoctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExaoctetPerSecond), ExaoctetsPerSecondTolerance); AssertEx.EqualTolerance(ExbibitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExbibitPerSecond), ExbibitsPerSecondTolerance); AssertEx.EqualTolerance(ExbibytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExbibytePerSecond), ExbibytesPerSecondTolerance); + AssertEx.EqualTolerance(ExbioctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.ExbioctetPerSecond), ExbioctetsPerSecondTolerance); AssertEx.EqualTolerance(GibibitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.GibibitPerSecond), GibibitsPerSecondTolerance); AssertEx.EqualTolerance(GibibytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.GibibytePerSecond), GibibytesPerSecondTolerance); + AssertEx.EqualTolerance(GibioctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.GibioctetPerSecond), GibioctetsPerSecondTolerance); AssertEx.EqualTolerance(GigabitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.GigabitPerSecond), GigabitsPerSecondTolerance); AssertEx.EqualTolerance(GigabytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.GigabytePerSecond), GigabytesPerSecondTolerance); + AssertEx.EqualTolerance(GigaoctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.GigaoctetPerSecond), GigaoctetsPerSecondTolerance); AssertEx.EqualTolerance(KibibitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.KibibitPerSecond), KibibitsPerSecondTolerance); AssertEx.EqualTolerance(KibibytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.KibibytePerSecond), KibibytesPerSecondTolerance); + AssertEx.EqualTolerance(KibioctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.KibioctetPerSecond), KibioctetsPerSecondTolerance); AssertEx.EqualTolerance(KilobitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.KilobitPerSecond), KilobitsPerSecondTolerance); AssertEx.EqualTolerance(KilobytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.KilobytePerSecond), KilobytesPerSecondTolerance); + AssertEx.EqualTolerance(KilooctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.KilooctetPerSecond), KilooctetsPerSecondTolerance); AssertEx.EqualTolerance(MebibitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.MebibitPerSecond), MebibitsPerSecondTolerance); AssertEx.EqualTolerance(MebibytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.MebibytePerSecond), MebibytesPerSecondTolerance); + AssertEx.EqualTolerance(MebioctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.MebioctetPerSecond), MebioctetsPerSecondTolerance); AssertEx.EqualTolerance(MegabitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.MegabitPerSecond), MegabitsPerSecondTolerance); AssertEx.EqualTolerance(MegabytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.MegabytePerSecond), MegabytesPerSecondTolerance); + AssertEx.EqualTolerance(MegaoctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.MegaoctetPerSecond), MegaoctetsPerSecondTolerance); + AssertEx.EqualTolerance(OctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.OctetPerSecond), OctetsPerSecondTolerance); AssertEx.EqualTolerance(PebibitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.PebibitPerSecond), PebibitsPerSecondTolerance); AssertEx.EqualTolerance(PebibytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.PebibytePerSecond), PebibytesPerSecondTolerance); + AssertEx.EqualTolerance(PebioctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.PebioctetPerSecond), PebioctetsPerSecondTolerance); AssertEx.EqualTolerance(PetabitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.PetabitPerSecond), PetabitsPerSecondTolerance); AssertEx.EqualTolerance(PetabytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.PetabytePerSecond), PetabytesPerSecondTolerance); + AssertEx.EqualTolerance(PetaoctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.PetaoctetPerSecond), PetaoctetsPerSecondTolerance); AssertEx.EqualTolerance(TebibitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.TebibitPerSecond), TebibitsPerSecondTolerance); AssertEx.EqualTolerance(TebibytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.TebibytePerSecond), TebibytesPerSecondTolerance); + AssertEx.EqualTolerance(TebioctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.TebioctetPerSecond), TebioctetsPerSecondTolerance); AssertEx.EqualTolerance(TerabitsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.TerabitPerSecond), TerabitsPerSecondTolerance); AssertEx.EqualTolerance(TerabytesPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.TerabytePerSecond), TerabytesPerSecondTolerance); + AssertEx.EqualTolerance(TeraoctetsPerSecondInOneBitPerSecond, bitpersecond.As(BitRateUnit.TeraoctetPerSecond), TeraoctetsPerSecondTolerance); } [Fact] @@ -562,6 +692,13 @@ public void Parse() Assert.Equal(BitRateUnit.ExabytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Eo/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.ExaoctetsPerSecond, ExaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExaoctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Eibit/s", CultureInfo.GetCultureInfo("en-US")); @@ -583,6 +720,13 @@ public void Parse() Assert.Equal(BitRateUnit.ExbibytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Eio/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.ExbioctetsPerSecond, ExbioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExbioctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Gibit/s", CultureInfo.GetCultureInfo("en-US")); @@ -604,6 +748,13 @@ public void Parse() Assert.Equal(BitRateUnit.GibibytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Gio/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.GibioctetsPerSecond, GibioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.GibioctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Gbit/s", CultureInfo.GetCultureInfo("en-US")); @@ -625,6 +776,13 @@ public void Parse() Assert.Equal(BitRateUnit.GigabytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Go/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.GigaoctetsPerSecond, GigaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.GigaoctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Kibit/s", CultureInfo.GetCultureInfo("en-US")); @@ -646,6 +804,13 @@ public void Parse() Assert.Equal(BitRateUnit.KibibytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Kio/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.KibioctetsPerSecond, KibioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.KibioctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 kbit/s", CultureInfo.GetCultureInfo("en-US")); @@ -667,6 +832,13 @@ public void Parse() Assert.Equal(BitRateUnit.KilobytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 ko/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.KilooctetsPerSecond, KilooctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.KilooctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Mibit/s", CultureInfo.GetCultureInfo("en-US")); @@ -688,6 +860,13 @@ public void Parse() Assert.Equal(BitRateUnit.MebibytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Mio/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.MebioctetsPerSecond, MebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.MebioctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Mbit/s", CultureInfo.GetCultureInfo("en-US")); @@ -709,6 +888,20 @@ public void Parse() Assert.Equal(BitRateUnit.MegabytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Mo/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.MegaoctetsPerSecond, MegaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.MegaoctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = BitRate.Parse("1 o/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.OctetsPerSecond, OctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.OctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Pibit/s", CultureInfo.GetCultureInfo("en-US")); @@ -730,6 +923,13 @@ public void Parse() Assert.Equal(BitRateUnit.PebibytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Pio/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.PebioctetsPerSecond, PebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.PebioctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Pbit/s", CultureInfo.GetCultureInfo("en-US")); @@ -751,6 +951,13 @@ public void Parse() Assert.Equal(BitRateUnit.PetabytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Po/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.PetaoctetsPerSecond, PetaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.PetaoctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Tibit/s", CultureInfo.GetCultureInfo("en-US")); @@ -772,6 +979,13 @@ public void Parse() Assert.Equal(BitRateUnit.TebibytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 Tio/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.TebioctetsPerSecond, TebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.TebioctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = BitRate.Parse("1 Tbit/s", CultureInfo.GetCultureInfo("en-US")); @@ -793,6 +1007,13 @@ public void Parse() Assert.Equal(BitRateUnit.TerabytePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = BitRate.Parse("1 To/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.TeraoctetsPerSecond, TeraoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.TeraoctetPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + } [Fact] @@ -834,6 +1055,12 @@ public void TryParse() Assert.Equal(BitRateUnit.ExabytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Eo/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.ExaoctetsPerSecond, ExaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExaoctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Eibit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.ExbibitsPerSecond, ExbibitsPerSecondTolerance); @@ -852,6 +1079,12 @@ public void TryParse() Assert.Equal(BitRateUnit.ExbibytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Eio/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.ExbioctetsPerSecond, ExbioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.ExbioctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Gibit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.GibibitsPerSecond, GibibitsPerSecondTolerance); @@ -870,6 +1103,12 @@ public void TryParse() Assert.Equal(BitRateUnit.GibibytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Gio/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.GibioctetsPerSecond, GibioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.GibioctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Gbit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.GigabitsPerSecond, GigabitsPerSecondTolerance); @@ -888,6 +1127,12 @@ public void TryParse() Assert.Equal(BitRateUnit.GigabytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Go/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.GigaoctetsPerSecond, GigaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.GigaoctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Kibit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.KibibitsPerSecond, KibibitsPerSecondTolerance); @@ -906,6 +1151,12 @@ public void TryParse() Assert.Equal(BitRateUnit.KibibytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Kio/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.KibioctetsPerSecond, KibioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.KibioctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 kbit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.KilobitsPerSecond, KilobitsPerSecondTolerance); @@ -924,6 +1175,12 @@ public void TryParse() Assert.Equal(BitRateUnit.KilobytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 ko/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.KilooctetsPerSecond, KilooctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.KilooctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Mibit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MebibitsPerSecond, MebibitsPerSecondTolerance); @@ -942,6 +1199,12 @@ public void TryParse() Assert.Equal(BitRateUnit.MebibytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Mio/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MebioctetsPerSecond, MebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.MebioctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Mbit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MegabitsPerSecond, MegabitsPerSecondTolerance); @@ -960,6 +1223,18 @@ public void TryParse() Assert.Equal(BitRateUnit.MegabytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Mo/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MegaoctetsPerSecond, MegaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.MegaoctetPerSecond, parsed.Unit); + } + + { + Assert.True(BitRate.TryParse("1 o/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.OctetsPerSecond, OctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.OctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Pibit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.PebibitsPerSecond, PebibitsPerSecondTolerance); @@ -978,6 +1253,12 @@ public void TryParse() Assert.Equal(BitRateUnit.PebibytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Pio/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.PebioctetsPerSecond, PebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.PebioctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Pbit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.PetabitsPerSecond, PetabitsPerSecondTolerance); @@ -996,6 +1277,12 @@ public void TryParse() Assert.Equal(BitRateUnit.PetabytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Po/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.PetaoctetsPerSecond, PetaoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.PetaoctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Tibit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.TebibitsPerSecond, TebibitsPerSecondTolerance); @@ -1014,6 +1301,12 @@ public void TryParse() Assert.Equal(BitRateUnit.TebibytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 Tio/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.TebioctetsPerSecond, TebioctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.TebioctetPerSecond, parsed.Unit); + } + { Assert.True(BitRate.TryParse("1 Tbit/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.TerabitsPerSecond, TerabitsPerSecondTolerance); @@ -1032,6 +1325,12 @@ public void TryParse() Assert.Equal(BitRateUnit.TerabytePerSecond, parsed.Unit); } + { + Assert.True(BitRate.TryParse("1 To/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.TeraoctetsPerSecond, TeraoctetsPerSecondTolerance); + Assert.Equal(BitRateUnit.TeraoctetPerSecond, parsed.Unit); + } + } [Theory] @@ -1041,39 +1340,52 @@ public void TryParse() [InlineData("Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("kbps", BitRateUnit.KilobitPerSecond)] [InlineData("kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("o/s", BitRateUnit.OctetPerSecond)] [InlineData("Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("To/s", BitRateUnit.TeraoctetPerSecond)] public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, BitRateUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -1089,39 +1401,52 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, BitRateUn [InlineData("Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("kbps", BitRateUnit.KilobitPerSecond)] [InlineData("kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("o/s", BitRateUnit.OctetPerSecond)] [InlineData("Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("To/s", BitRateUnit.TeraoctetPerSecond)] public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, BitRateUnit expectedUnit) { // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. @@ -1137,39 +1462,52 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [InlineData("en-US", "Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("en-US", "Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("en-US", "Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("en-US", "Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("en-US", "Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("en-US", "Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("en-US", "Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("en-US", "Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("en-US", "Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("en-US", "Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("en-US", "kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kbps", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("en-US", "ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("en-US", "Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("en-US", "Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("en-US", "Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("en-US", "Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("en-US", "o/s", BitRateUnit.OctetPerSecond)] [InlineData("en-US", "Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("en-US", "Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("en-US", "Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("en-US", "Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("en-US", "Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("en-US", "Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("en-US", "Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("en-US", "To/s", BitRateUnit.TeraoctetPerSecond)] public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, BitRateUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -1184,39 +1522,52 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, Bi [InlineData("en-US", "Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("en-US", "Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("en-US", "Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("en-US", "Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("en-US", "Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("en-US", "Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("en-US", "Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("en-US", "Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("en-US", "Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("en-US", "Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("en-US", "kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kbps", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("en-US", "ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("en-US", "Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("en-US", "Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("en-US", "Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("en-US", "Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("en-US", "o/s", BitRateUnit.OctetPerSecond)] [InlineData("en-US", "Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("en-US", "Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("en-US", "Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("en-US", "Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("en-US", "Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("en-US", "Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("en-US", "Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("en-US", "To/s", BitRateUnit.TeraoctetPerSecond)] public void ParseUnit_WithCulture(string culture, string abbreviation, BitRateUnit expectedUnit) { BitRateUnit parsedUnit = BitRate.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture)); @@ -1230,39 +1581,52 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, BitRateUn [InlineData("Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("kbps", BitRateUnit.KilobitPerSecond)] [InlineData("kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("o/s", BitRateUnit.OctetPerSecond)] [InlineData("Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("To/s", BitRateUnit.TeraoctetPerSecond)] public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, BitRateUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -1278,39 +1642,52 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, BitRat [InlineData("Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("kbps", BitRateUnit.KilobitPerSecond)] [InlineData("kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("o/s", BitRateUnit.OctetPerSecond)] [InlineData("Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("To/s", BitRateUnit.TeraoctetPerSecond)] public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, BitRateUnit expectedUnit) { // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. @@ -1326,39 +1703,52 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [InlineData("en-US", "Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("en-US", "Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("en-US", "Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("en-US", "Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("en-US", "Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("en-US", "Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("en-US", "Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("en-US", "Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("en-US", "Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("en-US", "Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("en-US", "kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kbps", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("en-US", "ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("en-US", "Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("en-US", "Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("en-US", "Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("en-US", "Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("en-US", "o/s", BitRateUnit.OctetPerSecond)] [InlineData("en-US", "Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("en-US", "Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("en-US", "Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("en-US", "Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("en-US", "Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("en-US", "Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("en-US", "Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("en-US", "To/s", BitRateUnit.TeraoctetPerSecond)] public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, BitRateUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -1373,39 +1763,52 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [InlineData("en-US", "Ebit/s", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "Ebps", BitRateUnit.ExabitPerSecond)] [InlineData("en-US", "EB/s", BitRateUnit.ExabytePerSecond)] + [InlineData("en-US", "Eo/s", BitRateUnit.ExaoctetPerSecond)] [InlineData("en-US", "Eibit/s", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "Eibps", BitRateUnit.ExbibitPerSecond)] [InlineData("en-US", "EiB/s", BitRateUnit.ExbibytePerSecond)] + [InlineData("en-US", "Eio/s", BitRateUnit.ExbioctetPerSecond)] [InlineData("en-US", "Gibit/s", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "Gibps", BitRateUnit.GibibitPerSecond)] [InlineData("en-US", "GiB/s", BitRateUnit.GibibytePerSecond)] + [InlineData("en-US", "Gio/s", BitRateUnit.GibioctetPerSecond)] [InlineData("en-US", "Gbit/s", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "Gbps", BitRateUnit.GigabitPerSecond)] [InlineData("en-US", "GB/s", BitRateUnit.GigabytePerSecond)] + [InlineData("en-US", "Go/s", BitRateUnit.GigaoctetPerSecond)] [InlineData("en-US", "Kibit/s", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "Kibps", BitRateUnit.KibibitPerSecond)] [InlineData("en-US", "KiB/s", BitRateUnit.KibibytePerSecond)] + [InlineData("en-US", "Kio/s", BitRateUnit.KibioctetPerSecond)] [InlineData("en-US", "kbit/s", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kbps", BitRateUnit.KilobitPerSecond)] [InlineData("en-US", "kB/s", BitRateUnit.KilobytePerSecond)] + [InlineData("en-US", "ko/s", BitRateUnit.KilooctetPerSecond)] [InlineData("en-US", "Mibit/s", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "Mibps", BitRateUnit.MebibitPerSecond)] [InlineData("en-US", "MiB/s", BitRateUnit.MebibytePerSecond)] + [InlineData("en-US", "Mio/s", BitRateUnit.MebioctetPerSecond)] [InlineData("en-US", "Mbit/s", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "Mbps", BitRateUnit.MegabitPerSecond)] [InlineData("en-US", "MB/s", BitRateUnit.MegabytePerSecond)] + [InlineData("en-US", "Mo/s", BitRateUnit.MegaoctetPerSecond)] + [InlineData("en-US", "o/s", BitRateUnit.OctetPerSecond)] [InlineData("en-US", "Pibit/s", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "Pibps", BitRateUnit.PebibitPerSecond)] [InlineData("en-US", "PiB/s", BitRateUnit.PebibytePerSecond)] + [InlineData("en-US", "Pio/s", BitRateUnit.PebioctetPerSecond)] [InlineData("en-US", "Pbit/s", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "Pbps", BitRateUnit.PetabitPerSecond)] [InlineData("en-US", "PB/s", BitRateUnit.PetabytePerSecond)] + [InlineData("en-US", "Po/s", BitRateUnit.PetaoctetPerSecond)] [InlineData("en-US", "Tibit/s", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "Tibps", BitRateUnit.TebibitPerSecond)] [InlineData("en-US", "TiB/s", BitRateUnit.TebibytePerSecond)] + [InlineData("en-US", "Tio/s", BitRateUnit.TebioctetPerSecond)] [InlineData("en-US", "Tbit/s", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "Tbps", BitRateUnit.TerabitPerSecond)] [InlineData("en-US", "TB/s", BitRateUnit.TerabytePerSecond)] + [InlineData("en-US", "To/s", BitRateUnit.TeraoctetPerSecond)] public void TryParseUnit_WithCulture(string culture, string abbreviation, BitRateUnit expectedUnit) { Assert.True(BitRate.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out BitRateUnit parsedUnit)); @@ -1481,28 +1884,41 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, BitRate.FromBytesPerSecond(bitpersecond.BytesPerSecond).BitsPerSecond, BytesPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromExabitsPerSecond(bitpersecond.ExabitsPerSecond).BitsPerSecond, ExabitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromExabytesPerSecond(bitpersecond.ExabytesPerSecond).BitsPerSecond, ExabytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromExaoctetsPerSecond(bitpersecond.ExaoctetsPerSecond).BitsPerSecond, ExaoctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromExbibitsPerSecond(bitpersecond.ExbibitsPerSecond).BitsPerSecond, ExbibitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromExbibytesPerSecond(bitpersecond.ExbibytesPerSecond).BitsPerSecond, ExbibytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromExbioctetsPerSecond(bitpersecond.ExbioctetsPerSecond).BitsPerSecond, ExbioctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromGibibitsPerSecond(bitpersecond.GibibitsPerSecond).BitsPerSecond, GibibitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromGibibytesPerSecond(bitpersecond.GibibytesPerSecond).BitsPerSecond, GibibytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromGibioctetsPerSecond(bitpersecond.GibioctetsPerSecond).BitsPerSecond, GibioctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromGigabitsPerSecond(bitpersecond.GigabitsPerSecond).BitsPerSecond, GigabitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromGigabytesPerSecond(bitpersecond.GigabytesPerSecond).BitsPerSecond, GigabytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromGigaoctetsPerSecond(bitpersecond.GigaoctetsPerSecond).BitsPerSecond, GigaoctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromKibibitsPerSecond(bitpersecond.KibibitsPerSecond).BitsPerSecond, KibibitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromKibibytesPerSecond(bitpersecond.KibibytesPerSecond).BitsPerSecond, KibibytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromKibioctetsPerSecond(bitpersecond.KibioctetsPerSecond).BitsPerSecond, KibioctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromKilobitsPerSecond(bitpersecond.KilobitsPerSecond).BitsPerSecond, KilobitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromKilobytesPerSecond(bitpersecond.KilobytesPerSecond).BitsPerSecond, KilobytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromKilooctetsPerSecond(bitpersecond.KilooctetsPerSecond).BitsPerSecond, KilooctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromMebibitsPerSecond(bitpersecond.MebibitsPerSecond).BitsPerSecond, MebibitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromMebibytesPerSecond(bitpersecond.MebibytesPerSecond).BitsPerSecond, MebibytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromMebioctetsPerSecond(bitpersecond.MebioctetsPerSecond).BitsPerSecond, MebioctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromMegabitsPerSecond(bitpersecond.MegabitsPerSecond).BitsPerSecond, MegabitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromMegabytesPerSecond(bitpersecond.MegabytesPerSecond).BitsPerSecond, MegabytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromMegaoctetsPerSecond(bitpersecond.MegaoctetsPerSecond).BitsPerSecond, MegaoctetsPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromOctetsPerSecond(bitpersecond.OctetsPerSecond).BitsPerSecond, OctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromPebibitsPerSecond(bitpersecond.PebibitsPerSecond).BitsPerSecond, PebibitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromPebibytesPerSecond(bitpersecond.PebibytesPerSecond).BitsPerSecond, PebibytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromPebioctetsPerSecond(bitpersecond.PebioctetsPerSecond).BitsPerSecond, PebioctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromPetabitsPerSecond(bitpersecond.PetabitsPerSecond).BitsPerSecond, PetabitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromPetabytesPerSecond(bitpersecond.PetabytesPerSecond).BitsPerSecond, PetabytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromPetaoctetsPerSecond(bitpersecond.PetaoctetsPerSecond).BitsPerSecond, PetaoctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromTebibitsPerSecond(bitpersecond.TebibitsPerSecond).BitsPerSecond, TebibitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromTebibytesPerSecond(bitpersecond.TebibytesPerSecond).BitsPerSecond, TebibytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromTebioctetsPerSecond(bitpersecond.TebioctetsPerSecond).BitsPerSecond, TebioctetsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromTerabitsPerSecond(bitpersecond.TerabitsPerSecond).BitsPerSecond, TerabitsPerSecondTolerance); AssertEx.EqualTolerance(1, BitRate.FromTerabytesPerSecond(bitpersecond.TerabytesPerSecond).BitsPerSecond, TerabytesPerSecondTolerance); + AssertEx.EqualTolerance(1, BitRate.FromTeraoctetsPerSecond(bitpersecond.TeraoctetsPerSecond).BitsPerSecond, TeraoctetsPerSecondTolerance); } [Fact] @@ -1654,28 +2070,41 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 B/s", new BitRate(1, BitRateUnit.BytePerSecond).ToString()); Assert.Equal("1 Ebit/s", new BitRate(1, BitRateUnit.ExabitPerSecond).ToString()); Assert.Equal("1 EB/s", new BitRate(1, BitRateUnit.ExabytePerSecond).ToString()); + Assert.Equal("1 Eo/s", new BitRate(1, BitRateUnit.ExaoctetPerSecond).ToString()); Assert.Equal("1 Eibit/s", new BitRate(1, BitRateUnit.ExbibitPerSecond).ToString()); Assert.Equal("1 EiB/s", new BitRate(1, BitRateUnit.ExbibytePerSecond).ToString()); + Assert.Equal("1 Eio/s", new BitRate(1, BitRateUnit.ExbioctetPerSecond).ToString()); Assert.Equal("1 Gibit/s", new BitRate(1, BitRateUnit.GibibitPerSecond).ToString()); Assert.Equal("1 GiB/s", new BitRate(1, BitRateUnit.GibibytePerSecond).ToString()); + Assert.Equal("1 Gio/s", new BitRate(1, BitRateUnit.GibioctetPerSecond).ToString()); Assert.Equal("1 Gbit/s", new BitRate(1, BitRateUnit.GigabitPerSecond).ToString()); Assert.Equal("1 GB/s", new BitRate(1, BitRateUnit.GigabytePerSecond).ToString()); + Assert.Equal("1 Go/s", new BitRate(1, BitRateUnit.GigaoctetPerSecond).ToString()); Assert.Equal("1 Kibit/s", new BitRate(1, BitRateUnit.KibibitPerSecond).ToString()); Assert.Equal("1 KiB/s", new BitRate(1, BitRateUnit.KibibytePerSecond).ToString()); + Assert.Equal("1 Kio/s", new BitRate(1, BitRateUnit.KibioctetPerSecond).ToString()); Assert.Equal("1 kbit/s", new BitRate(1, BitRateUnit.KilobitPerSecond).ToString()); Assert.Equal("1 kB/s", new BitRate(1, BitRateUnit.KilobytePerSecond).ToString()); + Assert.Equal("1 ko/s", new BitRate(1, BitRateUnit.KilooctetPerSecond).ToString()); Assert.Equal("1 Mibit/s", new BitRate(1, BitRateUnit.MebibitPerSecond).ToString()); Assert.Equal("1 MiB/s", new BitRate(1, BitRateUnit.MebibytePerSecond).ToString()); + Assert.Equal("1 Mio/s", new BitRate(1, BitRateUnit.MebioctetPerSecond).ToString()); Assert.Equal("1 Mbit/s", new BitRate(1, BitRateUnit.MegabitPerSecond).ToString()); Assert.Equal("1 MB/s", new BitRate(1, BitRateUnit.MegabytePerSecond).ToString()); + Assert.Equal("1 Mo/s", new BitRate(1, BitRateUnit.MegaoctetPerSecond).ToString()); + Assert.Equal("1 o/s", new BitRate(1, BitRateUnit.OctetPerSecond).ToString()); Assert.Equal("1 Pibit/s", new BitRate(1, BitRateUnit.PebibitPerSecond).ToString()); Assert.Equal("1 PiB/s", new BitRate(1, BitRateUnit.PebibytePerSecond).ToString()); + Assert.Equal("1 Pio/s", new BitRate(1, BitRateUnit.PebioctetPerSecond).ToString()); Assert.Equal("1 Pbit/s", new BitRate(1, BitRateUnit.PetabitPerSecond).ToString()); Assert.Equal("1 PB/s", new BitRate(1, BitRateUnit.PetabytePerSecond).ToString()); + Assert.Equal("1 Po/s", new BitRate(1, BitRateUnit.PetaoctetPerSecond).ToString()); Assert.Equal("1 Tibit/s", new BitRate(1, BitRateUnit.TebibitPerSecond).ToString()); Assert.Equal("1 TiB/s", new BitRate(1, BitRateUnit.TebibytePerSecond).ToString()); + Assert.Equal("1 Tio/s", new BitRate(1, BitRateUnit.TebioctetPerSecond).ToString()); Assert.Equal("1 Tbit/s", new BitRate(1, BitRateUnit.TerabitPerSecond).ToString()); Assert.Equal("1 TB/s", new BitRate(1, BitRateUnit.TerabytePerSecond).ToString()); + Assert.Equal("1 To/s", new BitRate(1, BitRateUnit.TeraoctetPerSecond).ToString()); } [Fact] @@ -1688,28 +2117,41 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 B/s", new BitRate(1, BitRateUnit.BytePerSecond).ToString(swedishCulture)); Assert.Equal("1 Ebit/s", new BitRate(1, BitRateUnit.ExabitPerSecond).ToString(swedishCulture)); Assert.Equal("1 EB/s", new BitRate(1, BitRateUnit.ExabytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Eo/s", new BitRate(1, BitRateUnit.ExaoctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Eibit/s", new BitRate(1, BitRateUnit.ExbibitPerSecond).ToString(swedishCulture)); Assert.Equal("1 EiB/s", new BitRate(1, BitRateUnit.ExbibytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Eio/s", new BitRate(1, BitRateUnit.ExbioctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Gibit/s", new BitRate(1, BitRateUnit.GibibitPerSecond).ToString(swedishCulture)); Assert.Equal("1 GiB/s", new BitRate(1, BitRateUnit.GibibytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Gio/s", new BitRate(1, BitRateUnit.GibioctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Gbit/s", new BitRate(1, BitRateUnit.GigabitPerSecond).ToString(swedishCulture)); Assert.Equal("1 GB/s", new BitRate(1, BitRateUnit.GigabytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Go/s", new BitRate(1, BitRateUnit.GigaoctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Kibit/s", new BitRate(1, BitRateUnit.KibibitPerSecond).ToString(swedishCulture)); Assert.Equal("1 KiB/s", new BitRate(1, BitRateUnit.KibibytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Kio/s", new BitRate(1, BitRateUnit.KibioctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 kbit/s", new BitRate(1, BitRateUnit.KilobitPerSecond).ToString(swedishCulture)); Assert.Equal("1 kB/s", new BitRate(1, BitRateUnit.KilobytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 ko/s", new BitRate(1, BitRateUnit.KilooctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Mibit/s", new BitRate(1, BitRateUnit.MebibitPerSecond).ToString(swedishCulture)); Assert.Equal("1 MiB/s", new BitRate(1, BitRateUnit.MebibytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Mio/s", new BitRate(1, BitRateUnit.MebioctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Mbit/s", new BitRate(1, BitRateUnit.MegabitPerSecond).ToString(swedishCulture)); Assert.Equal("1 MB/s", new BitRate(1, BitRateUnit.MegabytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Mo/s", new BitRate(1, BitRateUnit.MegaoctetPerSecond).ToString(swedishCulture)); + Assert.Equal("1 o/s", new BitRate(1, BitRateUnit.OctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Pibit/s", new BitRate(1, BitRateUnit.PebibitPerSecond).ToString(swedishCulture)); Assert.Equal("1 PiB/s", new BitRate(1, BitRateUnit.PebibytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Pio/s", new BitRate(1, BitRateUnit.PebioctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Pbit/s", new BitRate(1, BitRateUnit.PetabitPerSecond).ToString(swedishCulture)); Assert.Equal("1 PB/s", new BitRate(1, BitRateUnit.PetabytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Po/s", new BitRate(1, BitRateUnit.PetaoctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Tibit/s", new BitRate(1, BitRateUnit.TebibitPerSecond).ToString(swedishCulture)); Assert.Equal("1 TiB/s", new BitRate(1, BitRateUnit.TebibytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 Tio/s", new BitRate(1, BitRateUnit.TebioctetPerSecond).ToString(swedishCulture)); Assert.Equal("1 Tbit/s", new BitRate(1, BitRateUnit.TerabitPerSecond).ToString(swedishCulture)); Assert.Equal("1 TB/s", new BitRate(1, BitRateUnit.TerabytePerSecond).ToString(swedishCulture)); + Assert.Equal("1 To/s", new BitRate(1, BitRateUnit.TeraoctetPerSecond).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs index e8bdfe75ad..2d914ecc07 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/InformationTestsBase.g.cs @@ -43,56 +43,82 @@ public abstract partial class InformationTestsBase : QuantityTestsBase protected abstract double BytesInOneBit { get; } protected abstract double ExabitsInOneBit { get; } protected abstract double ExabytesInOneBit { get; } + protected abstract double ExaoctetsInOneBit { get; } protected abstract double ExbibitsInOneBit { get; } protected abstract double ExbibytesInOneBit { get; } + protected abstract double ExbioctetsInOneBit { get; } protected abstract double GibibitsInOneBit { get; } protected abstract double GibibytesInOneBit { get; } + protected abstract double GibioctetsInOneBit { get; } protected abstract double GigabitsInOneBit { get; } protected abstract double GigabytesInOneBit { get; } + protected abstract double GigaoctetsInOneBit { get; } protected abstract double KibibitsInOneBit { get; } protected abstract double KibibytesInOneBit { get; } + protected abstract double KibioctetsInOneBit { get; } protected abstract double KilobitsInOneBit { get; } protected abstract double KilobytesInOneBit { get; } + protected abstract double KilooctetsInOneBit { get; } protected abstract double MebibitsInOneBit { get; } protected abstract double MebibytesInOneBit { get; } + protected abstract double MebioctetsInOneBit { get; } protected abstract double MegabitsInOneBit { get; } protected abstract double MegabytesInOneBit { get; } + protected abstract double MegaoctetsInOneBit { get; } + protected abstract double OctetsInOneBit { get; } protected abstract double PebibitsInOneBit { get; } protected abstract double PebibytesInOneBit { get; } + protected abstract double PebioctetsInOneBit { get; } protected abstract double PetabitsInOneBit { get; } protected abstract double PetabytesInOneBit { get; } + protected abstract double PetaoctetsInOneBit { get; } protected abstract double TebibitsInOneBit { get; } protected abstract double TebibytesInOneBit { get; } + protected abstract double TebioctetsInOneBit { get; } protected abstract double TerabitsInOneBit { get; } protected abstract double TerabytesInOneBit { get; } + protected abstract double TeraoctetsInOneBit { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double BitsTolerance { get { return 1e-5; } } protected virtual double BytesTolerance { get { return 1e-5; } } protected virtual double ExabitsTolerance { get { return 1e-5; } } protected virtual double ExabytesTolerance { get { return 1e-5; } } + protected virtual double ExaoctetsTolerance { get { return 1e-5; } } protected virtual double ExbibitsTolerance { get { return 1e-5; } } protected virtual double ExbibytesTolerance { get { return 1e-5; } } + protected virtual double ExbioctetsTolerance { get { return 1e-5; } } protected virtual double GibibitsTolerance { get { return 1e-5; } } protected virtual double GibibytesTolerance { get { return 1e-5; } } + protected virtual double GibioctetsTolerance { get { return 1e-5; } } protected virtual double GigabitsTolerance { get { return 1e-5; } } protected virtual double GigabytesTolerance { get { return 1e-5; } } + protected virtual double GigaoctetsTolerance { get { return 1e-5; } } protected virtual double KibibitsTolerance { get { return 1e-5; } } protected virtual double KibibytesTolerance { get { return 1e-5; } } + protected virtual double KibioctetsTolerance { get { return 1e-5; } } protected virtual double KilobitsTolerance { get { return 1e-5; } } protected virtual double KilobytesTolerance { get { return 1e-5; } } + protected virtual double KilooctetsTolerance { get { return 1e-5; } } protected virtual double MebibitsTolerance { get { return 1e-5; } } protected virtual double MebibytesTolerance { get { return 1e-5; } } + protected virtual double MebioctetsTolerance { get { return 1e-5; } } protected virtual double MegabitsTolerance { get { return 1e-5; } } protected virtual double MegabytesTolerance { get { return 1e-5; } } + protected virtual double MegaoctetsTolerance { get { return 1e-5; } } + protected virtual double OctetsTolerance { get { return 1e-5; } } protected virtual double PebibitsTolerance { get { return 1e-5; } } protected virtual double PebibytesTolerance { get { return 1e-5; } } + protected virtual double PebioctetsTolerance { get { return 1e-5; } } protected virtual double PetabitsTolerance { get { return 1e-5; } } protected virtual double PetabytesTolerance { get { return 1e-5; } } + protected virtual double PetaoctetsTolerance { get { return 1e-5; } } protected virtual double TebibitsTolerance { get { return 1e-5; } } protected virtual double TebibytesTolerance { get { return 1e-5; } } + protected virtual double TebioctetsTolerance { get { return 1e-5; } } protected virtual double TerabitsTolerance { get { return 1e-5; } } protected virtual double TerabytesTolerance { get { return 1e-5; } } + protected virtual double TeraoctetsTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(InformationUnit unit) @@ -103,28 +129,41 @@ public abstract partial class InformationTestsBase : QuantityTestsBase InformationUnit.Byte => (BytesInOneBit, BytesTolerance), InformationUnit.Exabit => (ExabitsInOneBit, ExabitsTolerance), InformationUnit.Exabyte => (ExabytesInOneBit, ExabytesTolerance), + InformationUnit.Exaoctet => (ExaoctetsInOneBit, ExaoctetsTolerance), InformationUnit.Exbibit => (ExbibitsInOneBit, ExbibitsTolerance), InformationUnit.Exbibyte => (ExbibytesInOneBit, ExbibytesTolerance), + InformationUnit.Exbioctet => (ExbioctetsInOneBit, ExbioctetsTolerance), InformationUnit.Gibibit => (GibibitsInOneBit, GibibitsTolerance), InformationUnit.Gibibyte => (GibibytesInOneBit, GibibytesTolerance), + InformationUnit.Gibioctet => (GibioctetsInOneBit, GibioctetsTolerance), InformationUnit.Gigabit => (GigabitsInOneBit, GigabitsTolerance), InformationUnit.Gigabyte => (GigabytesInOneBit, GigabytesTolerance), + InformationUnit.Gigaoctet => (GigaoctetsInOneBit, GigaoctetsTolerance), InformationUnit.Kibibit => (KibibitsInOneBit, KibibitsTolerance), InformationUnit.Kibibyte => (KibibytesInOneBit, KibibytesTolerance), + InformationUnit.Kibioctet => (KibioctetsInOneBit, KibioctetsTolerance), InformationUnit.Kilobit => (KilobitsInOneBit, KilobitsTolerance), InformationUnit.Kilobyte => (KilobytesInOneBit, KilobytesTolerance), + InformationUnit.Kilooctet => (KilooctetsInOneBit, KilooctetsTolerance), InformationUnit.Mebibit => (MebibitsInOneBit, MebibitsTolerance), InformationUnit.Mebibyte => (MebibytesInOneBit, MebibytesTolerance), + InformationUnit.Mebioctet => (MebioctetsInOneBit, MebioctetsTolerance), InformationUnit.Megabit => (MegabitsInOneBit, MegabitsTolerance), InformationUnit.Megabyte => (MegabytesInOneBit, MegabytesTolerance), + InformationUnit.Megaoctet => (MegaoctetsInOneBit, MegaoctetsTolerance), + InformationUnit.Octet => (OctetsInOneBit, OctetsTolerance), InformationUnit.Pebibit => (PebibitsInOneBit, PebibitsTolerance), InformationUnit.Pebibyte => (PebibytesInOneBit, PebibytesTolerance), + InformationUnit.Pebioctet => (PebioctetsInOneBit, PebioctetsTolerance), InformationUnit.Petabit => (PetabitsInOneBit, PetabitsTolerance), InformationUnit.Petabyte => (PetabytesInOneBit, PetabytesTolerance), + InformationUnit.Petaoctet => (PetaoctetsInOneBit, PetaoctetsTolerance), InformationUnit.Tebibit => (TebibitsInOneBit, TebibitsTolerance), InformationUnit.Tebibyte => (TebibytesInOneBit, TebibytesTolerance), + InformationUnit.Tebioctet => (TebioctetsInOneBit, TebioctetsTolerance), InformationUnit.Terabit => (TerabitsInOneBit, TerabitsTolerance), InformationUnit.Terabyte => (TerabytesInOneBit, TerabytesTolerance), + InformationUnit.Teraoctet => (TeraoctetsInOneBit, TeraoctetsTolerance), _ => throw new NotSupportedException() }; } @@ -135,28 +174,41 @@ public abstract partial class InformationTestsBase : QuantityTestsBase new object[] { InformationUnit.Byte }, new object[] { InformationUnit.Exabit }, new object[] { InformationUnit.Exabyte }, + new object[] { InformationUnit.Exaoctet }, new object[] { InformationUnit.Exbibit }, new object[] { InformationUnit.Exbibyte }, + new object[] { InformationUnit.Exbioctet }, new object[] { InformationUnit.Gibibit }, new object[] { InformationUnit.Gibibyte }, + new object[] { InformationUnit.Gibioctet }, new object[] { InformationUnit.Gigabit }, new object[] { InformationUnit.Gigabyte }, + new object[] { InformationUnit.Gigaoctet }, new object[] { InformationUnit.Kibibit }, new object[] { InformationUnit.Kibibyte }, + new object[] { InformationUnit.Kibioctet }, new object[] { InformationUnit.Kilobit }, new object[] { InformationUnit.Kilobyte }, + new object[] { InformationUnit.Kilooctet }, new object[] { InformationUnit.Mebibit }, new object[] { InformationUnit.Mebibyte }, + new object[] { InformationUnit.Mebioctet }, new object[] { InformationUnit.Megabit }, new object[] { InformationUnit.Megabyte }, + new object[] { InformationUnit.Megaoctet }, + new object[] { InformationUnit.Octet }, new object[] { InformationUnit.Pebibit }, new object[] { InformationUnit.Pebibyte }, + new object[] { InformationUnit.Pebioctet }, new object[] { InformationUnit.Petabit }, new object[] { InformationUnit.Petabyte }, + new object[] { InformationUnit.Petaoctet }, new object[] { InformationUnit.Tebibit }, new object[] { InformationUnit.Tebibyte }, + new object[] { InformationUnit.Tebioctet }, new object[] { InformationUnit.Terabit }, new object[] { InformationUnit.Terabyte }, + new object[] { InformationUnit.Teraoctet }, }; [Fact] @@ -207,28 +259,41 @@ public void BitToInformationUnits() AssertEx.EqualTolerance(BytesInOneBit, bit.Bytes, BytesTolerance); AssertEx.EqualTolerance(ExabitsInOneBit, bit.Exabits, ExabitsTolerance); AssertEx.EqualTolerance(ExabytesInOneBit, bit.Exabytes, ExabytesTolerance); + AssertEx.EqualTolerance(ExaoctetsInOneBit, bit.Exaoctets, ExaoctetsTolerance); AssertEx.EqualTolerance(ExbibitsInOneBit, bit.Exbibits, ExbibitsTolerance); AssertEx.EqualTolerance(ExbibytesInOneBit, bit.Exbibytes, ExbibytesTolerance); + AssertEx.EqualTolerance(ExbioctetsInOneBit, bit.Exbioctets, ExbioctetsTolerance); AssertEx.EqualTolerance(GibibitsInOneBit, bit.Gibibits, GibibitsTolerance); AssertEx.EqualTolerance(GibibytesInOneBit, bit.Gibibytes, GibibytesTolerance); + AssertEx.EqualTolerance(GibioctetsInOneBit, bit.Gibioctets, GibioctetsTolerance); AssertEx.EqualTolerance(GigabitsInOneBit, bit.Gigabits, GigabitsTolerance); AssertEx.EqualTolerance(GigabytesInOneBit, bit.Gigabytes, GigabytesTolerance); + AssertEx.EqualTolerance(GigaoctetsInOneBit, bit.Gigaoctets, GigaoctetsTolerance); AssertEx.EqualTolerance(KibibitsInOneBit, bit.Kibibits, KibibitsTolerance); AssertEx.EqualTolerance(KibibytesInOneBit, bit.Kibibytes, KibibytesTolerance); + AssertEx.EqualTolerance(KibioctetsInOneBit, bit.Kibioctets, KibioctetsTolerance); AssertEx.EqualTolerance(KilobitsInOneBit, bit.Kilobits, KilobitsTolerance); AssertEx.EqualTolerance(KilobytesInOneBit, bit.Kilobytes, KilobytesTolerance); + AssertEx.EqualTolerance(KilooctetsInOneBit, bit.Kilooctets, KilooctetsTolerance); AssertEx.EqualTolerance(MebibitsInOneBit, bit.Mebibits, MebibitsTolerance); AssertEx.EqualTolerance(MebibytesInOneBit, bit.Mebibytes, MebibytesTolerance); + AssertEx.EqualTolerance(MebioctetsInOneBit, bit.Mebioctets, MebioctetsTolerance); AssertEx.EqualTolerance(MegabitsInOneBit, bit.Megabits, MegabitsTolerance); AssertEx.EqualTolerance(MegabytesInOneBit, bit.Megabytes, MegabytesTolerance); + AssertEx.EqualTolerance(MegaoctetsInOneBit, bit.Megaoctets, MegaoctetsTolerance); + AssertEx.EqualTolerance(OctetsInOneBit, bit.Octets, OctetsTolerance); AssertEx.EqualTolerance(PebibitsInOneBit, bit.Pebibits, PebibitsTolerance); AssertEx.EqualTolerance(PebibytesInOneBit, bit.Pebibytes, PebibytesTolerance); + AssertEx.EqualTolerance(PebioctetsInOneBit, bit.Pebioctets, PebioctetsTolerance); AssertEx.EqualTolerance(PetabitsInOneBit, bit.Petabits, PetabitsTolerance); AssertEx.EqualTolerance(PetabytesInOneBit, bit.Petabytes, PetabytesTolerance); + AssertEx.EqualTolerance(PetaoctetsInOneBit, bit.Petaoctets, PetaoctetsTolerance); AssertEx.EqualTolerance(TebibitsInOneBit, bit.Tebibits, TebibitsTolerance); AssertEx.EqualTolerance(TebibytesInOneBit, bit.Tebibytes, TebibytesTolerance); + AssertEx.EqualTolerance(TebioctetsInOneBit, bit.Tebioctets, TebioctetsTolerance); AssertEx.EqualTolerance(TerabitsInOneBit, bit.Terabits, TerabitsTolerance); AssertEx.EqualTolerance(TerabytesInOneBit, bit.Terabytes, TerabytesTolerance); + AssertEx.EqualTolerance(TeraoctetsInOneBit, bit.Teraoctets, TeraoctetsTolerance); } [Fact] @@ -250,93 +315,145 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity03.Exabytes, ExabytesTolerance); Assert.Equal(InformationUnit.Exabyte, quantity03.Unit); - var quantity04 = Information.From(1, InformationUnit.Exbibit); - AssertEx.EqualTolerance(1, quantity04.Exbibits, ExbibitsTolerance); - Assert.Equal(InformationUnit.Exbibit, quantity04.Unit); + var quantity04 = Information.From(1, InformationUnit.Exaoctet); + AssertEx.EqualTolerance(1, quantity04.Exaoctets, ExaoctetsTolerance); + Assert.Equal(InformationUnit.Exaoctet, quantity04.Unit); - var quantity05 = Information.From(1, InformationUnit.Exbibyte); - AssertEx.EqualTolerance(1, quantity05.Exbibytes, ExbibytesTolerance); - Assert.Equal(InformationUnit.Exbibyte, quantity05.Unit); + var quantity05 = Information.From(1, InformationUnit.Exbibit); + AssertEx.EqualTolerance(1, quantity05.Exbibits, ExbibitsTolerance); + Assert.Equal(InformationUnit.Exbibit, quantity05.Unit); - var quantity06 = Information.From(1, InformationUnit.Gibibit); - AssertEx.EqualTolerance(1, quantity06.Gibibits, GibibitsTolerance); - Assert.Equal(InformationUnit.Gibibit, quantity06.Unit); + var quantity06 = Information.From(1, InformationUnit.Exbibyte); + AssertEx.EqualTolerance(1, quantity06.Exbibytes, ExbibytesTolerance); + Assert.Equal(InformationUnit.Exbibyte, quantity06.Unit); - var quantity07 = Information.From(1, InformationUnit.Gibibyte); - AssertEx.EqualTolerance(1, quantity07.Gibibytes, GibibytesTolerance); - Assert.Equal(InformationUnit.Gibibyte, quantity07.Unit); + var quantity07 = Information.From(1, InformationUnit.Exbioctet); + AssertEx.EqualTolerance(1, quantity07.Exbioctets, ExbioctetsTolerance); + Assert.Equal(InformationUnit.Exbioctet, quantity07.Unit); - var quantity08 = Information.From(1, InformationUnit.Gigabit); - AssertEx.EqualTolerance(1, quantity08.Gigabits, GigabitsTolerance); - Assert.Equal(InformationUnit.Gigabit, quantity08.Unit); + var quantity08 = Information.From(1, InformationUnit.Gibibit); + AssertEx.EqualTolerance(1, quantity08.Gibibits, GibibitsTolerance); + Assert.Equal(InformationUnit.Gibibit, quantity08.Unit); - var quantity09 = Information.From(1, InformationUnit.Gigabyte); - AssertEx.EqualTolerance(1, quantity09.Gigabytes, GigabytesTolerance); - Assert.Equal(InformationUnit.Gigabyte, quantity09.Unit); + var quantity09 = Information.From(1, InformationUnit.Gibibyte); + AssertEx.EqualTolerance(1, quantity09.Gibibytes, GibibytesTolerance); + Assert.Equal(InformationUnit.Gibibyte, quantity09.Unit); - var quantity10 = Information.From(1, InformationUnit.Kibibit); - AssertEx.EqualTolerance(1, quantity10.Kibibits, KibibitsTolerance); - Assert.Equal(InformationUnit.Kibibit, quantity10.Unit); + var quantity10 = Information.From(1, InformationUnit.Gibioctet); + AssertEx.EqualTolerance(1, quantity10.Gibioctets, GibioctetsTolerance); + Assert.Equal(InformationUnit.Gibioctet, quantity10.Unit); - var quantity11 = Information.From(1, InformationUnit.Kibibyte); - AssertEx.EqualTolerance(1, quantity11.Kibibytes, KibibytesTolerance); - Assert.Equal(InformationUnit.Kibibyte, quantity11.Unit); + var quantity11 = Information.From(1, InformationUnit.Gigabit); + AssertEx.EqualTolerance(1, quantity11.Gigabits, GigabitsTolerance); + Assert.Equal(InformationUnit.Gigabit, quantity11.Unit); - var quantity12 = Information.From(1, InformationUnit.Kilobit); - AssertEx.EqualTolerance(1, quantity12.Kilobits, KilobitsTolerance); - Assert.Equal(InformationUnit.Kilobit, quantity12.Unit); + var quantity12 = Information.From(1, InformationUnit.Gigabyte); + AssertEx.EqualTolerance(1, quantity12.Gigabytes, GigabytesTolerance); + Assert.Equal(InformationUnit.Gigabyte, quantity12.Unit); - var quantity13 = Information.From(1, InformationUnit.Kilobyte); - AssertEx.EqualTolerance(1, quantity13.Kilobytes, KilobytesTolerance); - Assert.Equal(InformationUnit.Kilobyte, quantity13.Unit); + var quantity13 = Information.From(1, InformationUnit.Gigaoctet); + AssertEx.EqualTolerance(1, quantity13.Gigaoctets, GigaoctetsTolerance); + Assert.Equal(InformationUnit.Gigaoctet, quantity13.Unit); - var quantity14 = Information.From(1, InformationUnit.Mebibit); - AssertEx.EqualTolerance(1, quantity14.Mebibits, MebibitsTolerance); - Assert.Equal(InformationUnit.Mebibit, quantity14.Unit); + var quantity14 = Information.From(1, InformationUnit.Kibibit); + AssertEx.EqualTolerance(1, quantity14.Kibibits, KibibitsTolerance); + Assert.Equal(InformationUnit.Kibibit, quantity14.Unit); - var quantity15 = Information.From(1, InformationUnit.Mebibyte); - AssertEx.EqualTolerance(1, quantity15.Mebibytes, MebibytesTolerance); - Assert.Equal(InformationUnit.Mebibyte, quantity15.Unit); + var quantity15 = Information.From(1, InformationUnit.Kibibyte); + AssertEx.EqualTolerance(1, quantity15.Kibibytes, KibibytesTolerance); + Assert.Equal(InformationUnit.Kibibyte, quantity15.Unit); - var quantity16 = Information.From(1, InformationUnit.Megabit); - AssertEx.EqualTolerance(1, quantity16.Megabits, MegabitsTolerance); - Assert.Equal(InformationUnit.Megabit, quantity16.Unit); + var quantity16 = Information.From(1, InformationUnit.Kibioctet); + AssertEx.EqualTolerance(1, quantity16.Kibioctets, KibioctetsTolerance); + Assert.Equal(InformationUnit.Kibioctet, quantity16.Unit); - var quantity17 = Information.From(1, InformationUnit.Megabyte); - AssertEx.EqualTolerance(1, quantity17.Megabytes, MegabytesTolerance); - Assert.Equal(InformationUnit.Megabyte, quantity17.Unit); + var quantity17 = Information.From(1, InformationUnit.Kilobit); + AssertEx.EqualTolerance(1, quantity17.Kilobits, KilobitsTolerance); + Assert.Equal(InformationUnit.Kilobit, quantity17.Unit); - var quantity18 = Information.From(1, InformationUnit.Pebibit); - AssertEx.EqualTolerance(1, quantity18.Pebibits, PebibitsTolerance); - Assert.Equal(InformationUnit.Pebibit, quantity18.Unit); + var quantity18 = Information.From(1, InformationUnit.Kilobyte); + AssertEx.EqualTolerance(1, quantity18.Kilobytes, KilobytesTolerance); + Assert.Equal(InformationUnit.Kilobyte, quantity18.Unit); - var quantity19 = Information.From(1, InformationUnit.Pebibyte); - AssertEx.EqualTolerance(1, quantity19.Pebibytes, PebibytesTolerance); - Assert.Equal(InformationUnit.Pebibyte, quantity19.Unit); + var quantity19 = Information.From(1, InformationUnit.Kilooctet); + AssertEx.EqualTolerance(1, quantity19.Kilooctets, KilooctetsTolerance); + Assert.Equal(InformationUnit.Kilooctet, quantity19.Unit); - var quantity20 = Information.From(1, InformationUnit.Petabit); - AssertEx.EqualTolerance(1, quantity20.Petabits, PetabitsTolerance); - Assert.Equal(InformationUnit.Petabit, quantity20.Unit); + var quantity20 = Information.From(1, InformationUnit.Mebibit); + AssertEx.EqualTolerance(1, quantity20.Mebibits, MebibitsTolerance); + Assert.Equal(InformationUnit.Mebibit, quantity20.Unit); - var quantity21 = Information.From(1, InformationUnit.Petabyte); - AssertEx.EqualTolerance(1, quantity21.Petabytes, PetabytesTolerance); - Assert.Equal(InformationUnit.Petabyte, quantity21.Unit); + var quantity21 = Information.From(1, InformationUnit.Mebibyte); + AssertEx.EqualTolerance(1, quantity21.Mebibytes, MebibytesTolerance); + Assert.Equal(InformationUnit.Mebibyte, quantity21.Unit); - var quantity22 = Information.From(1, InformationUnit.Tebibit); - AssertEx.EqualTolerance(1, quantity22.Tebibits, TebibitsTolerance); - Assert.Equal(InformationUnit.Tebibit, quantity22.Unit); + var quantity22 = Information.From(1, InformationUnit.Mebioctet); + AssertEx.EqualTolerance(1, quantity22.Mebioctets, MebioctetsTolerance); + Assert.Equal(InformationUnit.Mebioctet, quantity22.Unit); - var quantity23 = Information.From(1, InformationUnit.Tebibyte); - AssertEx.EqualTolerance(1, quantity23.Tebibytes, TebibytesTolerance); - Assert.Equal(InformationUnit.Tebibyte, quantity23.Unit); + var quantity23 = Information.From(1, InformationUnit.Megabit); + AssertEx.EqualTolerance(1, quantity23.Megabits, MegabitsTolerance); + Assert.Equal(InformationUnit.Megabit, quantity23.Unit); - var quantity24 = Information.From(1, InformationUnit.Terabit); - AssertEx.EqualTolerance(1, quantity24.Terabits, TerabitsTolerance); - Assert.Equal(InformationUnit.Terabit, quantity24.Unit); + var quantity24 = Information.From(1, InformationUnit.Megabyte); + AssertEx.EqualTolerance(1, quantity24.Megabytes, MegabytesTolerance); + Assert.Equal(InformationUnit.Megabyte, quantity24.Unit); - var quantity25 = Information.From(1, InformationUnit.Terabyte); - AssertEx.EqualTolerance(1, quantity25.Terabytes, TerabytesTolerance); - Assert.Equal(InformationUnit.Terabyte, quantity25.Unit); + var quantity25 = Information.From(1, InformationUnit.Megaoctet); + AssertEx.EqualTolerance(1, quantity25.Megaoctets, MegaoctetsTolerance); + Assert.Equal(InformationUnit.Megaoctet, quantity25.Unit); + + var quantity26 = Information.From(1, InformationUnit.Octet); + AssertEx.EqualTolerance(1, quantity26.Octets, OctetsTolerance); + Assert.Equal(InformationUnit.Octet, quantity26.Unit); + + var quantity27 = Information.From(1, InformationUnit.Pebibit); + AssertEx.EqualTolerance(1, quantity27.Pebibits, PebibitsTolerance); + Assert.Equal(InformationUnit.Pebibit, quantity27.Unit); + + var quantity28 = Information.From(1, InformationUnit.Pebibyte); + AssertEx.EqualTolerance(1, quantity28.Pebibytes, PebibytesTolerance); + Assert.Equal(InformationUnit.Pebibyte, quantity28.Unit); + + var quantity29 = Information.From(1, InformationUnit.Pebioctet); + AssertEx.EqualTolerance(1, quantity29.Pebioctets, PebioctetsTolerance); + Assert.Equal(InformationUnit.Pebioctet, quantity29.Unit); + + var quantity30 = Information.From(1, InformationUnit.Petabit); + AssertEx.EqualTolerance(1, quantity30.Petabits, PetabitsTolerance); + Assert.Equal(InformationUnit.Petabit, quantity30.Unit); + + var quantity31 = Information.From(1, InformationUnit.Petabyte); + AssertEx.EqualTolerance(1, quantity31.Petabytes, PetabytesTolerance); + Assert.Equal(InformationUnit.Petabyte, quantity31.Unit); + + var quantity32 = Information.From(1, InformationUnit.Petaoctet); + AssertEx.EqualTolerance(1, quantity32.Petaoctets, PetaoctetsTolerance); + Assert.Equal(InformationUnit.Petaoctet, quantity32.Unit); + + var quantity33 = Information.From(1, InformationUnit.Tebibit); + AssertEx.EqualTolerance(1, quantity33.Tebibits, TebibitsTolerance); + Assert.Equal(InformationUnit.Tebibit, quantity33.Unit); + + var quantity34 = Information.From(1, InformationUnit.Tebibyte); + AssertEx.EqualTolerance(1, quantity34.Tebibytes, TebibytesTolerance); + Assert.Equal(InformationUnit.Tebibyte, quantity34.Unit); + + var quantity35 = Information.From(1, InformationUnit.Tebioctet); + AssertEx.EqualTolerance(1, quantity35.Tebioctets, TebioctetsTolerance); + Assert.Equal(InformationUnit.Tebioctet, quantity35.Unit); + + var quantity36 = Information.From(1, InformationUnit.Terabit); + AssertEx.EqualTolerance(1, quantity36.Terabits, TerabitsTolerance); + Assert.Equal(InformationUnit.Terabit, quantity36.Unit); + + var quantity37 = Information.From(1, InformationUnit.Terabyte); + AssertEx.EqualTolerance(1, quantity37.Terabytes, TerabytesTolerance); + Assert.Equal(InformationUnit.Terabyte, quantity37.Unit); + + var quantity38 = Information.From(1, InformationUnit.Teraoctet); + AssertEx.EqualTolerance(1, quantity38.Teraoctets, TeraoctetsTolerance); + Assert.Equal(InformationUnit.Teraoctet, quantity38.Unit); } @@ -366,28 +483,41 @@ public void As() AssertEx.EqualTolerance(BytesInOneBit, bit.As(InformationUnit.Byte), BytesTolerance); AssertEx.EqualTolerance(ExabitsInOneBit, bit.As(InformationUnit.Exabit), ExabitsTolerance); AssertEx.EqualTolerance(ExabytesInOneBit, bit.As(InformationUnit.Exabyte), ExabytesTolerance); + AssertEx.EqualTolerance(ExaoctetsInOneBit, bit.As(InformationUnit.Exaoctet), ExaoctetsTolerance); AssertEx.EqualTolerance(ExbibitsInOneBit, bit.As(InformationUnit.Exbibit), ExbibitsTolerance); AssertEx.EqualTolerance(ExbibytesInOneBit, bit.As(InformationUnit.Exbibyte), ExbibytesTolerance); + AssertEx.EqualTolerance(ExbioctetsInOneBit, bit.As(InformationUnit.Exbioctet), ExbioctetsTolerance); AssertEx.EqualTolerance(GibibitsInOneBit, bit.As(InformationUnit.Gibibit), GibibitsTolerance); AssertEx.EqualTolerance(GibibytesInOneBit, bit.As(InformationUnit.Gibibyte), GibibytesTolerance); + AssertEx.EqualTolerance(GibioctetsInOneBit, bit.As(InformationUnit.Gibioctet), GibioctetsTolerance); AssertEx.EqualTolerance(GigabitsInOneBit, bit.As(InformationUnit.Gigabit), GigabitsTolerance); AssertEx.EqualTolerance(GigabytesInOneBit, bit.As(InformationUnit.Gigabyte), GigabytesTolerance); + AssertEx.EqualTolerance(GigaoctetsInOneBit, bit.As(InformationUnit.Gigaoctet), GigaoctetsTolerance); AssertEx.EqualTolerance(KibibitsInOneBit, bit.As(InformationUnit.Kibibit), KibibitsTolerance); AssertEx.EqualTolerance(KibibytesInOneBit, bit.As(InformationUnit.Kibibyte), KibibytesTolerance); + AssertEx.EqualTolerance(KibioctetsInOneBit, bit.As(InformationUnit.Kibioctet), KibioctetsTolerance); AssertEx.EqualTolerance(KilobitsInOneBit, bit.As(InformationUnit.Kilobit), KilobitsTolerance); AssertEx.EqualTolerance(KilobytesInOneBit, bit.As(InformationUnit.Kilobyte), KilobytesTolerance); + AssertEx.EqualTolerance(KilooctetsInOneBit, bit.As(InformationUnit.Kilooctet), KilooctetsTolerance); AssertEx.EqualTolerance(MebibitsInOneBit, bit.As(InformationUnit.Mebibit), MebibitsTolerance); AssertEx.EqualTolerance(MebibytesInOneBit, bit.As(InformationUnit.Mebibyte), MebibytesTolerance); + AssertEx.EqualTolerance(MebioctetsInOneBit, bit.As(InformationUnit.Mebioctet), MebioctetsTolerance); AssertEx.EqualTolerance(MegabitsInOneBit, bit.As(InformationUnit.Megabit), MegabitsTolerance); AssertEx.EqualTolerance(MegabytesInOneBit, bit.As(InformationUnit.Megabyte), MegabytesTolerance); + AssertEx.EqualTolerance(MegaoctetsInOneBit, bit.As(InformationUnit.Megaoctet), MegaoctetsTolerance); + AssertEx.EqualTolerance(OctetsInOneBit, bit.As(InformationUnit.Octet), OctetsTolerance); AssertEx.EqualTolerance(PebibitsInOneBit, bit.As(InformationUnit.Pebibit), PebibitsTolerance); AssertEx.EqualTolerance(PebibytesInOneBit, bit.As(InformationUnit.Pebibyte), PebibytesTolerance); + AssertEx.EqualTolerance(PebioctetsInOneBit, bit.As(InformationUnit.Pebioctet), PebioctetsTolerance); AssertEx.EqualTolerance(PetabitsInOneBit, bit.As(InformationUnit.Petabit), PetabitsTolerance); AssertEx.EqualTolerance(PetabytesInOneBit, bit.As(InformationUnit.Petabyte), PetabytesTolerance); + AssertEx.EqualTolerance(PetaoctetsInOneBit, bit.As(InformationUnit.Petaoctet), PetaoctetsTolerance); AssertEx.EqualTolerance(TebibitsInOneBit, bit.As(InformationUnit.Tebibit), TebibitsTolerance); AssertEx.EqualTolerance(TebibytesInOneBit, bit.As(InformationUnit.Tebibyte), TebibytesTolerance); + AssertEx.EqualTolerance(TebioctetsInOneBit, bit.As(InformationUnit.Tebioctet), TebioctetsTolerance); AssertEx.EqualTolerance(TerabitsInOneBit, bit.As(InformationUnit.Terabit), TerabitsTolerance); AssertEx.EqualTolerance(TerabytesInOneBit, bit.As(InformationUnit.Terabyte), TerabytesTolerance); + AssertEx.EqualTolerance(TeraoctetsInOneBit, bit.As(InformationUnit.Teraoctet), TeraoctetsTolerance); } [Fact] @@ -488,6 +618,13 @@ public void Parse() Assert.Equal(InformationUnit.Exabyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Eo", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Exaoctets, ExaoctetsTolerance); + Assert.Equal(InformationUnit.Exaoctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Eib", CultureInfo.GetCultureInfo("en-US")); @@ -502,6 +639,13 @@ public void Parse() Assert.Equal(InformationUnit.Exbibyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Eio", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Exbioctets, ExbioctetsTolerance); + Assert.Equal(InformationUnit.Exbioctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Gib", CultureInfo.GetCultureInfo("en-US")); @@ -516,6 +660,13 @@ public void Parse() Assert.Equal(InformationUnit.Gibibyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Gio", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Gibioctets, GibioctetsTolerance); + Assert.Equal(InformationUnit.Gibioctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Gb", CultureInfo.GetCultureInfo("en-US")); @@ -530,6 +681,13 @@ public void Parse() Assert.Equal(InformationUnit.Gigabyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Go", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Gigaoctets, GigaoctetsTolerance); + Assert.Equal(InformationUnit.Gigaoctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Kib", CultureInfo.GetCultureInfo("en-US")); @@ -544,6 +702,13 @@ public void Parse() Assert.Equal(InformationUnit.Kibibyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Kio", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Kibioctets, KibioctetsTolerance); + Assert.Equal(InformationUnit.Kibioctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 kb", CultureInfo.GetCultureInfo("en-US")); @@ -558,6 +723,13 @@ public void Parse() Assert.Equal(InformationUnit.Kilobyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 ko", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Kilooctets, KilooctetsTolerance); + Assert.Equal(InformationUnit.Kilooctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Mib", CultureInfo.GetCultureInfo("en-US")); @@ -572,6 +744,13 @@ public void Parse() Assert.Equal(InformationUnit.Mebibyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Mio", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Mebioctets, MebioctetsTolerance); + Assert.Equal(InformationUnit.Mebioctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Mb", CultureInfo.GetCultureInfo("en-US")); @@ -586,6 +765,20 @@ public void Parse() Assert.Equal(InformationUnit.Megabyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Mo", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Megaoctets, MegaoctetsTolerance); + Assert.Equal(InformationUnit.Megaoctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = Information.Parse("1 o", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Octets, OctetsTolerance); + Assert.Equal(InformationUnit.Octet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Pib", CultureInfo.GetCultureInfo("en-US")); @@ -600,6 +793,13 @@ public void Parse() Assert.Equal(InformationUnit.Pebibyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Pio", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Pebioctets, PebioctetsTolerance); + Assert.Equal(InformationUnit.Pebioctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Pb", CultureInfo.GetCultureInfo("en-US")); @@ -614,6 +814,13 @@ public void Parse() Assert.Equal(InformationUnit.Petabyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Po", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Petaoctets, PetaoctetsTolerance); + Assert.Equal(InformationUnit.Petaoctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Tib", CultureInfo.GetCultureInfo("en-US")); @@ -628,6 +835,13 @@ public void Parse() Assert.Equal(InformationUnit.Tebibyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 Tio", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Tebioctets, TebioctetsTolerance); + Assert.Equal(InformationUnit.Tebioctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = Information.Parse("1 Tb", CultureInfo.GetCultureInfo("en-US")); @@ -642,11 +856,96 @@ public void Parse() Assert.Equal(InformationUnit.Terabyte, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = Information.Parse("1 To", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.Teraoctets, TeraoctetsTolerance); + Assert.Equal(InformationUnit.Teraoctet, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + } [Fact] public void TryParse() { + { + Assert.True(Information.TryParse("1 Eo", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Exaoctets, ExaoctetsTolerance); + Assert.Equal(InformationUnit.Exaoctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Eio", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Exbioctets, ExbioctetsTolerance); + Assert.Equal(InformationUnit.Exbioctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Gio", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Gibioctets, GibioctetsTolerance); + Assert.Equal(InformationUnit.Gibioctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Go", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Gigaoctets, GigaoctetsTolerance); + Assert.Equal(InformationUnit.Gigaoctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Kio", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Kibioctets, KibioctetsTolerance); + Assert.Equal(InformationUnit.Kibioctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 ko", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Kilooctets, KilooctetsTolerance); + Assert.Equal(InformationUnit.Kilooctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Mio", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Mebioctets, MebioctetsTolerance); + Assert.Equal(InformationUnit.Mebioctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Mo", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Megaoctets, MegaoctetsTolerance); + Assert.Equal(InformationUnit.Megaoctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 o", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Octets, OctetsTolerance); + Assert.Equal(InformationUnit.Octet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Pio", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Pebioctets, PebioctetsTolerance); + Assert.Equal(InformationUnit.Pebioctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Po", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Petaoctets, PetaoctetsTolerance); + Assert.Equal(InformationUnit.Petaoctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 Tio", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Tebioctets, TebioctetsTolerance); + Assert.Equal(InformationUnit.Tebioctet, parsed.Unit); + } + + { + Assert.True(Information.TryParse("1 To", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.Teraoctets, TeraoctetsTolerance); + Assert.Equal(InformationUnit.Teraoctet, parsed.Unit); + } + } [Theory] @@ -654,28 +953,41 @@ public void TryParse() [InlineData("B", InformationUnit.Byte)] [InlineData("Eb", InformationUnit.Exabit)] [InlineData("EB", InformationUnit.Exabyte)] + [InlineData("Eo", InformationUnit.Exaoctet)] [InlineData("Eib", InformationUnit.Exbibit)] [InlineData("EiB", InformationUnit.Exbibyte)] + [InlineData("Eio", InformationUnit.Exbioctet)] [InlineData("Gib", InformationUnit.Gibibit)] [InlineData("GiB", InformationUnit.Gibibyte)] + [InlineData("Gio", InformationUnit.Gibioctet)] [InlineData("Gb", InformationUnit.Gigabit)] [InlineData("GB", InformationUnit.Gigabyte)] + [InlineData("Go", InformationUnit.Gigaoctet)] [InlineData("Kib", InformationUnit.Kibibit)] [InlineData("KiB", InformationUnit.Kibibyte)] + [InlineData("Kio", InformationUnit.Kibioctet)] [InlineData("kb", InformationUnit.Kilobit)] [InlineData("kB", InformationUnit.Kilobyte)] + [InlineData("ko", InformationUnit.Kilooctet)] [InlineData("Mib", InformationUnit.Mebibit)] [InlineData("MiB", InformationUnit.Mebibyte)] + [InlineData("Mio", InformationUnit.Mebioctet)] [InlineData("Mb", InformationUnit.Megabit)] [InlineData("MB", InformationUnit.Megabyte)] + [InlineData("Mo", InformationUnit.Megaoctet)] + [InlineData("o", InformationUnit.Octet)] [InlineData("Pib", InformationUnit.Pebibit)] [InlineData("PiB", InformationUnit.Pebibyte)] + [InlineData("Pio", InformationUnit.Pebioctet)] [InlineData("Pb", InformationUnit.Petabit)] [InlineData("PB", InformationUnit.Petabyte)] + [InlineData("Po", InformationUnit.Petaoctet)] [InlineData("Tib", InformationUnit.Tebibit)] [InlineData("TiB", InformationUnit.Tebibyte)] + [InlineData("Tio", InformationUnit.Tebioctet)] [InlineData("Tb", InformationUnit.Terabit)] [InlineData("TB", InformationUnit.Terabyte)] + [InlineData("To", InformationUnit.Teraoctet)] public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, InformationUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -689,28 +1001,41 @@ public void ParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Informati [InlineData("B", InformationUnit.Byte)] [InlineData("Eb", InformationUnit.Exabit)] [InlineData("EB", InformationUnit.Exabyte)] + [InlineData("Eo", InformationUnit.Exaoctet)] [InlineData("Eib", InformationUnit.Exbibit)] [InlineData("EiB", InformationUnit.Exbibyte)] + [InlineData("Eio", InformationUnit.Exbioctet)] [InlineData("Gib", InformationUnit.Gibibit)] [InlineData("GiB", InformationUnit.Gibibyte)] + [InlineData("Gio", InformationUnit.Gibioctet)] [InlineData("Gb", InformationUnit.Gigabit)] [InlineData("GB", InformationUnit.Gigabyte)] + [InlineData("Go", InformationUnit.Gigaoctet)] [InlineData("Kib", InformationUnit.Kibibit)] [InlineData("KiB", InformationUnit.Kibibyte)] + [InlineData("Kio", InformationUnit.Kibioctet)] [InlineData("kb", InformationUnit.Kilobit)] [InlineData("kB", InformationUnit.Kilobyte)] + [InlineData("ko", InformationUnit.Kilooctet)] [InlineData("Mib", InformationUnit.Mebibit)] [InlineData("MiB", InformationUnit.Mebibyte)] + [InlineData("Mio", InformationUnit.Mebioctet)] [InlineData("Mb", InformationUnit.Megabit)] [InlineData("MB", InformationUnit.Megabyte)] + [InlineData("Mo", InformationUnit.Megaoctet)] + [InlineData("o", InformationUnit.Octet)] [InlineData("Pib", InformationUnit.Pebibit)] [InlineData("PiB", InformationUnit.Pebibyte)] + [InlineData("Pio", InformationUnit.Pebioctet)] [InlineData("Pb", InformationUnit.Petabit)] [InlineData("PB", InformationUnit.Petabyte)] + [InlineData("Po", InformationUnit.Petaoctet)] [InlineData("Tib", InformationUnit.Tebibit)] [InlineData("TiB", InformationUnit.Tebibyte)] + [InlineData("Tio", InformationUnit.Tebioctet)] [InlineData("Tb", InformationUnit.Terabit)] [InlineData("TB", InformationUnit.Terabyte)] + [InlineData("To", InformationUnit.Teraoctet)] public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, InformationUnit expectedUnit) { // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. @@ -724,28 +1049,41 @@ public void ParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string [InlineData("en-US", "B", InformationUnit.Byte)] [InlineData("en-US", "Eb", InformationUnit.Exabit)] [InlineData("en-US", "EB", InformationUnit.Exabyte)] + [InlineData("en-US", "Eo", InformationUnit.Exaoctet)] [InlineData("en-US", "Eib", InformationUnit.Exbibit)] [InlineData("en-US", "EiB", InformationUnit.Exbibyte)] + [InlineData("en-US", "Eio", InformationUnit.Exbioctet)] [InlineData("en-US", "Gib", InformationUnit.Gibibit)] [InlineData("en-US", "GiB", InformationUnit.Gibibyte)] + [InlineData("en-US", "Gio", InformationUnit.Gibioctet)] [InlineData("en-US", "Gb", InformationUnit.Gigabit)] [InlineData("en-US", "GB", InformationUnit.Gigabyte)] + [InlineData("en-US", "Go", InformationUnit.Gigaoctet)] [InlineData("en-US", "Kib", InformationUnit.Kibibit)] [InlineData("en-US", "KiB", InformationUnit.Kibibyte)] + [InlineData("en-US", "Kio", InformationUnit.Kibioctet)] [InlineData("en-US", "kb", InformationUnit.Kilobit)] [InlineData("en-US", "kB", InformationUnit.Kilobyte)] + [InlineData("en-US", "ko", InformationUnit.Kilooctet)] [InlineData("en-US", "Mib", InformationUnit.Mebibit)] [InlineData("en-US", "MiB", InformationUnit.Mebibyte)] + [InlineData("en-US", "Mio", InformationUnit.Mebioctet)] [InlineData("en-US", "Mb", InformationUnit.Megabit)] [InlineData("en-US", "MB", InformationUnit.Megabyte)] + [InlineData("en-US", "Mo", InformationUnit.Megaoctet)] + [InlineData("en-US", "o", InformationUnit.Octet)] [InlineData("en-US", "Pib", InformationUnit.Pebibit)] [InlineData("en-US", "PiB", InformationUnit.Pebibyte)] + [InlineData("en-US", "Pio", InformationUnit.Pebioctet)] [InlineData("en-US", "Pb", InformationUnit.Petabit)] [InlineData("en-US", "PB", InformationUnit.Petabyte)] + [InlineData("en-US", "Po", InformationUnit.Petaoctet)] [InlineData("en-US", "Tib", InformationUnit.Tebibit)] [InlineData("en-US", "TiB", InformationUnit.Tebibyte)] + [InlineData("en-US", "Tio", InformationUnit.Tebioctet)] [InlineData("en-US", "Tb", InformationUnit.Terabit)] [InlineData("en-US", "TB", InformationUnit.Terabyte)] + [InlineData("en-US", "To", InformationUnit.Teraoctet)] public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, InformationUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -758,28 +1096,41 @@ public void ParseUnit_WithCurrentCulture(string culture, string abbreviation, In [InlineData("en-US", "B", InformationUnit.Byte)] [InlineData("en-US", "Eb", InformationUnit.Exabit)] [InlineData("en-US", "EB", InformationUnit.Exabyte)] + [InlineData("en-US", "Eo", InformationUnit.Exaoctet)] [InlineData("en-US", "Eib", InformationUnit.Exbibit)] [InlineData("en-US", "EiB", InformationUnit.Exbibyte)] + [InlineData("en-US", "Eio", InformationUnit.Exbioctet)] [InlineData("en-US", "Gib", InformationUnit.Gibibit)] [InlineData("en-US", "GiB", InformationUnit.Gibibyte)] + [InlineData("en-US", "Gio", InformationUnit.Gibioctet)] [InlineData("en-US", "Gb", InformationUnit.Gigabit)] [InlineData("en-US", "GB", InformationUnit.Gigabyte)] + [InlineData("en-US", "Go", InformationUnit.Gigaoctet)] [InlineData("en-US", "Kib", InformationUnit.Kibibit)] [InlineData("en-US", "KiB", InformationUnit.Kibibyte)] + [InlineData("en-US", "Kio", InformationUnit.Kibioctet)] [InlineData("en-US", "kb", InformationUnit.Kilobit)] [InlineData("en-US", "kB", InformationUnit.Kilobyte)] + [InlineData("en-US", "ko", InformationUnit.Kilooctet)] [InlineData("en-US", "Mib", InformationUnit.Mebibit)] [InlineData("en-US", "MiB", InformationUnit.Mebibyte)] + [InlineData("en-US", "Mio", InformationUnit.Mebioctet)] [InlineData("en-US", "Mb", InformationUnit.Megabit)] [InlineData("en-US", "MB", InformationUnit.Megabyte)] + [InlineData("en-US", "Mo", InformationUnit.Megaoctet)] + [InlineData("en-US", "o", InformationUnit.Octet)] [InlineData("en-US", "Pib", InformationUnit.Pebibit)] [InlineData("en-US", "PiB", InformationUnit.Pebibyte)] + [InlineData("en-US", "Pio", InformationUnit.Pebioctet)] [InlineData("en-US", "Pb", InformationUnit.Petabit)] [InlineData("en-US", "PB", InformationUnit.Petabyte)] + [InlineData("en-US", "Po", InformationUnit.Petaoctet)] [InlineData("en-US", "Tib", InformationUnit.Tebibit)] [InlineData("en-US", "TiB", InformationUnit.Tebibyte)] + [InlineData("en-US", "Tio", InformationUnit.Tebioctet)] [InlineData("en-US", "Tb", InformationUnit.Terabit)] [InlineData("en-US", "TB", InformationUnit.Terabyte)] + [InlineData("en-US", "To", InformationUnit.Teraoctet)] public void ParseUnit_WithCulture(string culture, string abbreviation, InformationUnit expectedUnit) { InformationUnit parsedUnit = Information.ParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture)); @@ -791,28 +1142,41 @@ public void ParseUnit_WithCulture(string culture, string abbreviation, Informati [InlineData("B", InformationUnit.Byte)] [InlineData("Eb", InformationUnit.Exabit)] [InlineData("EB", InformationUnit.Exabyte)] + [InlineData("Eo", InformationUnit.Exaoctet)] [InlineData("Eib", InformationUnit.Exbibit)] [InlineData("EiB", InformationUnit.Exbibyte)] + [InlineData("Eio", InformationUnit.Exbioctet)] [InlineData("Gib", InformationUnit.Gibibit)] [InlineData("GiB", InformationUnit.Gibibyte)] + [InlineData("Gio", InformationUnit.Gibioctet)] [InlineData("Gb", InformationUnit.Gigabit)] [InlineData("GB", InformationUnit.Gigabyte)] + [InlineData("Go", InformationUnit.Gigaoctet)] [InlineData("Kib", InformationUnit.Kibibit)] [InlineData("KiB", InformationUnit.Kibibyte)] + [InlineData("Kio", InformationUnit.Kibioctet)] [InlineData("kb", InformationUnit.Kilobit)] [InlineData("kB", InformationUnit.Kilobyte)] + [InlineData("ko", InformationUnit.Kilooctet)] [InlineData("Mib", InformationUnit.Mebibit)] [InlineData("MiB", InformationUnit.Mebibyte)] + [InlineData("Mio", InformationUnit.Mebioctet)] [InlineData("Mb", InformationUnit.Megabit)] [InlineData("MB", InformationUnit.Megabyte)] + [InlineData("Mo", InformationUnit.Megaoctet)] + [InlineData("o", InformationUnit.Octet)] [InlineData("Pib", InformationUnit.Pebibit)] [InlineData("PiB", InformationUnit.Pebibyte)] + [InlineData("Pio", InformationUnit.Pebioctet)] [InlineData("Pb", InformationUnit.Petabit)] [InlineData("PB", InformationUnit.Petabyte)] + [InlineData("Po", InformationUnit.Petaoctet)] [InlineData("Tib", InformationUnit.Tebibit)] [InlineData("TiB", InformationUnit.Tebibyte)] + [InlineData("Tio", InformationUnit.Tebioctet)] [InlineData("Tb", InformationUnit.Terabit)] [InlineData("TB", InformationUnit.Terabyte)] + [InlineData("To", InformationUnit.Teraoctet)] public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, InformationUnit expectedUnit) { // Fallback culture "en-US" is always localized @@ -826,28 +1190,41 @@ public void TryParseUnit_WithUsEnglishCurrentCulture(string abbreviation, Inform [InlineData("B", InformationUnit.Byte)] [InlineData("Eb", InformationUnit.Exabit)] [InlineData("EB", InformationUnit.Exabyte)] + [InlineData("Eo", InformationUnit.Exaoctet)] [InlineData("Eib", InformationUnit.Exbibit)] [InlineData("EiB", InformationUnit.Exbibyte)] + [InlineData("Eio", InformationUnit.Exbioctet)] [InlineData("Gib", InformationUnit.Gibibit)] [InlineData("GiB", InformationUnit.Gibibyte)] + [InlineData("Gio", InformationUnit.Gibioctet)] [InlineData("Gb", InformationUnit.Gigabit)] [InlineData("GB", InformationUnit.Gigabyte)] + [InlineData("Go", InformationUnit.Gigaoctet)] [InlineData("Kib", InformationUnit.Kibibit)] [InlineData("KiB", InformationUnit.Kibibyte)] + [InlineData("Kio", InformationUnit.Kibioctet)] [InlineData("kb", InformationUnit.Kilobit)] [InlineData("kB", InformationUnit.Kilobyte)] + [InlineData("ko", InformationUnit.Kilooctet)] [InlineData("Mib", InformationUnit.Mebibit)] [InlineData("MiB", InformationUnit.Mebibyte)] + [InlineData("Mio", InformationUnit.Mebioctet)] [InlineData("Mb", InformationUnit.Megabit)] [InlineData("MB", InformationUnit.Megabyte)] + [InlineData("Mo", InformationUnit.Megaoctet)] + [InlineData("o", InformationUnit.Octet)] [InlineData("Pib", InformationUnit.Pebibit)] [InlineData("PiB", InformationUnit.Pebibyte)] + [InlineData("Pio", InformationUnit.Pebioctet)] [InlineData("Pb", InformationUnit.Petabit)] [InlineData("PB", InformationUnit.Petabyte)] + [InlineData("Po", InformationUnit.Petaoctet)] [InlineData("Tib", InformationUnit.Tebibit)] [InlineData("TiB", InformationUnit.Tebibyte)] + [InlineData("Tio", InformationUnit.Tebioctet)] [InlineData("Tb", InformationUnit.Terabit)] [InlineData("TB", InformationUnit.Terabyte)] + [InlineData("To", InformationUnit.Teraoctet)] public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(string abbreviation, InformationUnit expectedUnit) { // Currently, no abbreviations are localized for Icelandic, so it should fall back to "en-US" when parsing. @@ -861,28 +1238,41 @@ public void TryParseUnit_WithUnsupportedCurrentCulture_FallsBackToUsEnglish(stri [InlineData("en-US", "B", InformationUnit.Byte)] [InlineData("en-US", "Eb", InformationUnit.Exabit)] [InlineData("en-US", "EB", InformationUnit.Exabyte)] + [InlineData("en-US", "Eo", InformationUnit.Exaoctet)] [InlineData("en-US", "Eib", InformationUnit.Exbibit)] [InlineData("en-US", "EiB", InformationUnit.Exbibyte)] + [InlineData("en-US", "Eio", InformationUnit.Exbioctet)] [InlineData("en-US", "Gib", InformationUnit.Gibibit)] [InlineData("en-US", "GiB", InformationUnit.Gibibyte)] + [InlineData("en-US", "Gio", InformationUnit.Gibioctet)] [InlineData("en-US", "Gb", InformationUnit.Gigabit)] [InlineData("en-US", "GB", InformationUnit.Gigabyte)] + [InlineData("en-US", "Go", InformationUnit.Gigaoctet)] [InlineData("en-US", "Kib", InformationUnit.Kibibit)] [InlineData("en-US", "KiB", InformationUnit.Kibibyte)] + [InlineData("en-US", "Kio", InformationUnit.Kibioctet)] [InlineData("en-US", "kb", InformationUnit.Kilobit)] [InlineData("en-US", "kB", InformationUnit.Kilobyte)] + [InlineData("en-US", "ko", InformationUnit.Kilooctet)] [InlineData("en-US", "Mib", InformationUnit.Mebibit)] [InlineData("en-US", "MiB", InformationUnit.Mebibyte)] + [InlineData("en-US", "Mio", InformationUnit.Mebioctet)] [InlineData("en-US", "Mb", InformationUnit.Megabit)] [InlineData("en-US", "MB", InformationUnit.Megabyte)] + [InlineData("en-US", "Mo", InformationUnit.Megaoctet)] + [InlineData("en-US", "o", InformationUnit.Octet)] [InlineData("en-US", "Pib", InformationUnit.Pebibit)] [InlineData("en-US", "PiB", InformationUnit.Pebibyte)] + [InlineData("en-US", "Pio", InformationUnit.Pebioctet)] [InlineData("en-US", "Pb", InformationUnit.Petabit)] [InlineData("en-US", "PB", InformationUnit.Petabyte)] + [InlineData("en-US", "Po", InformationUnit.Petaoctet)] [InlineData("en-US", "Tib", InformationUnit.Tebibit)] [InlineData("en-US", "TiB", InformationUnit.Tebibyte)] + [InlineData("en-US", "Tio", InformationUnit.Tebioctet)] [InlineData("en-US", "Tb", InformationUnit.Terabit)] [InlineData("en-US", "TB", InformationUnit.Terabyte)] + [InlineData("en-US", "To", InformationUnit.Teraoctet)] public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, InformationUnit expectedUnit) { using var _ = new CultureScope(culture); @@ -895,28 +1285,41 @@ public void TryParseUnit_WithCurrentCulture(string culture, string abbreviation, [InlineData("en-US", "B", InformationUnit.Byte)] [InlineData("en-US", "Eb", InformationUnit.Exabit)] [InlineData("en-US", "EB", InformationUnit.Exabyte)] + [InlineData("en-US", "Eo", InformationUnit.Exaoctet)] [InlineData("en-US", "Eib", InformationUnit.Exbibit)] [InlineData("en-US", "EiB", InformationUnit.Exbibyte)] + [InlineData("en-US", "Eio", InformationUnit.Exbioctet)] [InlineData("en-US", "Gib", InformationUnit.Gibibit)] [InlineData("en-US", "GiB", InformationUnit.Gibibyte)] + [InlineData("en-US", "Gio", InformationUnit.Gibioctet)] [InlineData("en-US", "Gb", InformationUnit.Gigabit)] [InlineData("en-US", "GB", InformationUnit.Gigabyte)] + [InlineData("en-US", "Go", InformationUnit.Gigaoctet)] [InlineData("en-US", "Kib", InformationUnit.Kibibit)] [InlineData("en-US", "KiB", InformationUnit.Kibibyte)] + [InlineData("en-US", "Kio", InformationUnit.Kibioctet)] [InlineData("en-US", "kb", InformationUnit.Kilobit)] [InlineData("en-US", "kB", InformationUnit.Kilobyte)] + [InlineData("en-US", "ko", InformationUnit.Kilooctet)] [InlineData("en-US", "Mib", InformationUnit.Mebibit)] [InlineData("en-US", "MiB", InformationUnit.Mebibyte)] + [InlineData("en-US", "Mio", InformationUnit.Mebioctet)] [InlineData("en-US", "Mb", InformationUnit.Megabit)] [InlineData("en-US", "MB", InformationUnit.Megabyte)] + [InlineData("en-US", "Mo", InformationUnit.Megaoctet)] + [InlineData("en-US", "o", InformationUnit.Octet)] [InlineData("en-US", "Pib", InformationUnit.Pebibit)] [InlineData("en-US", "PiB", InformationUnit.Pebibyte)] + [InlineData("en-US", "Pio", InformationUnit.Pebioctet)] [InlineData("en-US", "Pb", InformationUnit.Petabit)] [InlineData("en-US", "PB", InformationUnit.Petabyte)] + [InlineData("en-US", "Po", InformationUnit.Petaoctet)] [InlineData("en-US", "Tib", InformationUnit.Tebibit)] [InlineData("en-US", "TiB", InformationUnit.Tebibyte)] + [InlineData("en-US", "Tio", InformationUnit.Tebioctet)] [InlineData("en-US", "Tb", InformationUnit.Terabit)] [InlineData("en-US", "TB", InformationUnit.Terabyte)] + [InlineData("en-US", "To", InformationUnit.Teraoctet)] public void TryParseUnit_WithCulture(string culture, string abbreviation, InformationUnit expectedUnit) { Assert.True(Information.TryParseUnit(abbreviation, CultureInfo.GetCultureInfo(culture), out InformationUnit parsedUnit)); @@ -992,28 +1395,41 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Information.FromBytes(bit.Bytes).Bits, BytesTolerance); AssertEx.EqualTolerance(1, Information.FromExabits(bit.Exabits).Bits, ExabitsTolerance); AssertEx.EqualTolerance(1, Information.FromExabytes(bit.Exabytes).Bits, ExabytesTolerance); + AssertEx.EqualTolerance(1, Information.FromExaoctets(bit.Exaoctets).Bits, ExaoctetsTolerance); AssertEx.EqualTolerance(1, Information.FromExbibits(bit.Exbibits).Bits, ExbibitsTolerance); AssertEx.EqualTolerance(1, Information.FromExbibytes(bit.Exbibytes).Bits, ExbibytesTolerance); + AssertEx.EqualTolerance(1, Information.FromExbioctets(bit.Exbioctets).Bits, ExbioctetsTolerance); AssertEx.EqualTolerance(1, Information.FromGibibits(bit.Gibibits).Bits, GibibitsTolerance); AssertEx.EqualTolerance(1, Information.FromGibibytes(bit.Gibibytes).Bits, GibibytesTolerance); + AssertEx.EqualTolerance(1, Information.FromGibioctets(bit.Gibioctets).Bits, GibioctetsTolerance); AssertEx.EqualTolerance(1, Information.FromGigabits(bit.Gigabits).Bits, GigabitsTolerance); AssertEx.EqualTolerance(1, Information.FromGigabytes(bit.Gigabytes).Bits, GigabytesTolerance); + AssertEx.EqualTolerance(1, Information.FromGigaoctets(bit.Gigaoctets).Bits, GigaoctetsTolerance); AssertEx.EqualTolerance(1, Information.FromKibibits(bit.Kibibits).Bits, KibibitsTolerance); AssertEx.EqualTolerance(1, Information.FromKibibytes(bit.Kibibytes).Bits, KibibytesTolerance); + AssertEx.EqualTolerance(1, Information.FromKibioctets(bit.Kibioctets).Bits, KibioctetsTolerance); AssertEx.EqualTolerance(1, Information.FromKilobits(bit.Kilobits).Bits, KilobitsTolerance); AssertEx.EqualTolerance(1, Information.FromKilobytes(bit.Kilobytes).Bits, KilobytesTolerance); + AssertEx.EqualTolerance(1, Information.FromKilooctets(bit.Kilooctets).Bits, KilooctetsTolerance); AssertEx.EqualTolerance(1, Information.FromMebibits(bit.Mebibits).Bits, MebibitsTolerance); AssertEx.EqualTolerance(1, Information.FromMebibytes(bit.Mebibytes).Bits, MebibytesTolerance); + AssertEx.EqualTolerance(1, Information.FromMebioctets(bit.Mebioctets).Bits, MebioctetsTolerance); AssertEx.EqualTolerance(1, Information.FromMegabits(bit.Megabits).Bits, MegabitsTolerance); AssertEx.EqualTolerance(1, Information.FromMegabytes(bit.Megabytes).Bits, MegabytesTolerance); + AssertEx.EqualTolerance(1, Information.FromMegaoctets(bit.Megaoctets).Bits, MegaoctetsTolerance); + AssertEx.EqualTolerance(1, Information.FromOctets(bit.Octets).Bits, OctetsTolerance); AssertEx.EqualTolerance(1, Information.FromPebibits(bit.Pebibits).Bits, PebibitsTolerance); AssertEx.EqualTolerance(1, Information.FromPebibytes(bit.Pebibytes).Bits, PebibytesTolerance); + AssertEx.EqualTolerance(1, Information.FromPebioctets(bit.Pebioctets).Bits, PebioctetsTolerance); AssertEx.EqualTolerance(1, Information.FromPetabits(bit.Petabits).Bits, PetabitsTolerance); AssertEx.EqualTolerance(1, Information.FromPetabytes(bit.Petabytes).Bits, PetabytesTolerance); + AssertEx.EqualTolerance(1, Information.FromPetaoctets(bit.Petaoctets).Bits, PetaoctetsTolerance); AssertEx.EqualTolerance(1, Information.FromTebibits(bit.Tebibits).Bits, TebibitsTolerance); AssertEx.EqualTolerance(1, Information.FromTebibytes(bit.Tebibytes).Bits, TebibytesTolerance); + AssertEx.EqualTolerance(1, Information.FromTebioctets(bit.Tebioctets).Bits, TebioctetsTolerance); AssertEx.EqualTolerance(1, Information.FromTerabits(bit.Terabits).Bits, TerabitsTolerance); AssertEx.EqualTolerance(1, Information.FromTerabytes(bit.Terabytes).Bits, TerabytesTolerance); + AssertEx.EqualTolerance(1, Information.FromTeraoctets(bit.Teraoctets).Bits, TeraoctetsTolerance); } [Fact] @@ -1165,28 +1581,41 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 B", new Information(1, InformationUnit.Byte).ToString()); Assert.Equal("1 Eb", new Information(1, InformationUnit.Exabit).ToString()); Assert.Equal("1 EB", new Information(1, InformationUnit.Exabyte).ToString()); + Assert.Equal("1 Eo", new Information(1, InformationUnit.Exaoctet).ToString()); Assert.Equal("1 Eib", new Information(1, InformationUnit.Exbibit).ToString()); Assert.Equal("1 EiB", new Information(1, InformationUnit.Exbibyte).ToString()); + Assert.Equal("1 Eio", new Information(1, InformationUnit.Exbioctet).ToString()); Assert.Equal("1 Gib", new Information(1, InformationUnit.Gibibit).ToString()); Assert.Equal("1 GiB", new Information(1, InformationUnit.Gibibyte).ToString()); + Assert.Equal("1 Gio", new Information(1, InformationUnit.Gibioctet).ToString()); Assert.Equal("1 Gb", new Information(1, InformationUnit.Gigabit).ToString()); Assert.Equal("1 GB", new Information(1, InformationUnit.Gigabyte).ToString()); + Assert.Equal("1 Go", new Information(1, InformationUnit.Gigaoctet).ToString()); Assert.Equal("1 Kib", new Information(1, InformationUnit.Kibibit).ToString()); Assert.Equal("1 KiB", new Information(1, InformationUnit.Kibibyte).ToString()); + Assert.Equal("1 Kio", new Information(1, InformationUnit.Kibioctet).ToString()); Assert.Equal("1 kb", new Information(1, InformationUnit.Kilobit).ToString()); Assert.Equal("1 kB", new Information(1, InformationUnit.Kilobyte).ToString()); + Assert.Equal("1 ko", new Information(1, InformationUnit.Kilooctet).ToString()); Assert.Equal("1 Mib", new Information(1, InformationUnit.Mebibit).ToString()); Assert.Equal("1 MiB", new Information(1, InformationUnit.Mebibyte).ToString()); + Assert.Equal("1 Mio", new Information(1, InformationUnit.Mebioctet).ToString()); Assert.Equal("1 Mb", new Information(1, InformationUnit.Megabit).ToString()); Assert.Equal("1 MB", new Information(1, InformationUnit.Megabyte).ToString()); + Assert.Equal("1 Mo", new Information(1, InformationUnit.Megaoctet).ToString()); + Assert.Equal("1 o", new Information(1, InformationUnit.Octet).ToString()); Assert.Equal("1 Pib", new Information(1, InformationUnit.Pebibit).ToString()); Assert.Equal("1 PiB", new Information(1, InformationUnit.Pebibyte).ToString()); + Assert.Equal("1 Pio", new Information(1, InformationUnit.Pebioctet).ToString()); Assert.Equal("1 Pb", new Information(1, InformationUnit.Petabit).ToString()); Assert.Equal("1 PB", new Information(1, InformationUnit.Petabyte).ToString()); + Assert.Equal("1 Po", new Information(1, InformationUnit.Petaoctet).ToString()); Assert.Equal("1 Tib", new Information(1, InformationUnit.Tebibit).ToString()); Assert.Equal("1 TiB", new Information(1, InformationUnit.Tebibyte).ToString()); + Assert.Equal("1 Tio", new Information(1, InformationUnit.Tebioctet).ToString()); Assert.Equal("1 Tb", new Information(1, InformationUnit.Terabit).ToString()); Assert.Equal("1 TB", new Information(1, InformationUnit.Terabyte).ToString()); + Assert.Equal("1 To", new Information(1, InformationUnit.Teraoctet).ToString()); } [Fact] @@ -1199,28 +1628,41 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 B", new Information(1, InformationUnit.Byte).ToString(swedishCulture)); Assert.Equal("1 Eb", new Information(1, InformationUnit.Exabit).ToString(swedishCulture)); Assert.Equal("1 EB", new Information(1, InformationUnit.Exabyte).ToString(swedishCulture)); + Assert.Equal("1 Eo", new Information(1, InformationUnit.Exaoctet).ToString(swedishCulture)); Assert.Equal("1 Eib", new Information(1, InformationUnit.Exbibit).ToString(swedishCulture)); Assert.Equal("1 EiB", new Information(1, InformationUnit.Exbibyte).ToString(swedishCulture)); + Assert.Equal("1 Eio", new Information(1, InformationUnit.Exbioctet).ToString(swedishCulture)); Assert.Equal("1 Gib", new Information(1, InformationUnit.Gibibit).ToString(swedishCulture)); Assert.Equal("1 GiB", new Information(1, InformationUnit.Gibibyte).ToString(swedishCulture)); + Assert.Equal("1 Gio", new Information(1, InformationUnit.Gibioctet).ToString(swedishCulture)); Assert.Equal("1 Gb", new Information(1, InformationUnit.Gigabit).ToString(swedishCulture)); Assert.Equal("1 GB", new Information(1, InformationUnit.Gigabyte).ToString(swedishCulture)); + Assert.Equal("1 Go", new Information(1, InformationUnit.Gigaoctet).ToString(swedishCulture)); Assert.Equal("1 Kib", new Information(1, InformationUnit.Kibibit).ToString(swedishCulture)); Assert.Equal("1 KiB", new Information(1, InformationUnit.Kibibyte).ToString(swedishCulture)); + Assert.Equal("1 Kio", new Information(1, InformationUnit.Kibioctet).ToString(swedishCulture)); Assert.Equal("1 kb", new Information(1, InformationUnit.Kilobit).ToString(swedishCulture)); Assert.Equal("1 kB", new Information(1, InformationUnit.Kilobyte).ToString(swedishCulture)); + Assert.Equal("1 ko", new Information(1, InformationUnit.Kilooctet).ToString(swedishCulture)); Assert.Equal("1 Mib", new Information(1, InformationUnit.Mebibit).ToString(swedishCulture)); Assert.Equal("1 MiB", new Information(1, InformationUnit.Mebibyte).ToString(swedishCulture)); + Assert.Equal("1 Mio", new Information(1, InformationUnit.Mebioctet).ToString(swedishCulture)); Assert.Equal("1 Mb", new Information(1, InformationUnit.Megabit).ToString(swedishCulture)); Assert.Equal("1 MB", new Information(1, InformationUnit.Megabyte).ToString(swedishCulture)); + Assert.Equal("1 Mo", new Information(1, InformationUnit.Megaoctet).ToString(swedishCulture)); + Assert.Equal("1 o", new Information(1, InformationUnit.Octet).ToString(swedishCulture)); Assert.Equal("1 Pib", new Information(1, InformationUnit.Pebibit).ToString(swedishCulture)); Assert.Equal("1 PiB", new Information(1, InformationUnit.Pebibyte).ToString(swedishCulture)); + Assert.Equal("1 Pio", new Information(1, InformationUnit.Pebioctet).ToString(swedishCulture)); Assert.Equal("1 Pb", new Information(1, InformationUnit.Petabit).ToString(swedishCulture)); Assert.Equal("1 PB", new Information(1, InformationUnit.Petabyte).ToString(swedishCulture)); + Assert.Equal("1 Po", new Information(1, InformationUnit.Petaoctet).ToString(swedishCulture)); Assert.Equal("1 Tib", new Information(1, InformationUnit.Tebibit).ToString(swedishCulture)); Assert.Equal("1 TiB", new Information(1, InformationUnit.Tebibyte).ToString(swedishCulture)); + Assert.Equal("1 Tio", new Information(1, InformationUnit.Tebioctet).ToString(swedishCulture)); Assert.Equal("1 Tb", new Information(1, InformationUnit.Terabit).ToString(swedishCulture)); Assert.Equal("1 TB", new Information(1, InformationUnit.Terabyte).ToString(swedishCulture)); + Assert.Equal("1 To", new Information(1, InformationUnit.Teraoctet).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs index f073a23c80..1fe6c8aa86 100644 --- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs @@ -80,28 +80,41 @@ static BitRate() new UnitInfo(BitRateUnit.BytePerSecond, "BytesPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.ExabitPerSecond, "ExabitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.ExabytePerSecond, "ExabytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.ExaoctetPerSecond, "ExaoctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.ExbibitPerSecond, "ExbibitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.ExbibytePerSecond, "ExbibytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.ExbioctetPerSecond, "ExbioctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.GibibitPerSecond, "GibibitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.GibibytePerSecond, "GibibytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.GibioctetPerSecond, "GibioctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.GigabitPerSecond, "GigabitsPerSecond", new BaseUnits(time: DurationUnit.Nanosecond), "BitRate"), new UnitInfo(BitRateUnit.GigabytePerSecond, "GigabytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.GigaoctetPerSecond, "GigaoctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.KibibitPerSecond, "KibibitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.KibibytePerSecond, "KibibytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.KibioctetPerSecond, "KibioctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.KilobitPerSecond, "KilobitsPerSecond", new BaseUnits(time: DurationUnit.Millisecond), "BitRate"), new UnitInfo(BitRateUnit.KilobytePerSecond, "KilobytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.KilooctetPerSecond, "KilooctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.MebibitPerSecond, "MebibitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.MebibytePerSecond, "MebibytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.MebioctetPerSecond, "MebioctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.MegabitPerSecond, "MegabitsPerSecond", new BaseUnits(time: DurationUnit.Microsecond), "BitRate"), new UnitInfo(BitRateUnit.MegabytePerSecond, "MegabytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.MegaoctetPerSecond, "MegaoctetsPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.OctetPerSecond, "OctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.PebibitPerSecond, "PebibitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.PebibytePerSecond, "PebibytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.PebioctetPerSecond, "PebioctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.PetabitPerSecond, "PetabitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.PetabytePerSecond, "PetabytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.PetaoctetPerSecond, "PetaoctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.TebibitPerSecond, "TebibitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.TebibytePerSecond, "TebibytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.TebioctetPerSecond, "TebioctetsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.TerabitPerSecond, "TerabitsPerSecond", BaseUnits.Undefined, "BitRate"), new UnitInfo(BitRateUnit.TerabytePerSecond, "TerabytesPerSecond", BaseUnits.Undefined, "BitRate"), + new UnitInfo(BitRateUnit.TeraoctetPerSecond, "TeraoctetsPerSecond", BaseUnits.Undefined, "BitRate"), }, BaseUnit, Zero, BaseDimensions); @@ -219,6 +232,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double ExabytesPerSecond => As(BitRateUnit.ExabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double ExaoctetsPerSecond => As(BitRateUnit.ExaoctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -229,6 +247,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double ExbibytesPerSecond => As(BitRateUnit.ExbibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double ExbioctetsPerSecond => As(BitRateUnit.ExbioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -239,6 +262,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double GibibytesPerSecond => As(BitRateUnit.GibibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double GibioctetsPerSecond => As(BitRateUnit.GibioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -249,6 +277,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double GigabytesPerSecond => As(BitRateUnit.GigabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double GigaoctetsPerSecond => As(BitRateUnit.GigaoctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -259,6 +292,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double KibibytesPerSecond => As(BitRateUnit.KibibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double KibioctetsPerSecond => As(BitRateUnit.KibioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -269,6 +307,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double KilobytesPerSecond => As(BitRateUnit.KilobytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double KilooctetsPerSecond => As(BitRateUnit.KilooctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -279,6 +322,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double MebibytesPerSecond => As(BitRateUnit.MebibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MebioctetsPerSecond => As(BitRateUnit.MebioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -289,6 +337,16 @@ public BitRate(double value, UnitSystem unitSystem) /// public double MegabytesPerSecond => As(BitRateUnit.MegabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MegaoctetsPerSecond => As(BitRateUnit.MegaoctetPerSecond); + + /// + /// Gets a value of this quantity converted into + /// + public double OctetsPerSecond => As(BitRateUnit.OctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -299,6 +357,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double PebibytesPerSecond => As(BitRateUnit.PebibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double PebioctetsPerSecond => As(BitRateUnit.PebioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -309,6 +372,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double PetabytesPerSecond => As(BitRateUnit.PetabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double PetaoctetsPerSecond => As(BitRateUnit.PetaoctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -319,6 +387,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double TebibytesPerSecond => As(BitRateUnit.TebibytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double TebioctetsPerSecond => As(BitRateUnit.TebioctetPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -329,6 +402,11 @@ public BitRate(double value, UnitSystem unitSystem) /// public double TerabytesPerSecond => As(BitRateUnit.TerabytePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double TeraoctetsPerSecond => As(BitRateUnit.TeraoctetPerSecond); + #endregion #region Static Methods @@ -343,28 +421,41 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(BitRateUnit.BytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.ExabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.ExabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.ExbibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.ExbibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.ExbioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.GibibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.GibibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GibioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.GigabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.GigabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.GigaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.KibibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.KibibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KibioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.KilobitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.KilobytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.KilooctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.MebibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.MebibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MebioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.MegabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.MegabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.MegaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.OctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.PebibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.PebibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PebioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.PetabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.PetabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.PetaoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.TebibitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.TebibytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TebioctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.TerabitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.TerabytePerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.TeraoctetPerSecond, BitRateUnit.BitPerSecond, quantity => quantity.ToUnit(BitRateUnit.BitPerSecond)); // Register in unit converter: BaseUnit <-> BaseUnit unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.BitPerSecond, quantity => quantity); @@ -373,28 +464,41 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.BytePerSecond, quantity => quantity.ToUnit(BitRateUnit.BytePerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.ExabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExabitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.ExabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.ExabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.ExaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExaoctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.ExbibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExbibitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.ExbibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.ExbibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.ExbioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.ExbioctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.GibibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.GibibitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.GibibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.GibibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.GibioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.GibioctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.GigabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.GigabitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.GigabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.GigabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.GigaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.GigaoctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.KibibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.KibibitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.KibibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.KibibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.KibioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.KibioctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.KilobitPerSecond, quantity => quantity.ToUnit(BitRateUnit.KilobitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.KilobytePerSecond, quantity => quantity.ToUnit(BitRateUnit.KilobytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.KilooctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.KilooctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.MebibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.MebibitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.MebibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.MebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.MebioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.MebioctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.MegabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.MegabitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.MegabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.MegabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.MegaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.MegaoctetPerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.OctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.OctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.PebibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.PebibitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.PebibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.PebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.PebioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.PebioctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.PetabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.PetabitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.PetabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.PetabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.PetaoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.PetaoctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.TebibitPerSecond, quantity => quantity.ToUnit(BitRateUnit.TebibitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.TebibytePerSecond, quantity => quantity.ToUnit(BitRateUnit.TebibytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.TebioctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.TebioctetPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.TerabitPerSecond, quantity => quantity.ToUnit(BitRateUnit.TerabitPerSecond)); unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.TerabytePerSecond, quantity => quantity.ToUnit(BitRateUnit.TerabytePerSecond)); + unitConverter.SetConversionFunction(BitRateUnit.BitPerSecond, BitRateUnit.TeraoctetPerSecond, quantity => quantity.ToUnit(BitRateUnit.TeraoctetPerSecond)); } /// @@ -454,6 +558,14 @@ public static BitRate FromExabytesPerSecond(double value) return new BitRate(value, BitRateUnit.ExabytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromExaoctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.ExaoctetPerSecond); + } + /// /// Creates a from . /// @@ -470,6 +582,14 @@ public static BitRate FromExbibytesPerSecond(double value) return new BitRate(value, BitRateUnit.ExbibytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromExbioctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.ExbioctetPerSecond); + } + /// /// Creates a from . /// @@ -486,6 +606,14 @@ public static BitRate FromGibibytesPerSecond(double value) return new BitRate(value, BitRateUnit.GibibytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromGibioctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.GibioctetPerSecond); + } + /// /// Creates a from . /// @@ -502,6 +630,14 @@ public static BitRate FromGigabytesPerSecond(double value) return new BitRate(value, BitRateUnit.GigabytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromGigaoctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.GigaoctetPerSecond); + } + /// /// Creates a from . /// @@ -518,6 +654,14 @@ public static BitRate FromKibibytesPerSecond(double value) return new BitRate(value, BitRateUnit.KibibytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromKibioctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.KibioctetPerSecond); + } + /// /// Creates a from . /// @@ -534,6 +678,14 @@ public static BitRate FromKilobytesPerSecond(double value) return new BitRate(value, BitRateUnit.KilobytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromKilooctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.KilooctetPerSecond); + } + /// /// Creates a from . /// @@ -550,6 +702,14 @@ public static BitRate FromMebibytesPerSecond(double value) return new BitRate(value, BitRateUnit.MebibytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromMebioctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.MebioctetPerSecond); + } + /// /// Creates a from . /// @@ -566,6 +726,22 @@ public static BitRate FromMegabytesPerSecond(double value) return new BitRate(value, BitRateUnit.MegabytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromMegaoctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.MegaoctetPerSecond); + } + + /// + /// Creates a from . + /// + public static BitRate FromOctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.OctetPerSecond); + } + /// /// Creates a from . /// @@ -582,6 +758,14 @@ public static BitRate FromPebibytesPerSecond(double value) return new BitRate(value, BitRateUnit.PebibytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromPebioctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.PebioctetPerSecond); + } + /// /// Creates a from . /// @@ -598,6 +782,14 @@ public static BitRate FromPetabytesPerSecond(double value) return new BitRate(value, BitRateUnit.PetabytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromPetaoctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.PetaoctetPerSecond); + } + /// /// Creates a from . /// @@ -614,6 +806,14 @@ public static BitRate FromTebibytesPerSecond(double value) return new BitRate(value, BitRateUnit.TebibytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromTebioctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.TebioctetPerSecond); + } + /// /// Creates a from . /// @@ -630,6 +830,14 @@ public static BitRate FromTerabytesPerSecond(double value) return new BitRate(value, BitRateUnit.TerabytePerSecond); } + /// + /// Creates a from . + /// + public static BitRate FromTeraoctetsPerSecond(double value) + { + return new BitRate(value, BitRateUnit.TeraoctetPerSecond); + } + /// /// Dynamically convert from value and unit enum to . /// @@ -1099,55 +1307,81 @@ private bool TryToUnit(BitRateUnit unit, [NotNullWhen(true)] out BitRate? conver (BitRateUnit.BytePerSecond, BitRateUnit.BitPerSecond) => new BitRate(_value * 8, BitRateUnit.BitPerSecond), (BitRateUnit.ExabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e18d, BitRateUnit.BitPerSecond), (BitRateUnit.ExabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e18d, BitRateUnit.BitPerSecond), + (BitRateUnit.ExaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e18d, BitRateUnit.BitPerSecond), (BitRateUnit.ExbibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.ExbibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), + (BitRateUnit.ExbioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.GibibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.GibibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024), BitRateUnit.BitPerSecond), + (BitRateUnit.GibioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.GigabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e9d, BitRateUnit.BitPerSecond), (BitRateUnit.GigabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e9d, BitRateUnit.BitPerSecond), + (BitRateUnit.GigaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e9d, BitRateUnit.BitPerSecond), (BitRateUnit.KibibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1024d, BitRateUnit.BitPerSecond), (BitRateUnit.KibibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1024d, BitRateUnit.BitPerSecond), + (BitRateUnit.KibioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1024d, BitRateUnit.BitPerSecond), (BitRateUnit.KilobitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e3d, BitRateUnit.BitPerSecond), (BitRateUnit.KilobytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e3d, BitRateUnit.BitPerSecond), + (BitRateUnit.KilooctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e3d, BitRateUnit.BitPerSecond), (BitRateUnit.MebibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.MebibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024), BitRateUnit.BitPerSecond), + (BitRateUnit.MebioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.MegabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e6d, BitRateUnit.BitPerSecond), (BitRateUnit.MegabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e6d, BitRateUnit.BitPerSecond), + (BitRateUnit.MegaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e6d, BitRateUnit.BitPerSecond), + (BitRateUnit.OctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate(_value * 8, BitRateUnit.BitPerSecond), (BitRateUnit.PebibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.PebibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), + (BitRateUnit.PebioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.PetabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e15d, BitRateUnit.BitPerSecond), (BitRateUnit.PetabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e15d, BitRateUnit.BitPerSecond), + (BitRateUnit.PetaoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e15d, BitRateUnit.BitPerSecond), (BitRateUnit.TebibitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * (1024d * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.TebibytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), + (BitRateUnit.TebioctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * (1024d * 1024 * 1024 * 1024), BitRateUnit.BitPerSecond), (BitRateUnit.TerabitPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value) * 1e12d, BitRateUnit.BitPerSecond), (BitRateUnit.TerabytePerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e12d, BitRateUnit.BitPerSecond), + (BitRateUnit.TeraoctetPerSecond, BitRateUnit.BitPerSecond) => new BitRate((_value * 8) * 1e12d, BitRateUnit.BitPerSecond), // BaseUnit -> BitRateUnit (BitRateUnit.BitPerSecond, BitRateUnit.BytePerSecond) => new BitRate(_value / 8, BitRateUnit.BytePerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.ExabitPerSecond) => new BitRate((_value) / 1e18d, BitRateUnit.ExabitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.ExabytePerSecond) => new BitRate((_value / 8) / 1e18d, BitRateUnit.ExabytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.ExaoctetPerSecond) => new BitRate((_value / 8) / 1e18d, BitRateUnit.ExaoctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.ExbibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbibitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.ExbibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbibytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.ExbioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), BitRateUnit.ExbioctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.GibibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024), BitRateUnit.GibibitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.GibibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024), BitRateUnit.GibibytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.GibioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024), BitRateUnit.GibioctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.GigabitPerSecond) => new BitRate((_value) / 1e9d, BitRateUnit.GigabitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.GigabytePerSecond) => new BitRate((_value / 8) / 1e9d, BitRateUnit.GigabytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.GigaoctetPerSecond) => new BitRate((_value / 8) / 1e9d, BitRateUnit.GigaoctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.KibibitPerSecond) => new BitRate((_value) / 1024d, BitRateUnit.KibibitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.KibibytePerSecond) => new BitRate((_value / 8) / 1024d, BitRateUnit.KibibytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.KibioctetPerSecond) => new BitRate((_value / 8) / 1024d, BitRateUnit.KibioctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.KilobitPerSecond) => new BitRate((_value) / 1e3d, BitRateUnit.KilobitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.KilobytePerSecond) => new BitRate((_value / 8) / 1e3d, BitRateUnit.KilobytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.KilooctetPerSecond) => new BitRate((_value / 8) / 1e3d, BitRateUnit.KilooctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.MebibitPerSecond) => new BitRate((_value) / (1024d * 1024), BitRateUnit.MebibitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.MebibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024), BitRateUnit.MebibytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.MebioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024), BitRateUnit.MebioctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.MegabitPerSecond) => new BitRate((_value) / 1e6d, BitRateUnit.MegabitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.MegabytePerSecond) => new BitRate((_value / 8) / 1e6d, BitRateUnit.MegabytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.MegaoctetPerSecond) => new BitRate((_value / 8) / 1e6d, BitRateUnit.MegaoctetPerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.OctetPerSecond) => new BitRate(_value / 8, BitRateUnit.OctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.PebibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebibitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.PebibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebibytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.PebioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), BitRateUnit.PebioctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.PetabitPerSecond) => new BitRate((_value) / 1e15d, BitRateUnit.PetabitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.PetabytePerSecond) => new BitRate((_value / 8) / 1e15d, BitRateUnit.PetabytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.PetaoctetPerSecond) => new BitRate((_value / 8) / 1e15d, BitRateUnit.PetaoctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.TebibitPerSecond) => new BitRate((_value) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebibitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.TebibytePerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebibytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.TebioctetPerSecond) => new BitRate((_value / 8) / (1024d * 1024 * 1024 * 1024), BitRateUnit.TebioctetPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.TerabitPerSecond) => new BitRate((_value) / 1e12d, BitRateUnit.TerabitPerSecond), (BitRateUnit.BitPerSecond, BitRateUnit.TerabytePerSecond) => new BitRate((_value / 8) / 1e12d, BitRateUnit.TerabytePerSecond), + (BitRateUnit.BitPerSecond, BitRateUnit.TeraoctetPerSecond) => new BitRate((_value / 8) / 1e12d, BitRateUnit.TeraoctetPerSecond), _ => null }; diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs index bca77601ae..834fdbf272 100644 --- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs @@ -77,28 +77,41 @@ static Information() new UnitInfo(InformationUnit.Byte, "Bytes", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Exabit, "Exabits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Exabyte, "Exabytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Exaoctet, "Exaoctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Exbibit, "Exbibits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Exbibyte, "Exbibytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Exbioctet, "Exbioctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Gibibit, "Gibibits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Gibibyte, "Gibibytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Gibioctet, "Gibioctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Gigabit, "Gigabits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Gigabyte, "Gigabytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Gigaoctet, "Gigaoctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Kibibit, "Kibibits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Kibibyte, "Kibibytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Kibioctet, "Kibioctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Kilobit, "Kilobits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Kilobyte, "Kilobytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Kilooctet, "Kilooctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Mebibit, "Mebibits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Mebibyte, "Mebibytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Mebioctet, "Mebioctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Megabit, "Megabits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Megabyte, "Megabytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Megaoctet, "Megaoctets", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Octet, "Octets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Pebibit, "Pebibits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Pebibyte, "Pebibytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Pebioctet, "Pebioctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Petabit, "Petabits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Petabyte, "Petabytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Petaoctet, "Petaoctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Tebibit, "Tebibits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Tebibyte, "Tebibytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Tebioctet, "Tebioctets", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Terabit, "Terabits", BaseUnits.Undefined, "Information"), new UnitInfo(InformationUnit.Terabyte, "Terabytes", BaseUnits.Undefined, "Information"), + new UnitInfo(InformationUnit.Teraoctet, "Teraoctets", BaseUnits.Undefined, "Information"), }, BaseUnit, Zero, BaseDimensions); @@ -202,6 +215,11 @@ public Information(double value, InformationUnit unit) /// public double Exabytes => As(InformationUnit.Exabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Exaoctets => As(InformationUnit.Exaoctet); + /// /// Gets a value of this quantity converted into /// @@ -212,6 +230,11 @@ public Information(double value, InformationUnit unit) /// public double Exbibytes => As(InformationUnit.Exbibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Exbioctets => As(InformationUnit.Exbioctet); + /// /// Gets a value of this quantity converted into /// @@ -222,6 +245,11 @@ public Information(double value, InformationUnit unit) /// public double Gibibytes => As(InformationUnit.Gibibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Gibioctets => As(InformationUnit.Gibioctet); + /// /// Gets a value of this quantity converted into /// @@ -232,6 +260,11 @@ public Information(double value, InformationUnit unit) /// public double Gigabytes => As(InformationUnit.Gigabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Gigaoctets => As(InformationUnit.Gigaoctet); + /// /// Gets a value of this quantity converted into /// @@ -242,6 +275,11 @@ public Information(double value, InformationUnit unit) /// public double Kibibytes => As(InformationUnit.Kibibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Kibioctets => As(InformationUnit.Kibioctet); + /// /// Gets a value of this quantity converted into /// @@ -252,6 +290,11 @@ public Information(double value, InformationUnit unit) /// public double Kilobytes => As(InformationUnit.Kilobyte); + /// + /// Gets a value of this quantity converted into + /// + public double Kilooctets => As(InformationUnit.Kilooctet); + /// /// Gets a value of this quantity converted into /// @@ -262,6 +305,11 @@ public Information(double value, InformationUnit unit) /// public double Mebibytes => As(InformationUnit.Mebibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Mebioctets => As(InformationUnit.Mebioctet); + /// /// Gets a value of this quantity converted into /// @@ -272,6 +320,16 @@ public Information(double value, InformationUnit unit) /// public double Megabytes => As(InformationUnit.Megabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Megaoctets => As(InformationUnit.Megaoctet); + + /// + /// Gets a value of this quantity converted into + /// + public double Octets => As(InformationUnit.Octet); + /// /// Gets a value of this quantity converted into /// @@ -282,6 +340,11 @@ public Information(double value, InformationUnit unit) /// public double Pebibytes => As(InformationUnit.Pebibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Pebioctets => As(InformationUnit.Pebioctet); + /// /// Gets a value of this quantity converted into /// @@ -292,6 +355,11 @@ public Information(double value, InformationUnit unit) /// public double Petabytes => As(InformationUnit.Petabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Petaoctets => As(InformationUnit.Petaoctet); + /// /// Gets a value of this quantity converted into /// @@ -302,6 +370,11 @@ public Information(double value, InformationUnit unit) /// public double Tebibytes => As(InformationUnit.Tebibyte); + /// + /// Gets a value of this quantity converted into + /// + public double Tebioctets => As(InformationUnit.Tebioctet); + /// /// Gets a value of this quantity converted into /// @@ -312,6 +385,11 @@ public Information(double value, InformationUnit unit) /// public double Terabytes => As(InformationUnit.Terabyte); + /// + /// Gets a value of this quantity converted into + /// + public double Teraoctets => As(InformationUnit.Teraoctet); + #endregion #region Static Methods @@ -326,28 +404,41 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(InformationUnit.Byte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Exabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Exabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Exaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Exbibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Exbibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Exbioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Gibibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Gibibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Gibioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Gigabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Gigabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Gigaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Kibibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Kibibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Kibioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Kilobit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Kilobyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Kilooctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Mebibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Mebibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Mebioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Megabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Megabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Megaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Octet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Pebibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Pebibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Pebioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Petabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Petabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Petaoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Tebibit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Tebibyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Tebioctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Terabit, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); unitConverter.SetConversionFunction(InformationUnit.Terabyte, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); + unitConverter.SetConversionFunction(InformationUnit.Teraoctet, InformationUnit.Bit, quantity => quantity.ToUnit(InformationUnit.Bit)); // Register in unit converter: BaseUnit <-> BaseUnit unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Bit, quantity => quantity); @@ -356,28 +447,41 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Byte, quantity => quantity.ToUnit(InformationUnit.Byte)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Exabit, quantity => quantity.ToUnit(InformationUnit.Exabit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Exabyte, quantity => quantity.ToUnit(InformationUnit.Exabyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Exaoctet, quantity => quantity.ToUnit(InformationUnit.Exaoctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Exbibit, quantity => quantity.ToUnit(InformationUnit.Exbibit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Exbibyte, quantity => quantity.ToUnit(InformationUnit.Exbibyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Exbioctet, quantity => quantity.ToUnit(InformationUnit.Exbioctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Gibibit, quantity => quantity.ToUnit(InformationUnit.Gibibit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Gibibyte, quantity => quantity.ToUnit(InformationUnit.Gibibyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Gibioctet, quantity => quantity.ToUnit(InformationUnit.Gibioctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Gigabit, quantity => quantity.ToUnit(InformationUnit.Gigabit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Gigabyte, quantity => quantity.ToUnit(InformationUnit.Gigabyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Gigaoctet, quantity => quantity.ToUnit(InformationUnit.Gigaoctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Kibibit, quantity => quantity.ToUnit(InformationUnit.Kibibit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Kibibyte, quantity => quantity.ToUnit(InformationUnit.Kibibyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Kibioctet, quantity => quantity.ToUnit(InformationUnit.Kibioctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Kilobit, quantity => quantity.ToUnit(InformationUnit.Kilobit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Kilobyte, quantity => quantity.ToUnit(InformationUnit.Kilobyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Kilooctet, quantity => quantity.ToUnit(InformationUnit.Kilooctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Mebibit, quantity => quantity.ToUnit(InformationUnit.Mebibit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Mebibyte, quantity => quantity.ToUnit(InformationUnit.Mebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Mebioctet, quantity => quantity.ToUnit(InformationUnit.Mebioctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Megabit, quantity => quantity.ToUnit(InformationUnit.Megabit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Megabyte, quantity => quantity.ToUnit(InformationUnit.Megabyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Megaoctet, quantity => quantity.ToUnit(InformationUnit.Megaoctet)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Octet, quantity => quantity.ToUnit(InformationUnit.Octet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Pebibit, quantity => quantity.ToUnit(InformationUnit.Pebibit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Pebibyte, quantity => quantity.ToUnit(InformationUnit.Pebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Pebioctet, quantity => quantity.ToUnit(InformationUnit.Pebioctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Petabit, quantity => quantity.ToUnit(InformationUnit.Petabit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Petabyte, quantity => quantity.ToUnit(InformationUnit.Petabyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Petaoctet, quantity => quantity.ToUnit(InformationUnit.Petaoctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Tebibit, quantity => quantity.ToUnit(InformationUnit.Tebibit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Tebibyte, quantity => quantity.ToUnit(InformationUnit.Tebibyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Tebioctet, quantity => quantity.ToUnit(InformationUnit.Tebioctet)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Terabit, quantity => quantity.ToUnit(InformationUnit.Terabit)); unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Terabyte, quantity => quantity.ToUnit(InformationUnit.Terabyte)); + unitConverter.SetConversionFunction(InformationUnit.Bit, InformationUnit.Teraoctet, quantity => quantity.ToUnit(InformationUnit.Teraoctet)); } /// @@ -437,6 +541,14 @@ public static Information FromExabytes(double value) return new Information(value, InformationUnit.Exabyte); } + /// + /// Creates a from . + /// + public static Information FromExaoctets(double value) + { + return new Information(value, InformationUnit.Exaoctet); + } + /// /// Creates a from . /// @@ -453,6 +565,14 @@ public static Information FromExbibytes(double value) return new Information(value, InformationUnit.Exbibyte); } + /// + /// Creates a from . + /// + public static Information FromExbioctets(double value) + { + return new Information(value, InformationUnit.Exbioctet); + } + /// /// Creates a from . /// @@ -469,6 +589,14 @@ public static Information FromGibibytes(double value) return new Information(value, InformationUnit.Gibibyte); } + /// + /// Creates a from . + /// + public static Information FromGibioctets(double value) + { + return new Information(value, InformationUnit.Gibioctet); + } + /// /// Creates a from . /// @@ -485,6 +613,14 @@ public static Information FromGigabytes(double value) return new Information(value, InformationUnit.Gigabyte); } + /// + /// Creates a from . + /// + public static Information FromGigaoctets(double value) + { + return new Information(value, InformationUnit.Gigaoctet); + } + /// /// Creates a from . /// @@ -501,6 +637,14 @@ public static Information FromKibibytes(double value) return new Information(value, InformationUnit.Kibibyte); } + /// + /// Creates a from . + /// + public static Information FromKibioctets(double value) + { + return new Information(value, InformationUnit.Kibioctet); + } + /// /// Creates a from . /// @@ -517,6 +661,14 @@ public static Information FromKilobytes(double value) return new Information(value, InformationUnit.Kilobyte); } + /// + /// Creates a from . + /// + public static Information FromKilooctets(double value) + { + return new Information(value, InformationUnit.Kilooctet); + } + /// /// Creates a from . /// @@ -533,6 +685,14 @@ public static Information FromMebibytes(double value) return new Information(value, InformationUnit.Mebibyte); } + /// + /// Creates a from . + /// + public static Information FromMebioctets(double value) + { + return new Information(value, InformationUnit.Mebioctet); + } + /// /// Creates a from . /// @@ -549,6 +709,22 @@ public static Information FromMegabytes(double value) return new Information(value, InformationUnit.Megabyte); } + /// + /// Creates a from . + /// + public static Information FromMegaoctets(double value) + { + return new Information(value, InformationUnit.Megaoctet); + } + + /// + /// Creates a from . + /// + public static Information FromOctets(double value) + { + return new Information(value, InformationUnit.Octet); + } + /// /// Creates a from . /// @@ -565,6 +741,14 @@ public static Information FromPebibytes(double value) return new Information(value, InformationUnit.Pebibyte); } + /// + /// Creates a from . + /// + public static Information FromPebioctets(double value) + { + return new Information(value, InformationUnit.Pebioctet); + } + /// /// Creates a from . /// @@ -581,6 +765,14 @@ public static Information FromPetabytes(double value) return new Information(value, InformationUnit.Petabyte); } + /// + /// Creates a from . + /// + public static Information FromPetaoctets(double value) + { + return new Information(value, InformationUnit.Petaoctet); + } + /// /// Creates a from . /// @@ -597,6 +789,14 @@ public static Information FromTebibytes(double value) return new Information(value, InformationUnit.Tebibyte); } + /// + /// Creates a from . + /// + public static Information FromTebioctets(double value) + { + return new Information(value, InformationUnit.Tebioctet); + } + /// /// Creates a from . /// @@ -613,6 +813,14 @@ public static Information FromTerabytes(double value) return new Information(value, InformationUnit.Terabyte); } + /// + /// Creates a from . + /// + public static Information FromTeraoctets(double value) + { + return new Information(value, InformationUnit.Teraoctet); + } + /// /// Dynamically convert from value and unit enum to . /// @@ -1082,55 +1290,81 @@ private bool TryToUnit(InformationUnit unit, [NotNullWhen(true)] out Information (InformationUnit.Byte, InformationUnit.Bit) => new Information(_value * 8, InformationUnit.Bit), (InformationUnit.Exabit, InformationUnit.Bit) => new Information((_value) * 1e18d, InformationUnit.Bit), (InformationUnit.Exabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e18d, InformationUnit.Bit), + (InformationUnit.Exaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e18d, InformationUnit.Bit), (InformationUnit.Exbibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Exbibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit), + (InformationUnit.Exbioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Gibibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Gibibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024), InformationUnit.Bit), + (InformationUnit.Gibioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Gigabit, InformationUnit.Bit) => new Information((_value) * 1e9d, InformationUnit.Bit), (InformationUnit.Gigabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e9d, InformationUnit.Bit), + (InformationUnit.Gigaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e9d, InformationUnit.Bit), (InformationUnit.Kibibit, InformationUnit.Bit) => new Information((_value) * 1024d, InformationUnit.Bit), (InformationUnit.Kibibyte, InformationUnit.Bit) => new Information((_value * 8) * 1024d, InformationUnit.Bit), + (InformationUnit.Kibioctet, InformationUnit.Bit) => new Information((_value * 8) * 1024d, InformationUnit.Bit), (InformationUnit.Kilobit, InformationUnit.Bit) => new Information((_value) * 1e3d, InformationUnit.Bit), (InformationUnit.Kilobyte, InformationUnit.Bit) => new Information((_value * 8) * 1e3d, InformationUnit.Bit), + (InformationUnit.Kilooctet, InformationUnit.Bit) => new Information((_value * 8) * 1e3d, InformationUnit.Bit), (InformationUnit.Mebibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024), InformationUnit.Bit), (InformationUnit.Mebibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024), InformationUnit.Bit), + (InformationUnit.Mebioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024), InformationUnit.Bit), (InformationUnit.Megabit, InformationUnit.Bit) => new Information((_value) * 1e6d, InformationUnit.Bit), (InformationUnit.Megabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e6d, InformationUnit.Bit), + (InformationUnit.Megaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e6d, InformationUnit.Bit), + (InformationUnit.Octet, InformationUnit.Bit) => new Information(_value * 8, InformationUnit.Bit), (InformationUnit.Pebibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Pebibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit), + (InformationUnit.Pebioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Petabit, InformationUnit.Bit) => new Information((_value) * 1e15d, InformationUnit.Bit), (InformationUnit.Petabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e15d, InformationUnit.Bit), + (InformationUnit.Petaoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e15d, InformationUnit.Bit), (InformationUnit.Tebibit, InformationUnit.Bit) => new Information((_value) * (1024d * 1024 * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Tebibyte, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024), InformationUnit.Bit), + (InformationUnit.Tebioctet, InformationUnit.Bit) => new Information((_value * 8) * (1024d * 1024 * 1024 * 1024), InformationUnit.Bit), (InformationUnit.Terabit, InformationUnit.Bit) => new Information((_value) * 1e12d, InformationUnit.Bit), (InformationUnit.Terabyte, InformationUnit.Bit) => new Information((_value * 8) * 1e12d, InformationUnit.Bit), + (InformationUnit.Teraoctet, InformationUnit.Bit) => new Information((_value * 8) * 1e12d, InformationUnit.Bit), // BaseUnit -> InformationUnit (InformationUnit.Bit, InformationUnit.Byte) => new Information(_value / 8, InformationUnit.Byte), (InformationUnit.Bit, InformationUnit.Exabit) => new Information((_value) / 1e18d, InformationUnit.Exabit), (InformationUnit.Bit, InformationUnit.Exabyte) => new Information((_value / 8) / 1e18d, InformationUnit.Exabyte), + (InformationUnit.Bit, InformationUnit.Exaoctet) => new Information((_value / 8) / 1e18d, InformationUnit.Exaoctet), (InformationUnit.Bit, InformationUnit.Exbibit) => new Information((_value) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbibit), (InformationUnit.Bit, InformationUnit.Exbibyte) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbibyte), + (InformationUnit.Bit, InformationUnit.Exbioctet) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024 * 1024), InformationUnit.Exbioctet), (InformationUnit.Bit, InformationUnit.Gibibit) => new Information((_value) / (1024d * 1024 * 1024), InformationUnit.Gibibit), (InformationUnit.Bit, InformationUnit.Gibibyte) => new Information((_value / 8) / (1024d * 1024 * 1024), InformationUnit.Gibibyte), + (InformationUnit.Bit, InformationUnit.Gibioctet) => new Information((_value / 8) / (1024d * 1024 * 1024), InformationUnit.Gibioctet), (InformationUnit.Bit, InformationUnit.Gigabit) => new Information((_value) / 1e9d, InformationUnit.Gigabit), (InformationUnit.Bit, InformationUnit.Gigabyte) => new Information((_value / 8) / 1e9d, InformationUnit.Gigabyte), + (InformationUnit.Bit, InformationUnit.Gigaoctet) => new Information((_value / 8) / 1e9d, InformationUnit.Gigaoctet), (InformationUnit.Bit, InformationUnit.Kibibit) => new Information((_value) / 1024d, InformationUnit.Kibibit), (InformationUnit.Bit, InformationUnit.Kibibyte) => new Information((_value / 8) / 1024d, InformationUnit.Kibibyte), + (InformationUnit.Bit, InformationUnit.Kibioctet) => new Information((_value / 8) / 1024d, InformationUnit.Kibioctet), (InformationUnit.Bit, InformationUnit.Kilobit) => new Information((_value) / 1e3d, InformationUnit.Kilobit), (InformationUnit.Bit, InformationUnit.Kilobyte) => new Information((_value / 8) / 1e3d, InformationUnit.Kilobyte), + (InformationUnit.Bit, InformationUnit.Kilooctet) => new Information((_value / 8) / 1e3d, InformationUnit.Kilooctet), (InformationUnit.Bit, InformationUnit.Mebibit) => new Information((_value) / (1024d * 1024), InformationUnit.Mebibit), (InformationUnit.Bit, InformationUnit.Mebibyte) => new Information((_value / 8) / (1024d * 1024), InformationUnit.Mebibyte), + (InformationUnit.Bit, InformationUnit.Mebioctet) => new Information((_value / 8) / (1024d * 1024), InformationUnit.Mebioctet), (InformationUnit.Bit, InformationUnit.Megabit) => new Information((_value) / 1e6d, InformationUnit.Megabit), (InformationUnit.Bit, InformationUnit.Megabyte) => new Information((_value / 8) / 1e6d, InformationUnit.Megabyte), + (InformationUnit.Bit, InformationUnit.Megaoctet) => new Information((_value / 8) / 1e6d, InformationUnit.Megaoctet), + (InformationUnit.Bit, InformationUnit.Octet) => new Information(_value / 8, InformationUnit.Octet), (InformationUnit.Bit, InformationUnit.Pebibit) => new Information((_value) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebibit), (InformationUnit.Bit, InformationUnit.Pebibyte) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebibyte), + (InformationUnit.Bit, InformationUnit.Pebioctet) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024 * 1024), InformationUnit.Pebioctet), (InformationUnit.Bit, InformationUnit.Petabit) => new Information((_value) / 1e15d, InformationUnit.Petabit), (InformationUnit.Bit, InformationUnit.Petabyte) => new Information((_value / 8) / 1e15d, InformationUnit.Petabyte), + (InformationUnit.Bit, InformationUnit.Petaoctet) => new Information((_value / 8) / 1e15d, InformationUnit.Petaoctet), (InformationUnit.Bit, InformationUnit.Tebibit) => new Information((_value) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebibit), (InformationUnit.Bit, InformationUnit.Tebibyte) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebibyte), + (InformationUnit.Bit, InformationUnit.Tebioctet) => new Information((_value / 8) / (1024d * 1024 * 1024 * 1024), InformationUnit.Tebioctet), (InformationUnit.Bit, InformationUnit.Terabit) => new Information((_value) / 1e12d, InformationUnit.Terabit), (InformationUnit.Bit, InformationUnit.Terabyte) => new Information((_value / 8) / 1e12d, InformationUnit.Terabyte), + (InformationUnit.Bit, InformationUnit.Teraoctet) => new Information((_value / 8) / 1e12d, InformationUnit.Teraoctet), _ => null }; diff --git a/UnitsNet/GeneratedCode/Resources/BitRate.restext b/UnitsNet/GeneratedCode/Resources/BitRate.restext index c88dd8c809..8e4c210b19 100644 --- a/UnitsNet/GeneratedCode/Resources/BitRate.restext +++ b/UnitsNet/GeneratedCode/Resources/BitRate.restext @@ -2,25 +2,38 @@ BitsPerSecond=bit/s,bps BytesPerSecond=B/s ExabitsPerSecond=Ebit/s,Ebps ExabytesPerSecond=EB/s +ExaoctetsPerSecond=Eo/s ExbibitsPerSecond=Eibit/s,Eibps ExbibytesPerSecond=EiB/s +ExbioctetsPerSecond=Eio/s GibibitsPerSecond=Gibit/s,Gibps GibibytesPerSecond=GiB/s +GibioctetsPerSecond=Gio/s GigabitsPerSecond=Gbit/s,Gbps GigabytesPerSecond=GB/s +GigaoctetsPerSecond=Go/s KibibitsPerSecond=Kibit/s,Kibps KibibytesPerSecond=KiB/s +KibioctetsPerSecond=Kio/s KilobitsPerSecond=kbit/s,kbps KilobytesPerSecond=kB/s +KilooctetsPerSecond=ko/s MebibitsPerSecond=Mibit/s,Mibps MebibytesPerSecond=MiB/s +MebioctetsPerSecond=Mio/s MegabitsPerSecond=Mbit/s,Mbps MegabytesPerSecond=MB/s +MegaoctetsPerSecond=Mo/s +OctetsPerSecond=o/s PebibitsPerSecond=Pibit/s,Pibps PebibytesPerSecond=PiB/s +PebioctetsPerSecond=Pio/s PetabitsPerSecond=Pbit/s,Pbps PetabytesPerSecond=PB/s +PetaoctetsPerSecond=Po/s TebibitsPerSecond=Tibit/s,Tibps TebibytesPerSecond=TiB/s +TebioctetsPerSecond=Tio/s TerabitsPerSecond=Tbit/s,Tbps TerabytesPerSecond=TB/s +TeraoctetsPerSecond=To/s diff --git a/UnitsNet/GeneratedCode/Resources/Information.restext b/UnitsNet/GeneratedCode/Resources/Information.restext index 7618b95362..fe69fac536 100644 --- a/UnitsNet/GeneratedCode/Resources/Information.restext +++ b/UnitsNet/GeneratedCode/Resources/Information.restext @@ -2,25 +2,38 @@ Bits=b Bytes=B Exabits=Eb Exabytes=EB +Exaoctets=Eo Exbibits=Eib Exbibytes=EiB +Exbioctets=Eio Gibibits=Gib Gibibytes=GiB +Gibioctets=Gio Gigabits=Gb Gigabytes=GB +Gigaoctets=Go Kibibits=Kib Kibibytes=KiB +Kibioctets=Kio Kilobits=kb Kilobytes=kB +Kilooctets=ko Mebibits=Mib Mebibytes=MiB +Mebioctets=Mio Megabits=Mb Megabytes=MB +Megaoctets=Mo +Octets=o Pebibits=Pib Pebibytes=PiB +Pebioctets=Pio Petabits=Pb Petabytes=PB +Petaoctets=Po Tebibits=Tib Tebibytes=TiB +Tebioctets=Tio Terabits=Tb Terabytes=TB +Teraoctets=To diff --git a/UnitsNet/GeneratedCode/Units/BitRateUnit.g.cs b/UnitsNet/GeneratedCode/Units/BitRateUnit.g.cs index 6a3760ef6b..ebfb72662d 100644 --- a/UnitsNet/GeneratedCode/Units/BitRateUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/BitRateUnit.g.cs @@ -29,28 +29,41 @@ public enum BitRateUnit BytePerSecond = 2, ExabitPerSecond = 3, ExabytePerSecond = 4, + ExaoctetPerSecond = 29, ExbibitPerSecond = 5, ExbibytePerSecond = 6, + ExbioctetPerSecond = 31, GibibitPerSecond = 7, GibibytePerSecond = 8, + GibioctetPerSecond = 32, GigabitPerSecond = 9, GigabytePerSecond = 10, + GigaoctetPerSecond = 35, KibibitPerSecond = 11, KibibytePerSecond = 12, + KibioctetPerSecond = 30, KilobitPerSecond = 13, KilobytePerSecond = 14, + KilooctetPerSecond = 27, MebibitPerSecond = 15, MebibytePerSecond = 16, + MebioctetPerSecond = 36, MegabitPerSecond = 17, MegabytePerSecond = 18, + MegaoctetPerSecond = 34, + OctetPerSecond = 28, PebibitPerSecond = 19, PebibytePerSecond = 20, + PebioctetPerSecond = 33, PetabitPerSecond = 21, PetabytePerSecond = 22, + PetaoctetPerSecond = 46, TebibitPerSecond = 23, TebibytePerSecond = 24, + TebioctetPerSecond = 42, TerabitPerSecond = 25, TerabytePerSecond = 26, + TeraoctetPerSecond = 40, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Units/InformationUnit.g.cs b/UnitsNet/GeneratedCode/Units/InformationUnit.g.cs index fd72b621c2..ca0b4e2d4b 100644 --- a/UnitsNet/GeneratedCode/Units/InformationUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/InformationUnit.g.cs @@ -29,28 +29,41 @@ public enum InformationUnit Byte = 2, Exabit = 3, Exabyte = 4, + Exaoctet = 33, Exbibit = 5, Exbibyte = 6, + Exbioctet = 35, Gibibit = 7, Gibibyte = 8, + Gibioctet = 27, Gigabit = 9, Gigabyte = 10, + Gigaoctet = 28, Kibibit = 11, Kibibyte = 12, + Kibioctet = 30, Kilobit = 13, Kilobyte = 14, + Kilooctet = 32, Mebibit = 15, Mebibyte = 16, + Mebioctet = 36, Megabit = 17, Megabyte = 18, + Megaoctet = 34, + Octet = 31, Pebibit = 19, Pebibyte = 20, + Pebioctet = 29, Petabit = 21, Petabyte = 22, + Petaoctet = 39, Tebibit = 23, Tebibyte = 24, + Tebioctet = 43, Terabit = 25, Terabyte = 26, + Teraoctet = 40, } #pragma warning restore 1591