diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs index 18603760e3..9d20fde52a 100644 --- a/UnitsNet.Tests/CustomCode/VolumeTests.cs +++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs @@ -66,9 +66,15 @@ public class VolumeTests : VolumeTestsBase protected override double TeaspoonsTolerance => 1E-3; protected override double UsGallonsInOneCubicMeter => 264.17217; - + protected override double UsOuncesInOneCubicMeter => 33814.02270; + protected override double MetricCupsInOneCubicMeter => 4000; + + protected override double UsCustomaryCupsInOneCubicMeter => 4226.75283773; + + protected override double UsLegalCupsInOneCubicMeter => 4166.666666667; + [Test] public void VolumeDividedByAreaEqualsLength() { diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs index 8fa6bb0ad9..97a0f13a8b 100644 --- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs @@ -51,10 +51,13 @@ public abstract partial class VolumeTestsBase protected abstract double ImperialGallonsInOneCubicMeter { get; } protected abstract double ImperialOuncesInOneCubicMeter { get; } protected abstract double LitersInOneCubicMeter { get; } + protected abstract double MetricCupsInOneCubicMeter { get; } protected abstract double MillilitersInOneCubicMeter { get; } protected abstract double TablespoonsInOneCubicMeter { get; } protected abstract double TeaspoonsInOneCubicMeter { get; } + protected abstract double UsCustomaryCupsInOneCubicMeter { get; } protected abstract double UsGallonsInOneCubicMeter { get; } + protected abstract double UsLegalCupsInOneCubicMeter { get; } protected abstract double UsOuncesInOneCubicMeter { get; } // ReSharper disable VirtualMemberNeverOverriden.Global @@ -73,10 +76,13 @@ public abstract partial class VolumeTestsBase protected virtual double ImperialGallonsTolerance { get { return 1e-5; } } protected virtual double ImperialOuncesTolerance { get { return 1e-5; } } protected virtual double LitersTolerance { get { return 1e-5; } } + protected virtual double MetricCupsTolerance { get { return 1e-5; } } protected virtual double MillilitersTolerance { get { return 1e-5; } } protected virtual double TablespoonsTolerance { get { return 1e-5; } } protected virtual double TeaspoonsTolerance { get { return 1e-5; } } + protected virtual double UsCustomaryCupsTolerance { get { return 1e-5; } } protected virtual double UsGallonsTolerance { get { return 1e-5; } } + protected virtual double UsLegalCupsTolerance { get { return 1e-5; } } protected virtual double UsOuncesTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global @@ -99,10 +105,13 @@ public void CubicMeterToVolumeUnits() Assert.AreEqual(ImperialGallonsInOneCubicMeter, cubicmeter.ImperialGallons, ImperialGallonsTolerance); Assert.AreEqual(ImperialOuncesInOneCubicMeter, cubicmeter.ImperialOunces, ImperialOuncesTolerance); Assert.AreEqual(LitersInOneCubicMeter, cubicmeter.Liters, LitersTolerance); + Assert.AreEqual(MetricCupsInOneCubicMeter, cubicmeter.MetricCups, MetricCupsTolerance); Assert.AreEqual(MillilitersInOneCubicMeter, cubicmeter.Milliliters, MillilitersTolerance); Assert.AreEqual(TablespoonsInOneCubicMeter, cubicmeter.Tablespoons, TablespoonsTolerance); Assert.AreEqual(TeaspoonsInOneCubicMeter, cubicmeter.Teaspoons, TeaspoonsTolerance); + Assert.AreEqual(UsCustomaryCupsInOneCubicMeter, cubicmeter.UsCustomaryCups, UsCustomaryCupsTolerance); Assert.AreEqual(UsGallonsInOneCubicMeter, cubicmeter.UsGallons, UsGallonsTolerance); + Assert.AreEqual(UsLegalCupsInOneCubicMeter, cubicmeter.UsLegalCups, UsLegalCupsTolerance); Assert.AreEqual(UsOuncesInOneCubicMeter, cubicmeter.UsOunces, UsOuncesTolerance); } @@ -124,10 +133,13 @@ public void FromValueAndUnit() Assert.AreEqual(1, Volume.From(1, VolumeUnit.ImperialGallon).ImperialGallons, ImperialGallonsTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.ImperialOunce).ImperialOunces, ImperialOuncesTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.Liter).Liters, LitersTolerance); + Assert.AreEqual(1, Volume.From(1, VolumeUnit.MetricCup).MetricCups, MetricCupsTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.Milliliter).Milliliters, MillilitersTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.Tablespoon).Tablespoons, TablespoonsTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.Teaspoon).Teaspoons, TeaspoonsTolerance); + Assert.AreEqual(1, Volume.From(1, VolumeUnit.UsCustomaryCup).UsCustomaryCups, UsCustomaryCupsTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.UsGallon).UsGallons, UsGallonsTolerance); + Assert.AreEqual(1, Volume.From(1, VolumeUnit.UsLegalCup).UsLegalCups, UsLegalCupsTolerance); Assert.AreEqual(1, Volume.From(1, VolumeUnit.UsOunce).UsOunces, UsOuncesTolerance); } @@ -150,10 +162,13 @@ public void As() Assert.AreEqual(ImperialGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialGallon), ImperialGallonsTolerance); Assert.AreEqual(ImperialOuncesInOneCubicMeter, cubicmeter.As(VolumeUnit.ImperialOunce), ImperialOuncesTolerance); Assert.AreEqual(LitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Liter), LitersTolerance); + Assert.AreEqual(MetricCupsInOneCubicMeter, cubicmeter.As(VolumeUnit.MetricCup), MetricCupsTolerance); Assert.AreEqual(MillilitersInOneCubicMeter, cubicmeter.As(VolumeUnit.Milliliter), MillilitersTolerance); Assert.AreEqual(TablespoonsInOneCubicMeter, cubicmeter.As(VolumeUnit.Tablespoon), TablespoonsTolerance); Assert.AreEqual(TeaspoonsInOneCubicMeter, cubicmeter.As(VolumeUnit.Teaspoon), TeaspoonsTolerance); + Assert.AreEqual(UsCustomaryCupsInOneCubicMeter, cubicmeter.As(VolumeUnit.UsCustomaryCup), UsCustomaryCupsTolerance); Assert.AreEqual(UsGallonsInOneCubicMeter, cubicmeter.As(VolumeUnit.UsGallon), UsGallonsTolerance); + Assert.AreEqual(UsLegalCupsInOneCubicMeter, cubicmeter.As(VolumeUnit.UsLegalCup), UsLegalCupsTolerance); Assert.AreEqual(UsOuncesInOneCubicMeter, cubicmeter.As(VolumeUnit.UsOunce), UsOuncesTolerance); } @@ -176,10 +191,13 @@ public void ConversionRoundTrip() Assert.AreEqual(1, Volume.FromImperialGallons(cubicmeter.ImperialGallons).CubicMeters, ImperialGallonsTolerance); Assert.AreEqual(1, Volume.FromImperialOunces(cubicmeter.ImperialOunces).CubicMeters, ImperialOuncesTolerance); Assert.AreEqual(1, Volume.FromLiters(cubicmeter.Liters).CubicMeters, LitersTolerance); + Assert.AreEqual(1, Volume.FromMetricCups(cubicmeter.MetricCups).CubicMeters, MetricCupsTolerance); Assert.AreEqual(1, Volume.FromMilliliters(cubicmeter.Milliliters).CubicMeters, MillilitersTolerance); Assert.AreEqual(1, Volume.FromTablespoons(cubicmeter.Tablespoons).CubicMeters, TablespoonsTolerance); Assert.AreEqual(1, Volume.FromTeaspoons(cubicmeter.Teaspoons).CubicMeters, TeaspoonsTolerance); + Assert.AreEqual(1, Volume.FromUsCustomaryCups(cubicmeter.UsCustomaryCups).CubicMeters, UsCustomaryCupsTolerance); Assert.AreEqual(1, Volume.FromUsGallons(cubicmeter.UsGallons).CubicMeters, UsGallonsTolerance); + Assert.AreEqual(1, Volume.FromUsLegalCups(cubicmeter.UsLegalCups).CubicMeters, UsLegalCupsTolerance); Assert.AreEqual(1, Volume.FromUsOunces(cubicmeter.UsOunces).CubicMeters, UsOuncesTolerance); } diff --git a/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs b/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs index 8bea0de158..36e409a7d3 100644 --- a/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/VolumeUnit.g.cs @@ -40,10 +40,13 @@ public enum VolumeUnit ImperialGallon, ImperialOunce, Liter, + MetricCup, Milliliter, Tablespoon, Teaspoon, + UsCustomaryCup, UsGallon, + UsLegalCup, UsOunce, } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs index 78accd2f6c..53d824909f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Volume.g.cs @@ -174,6 +174,14 @@ public double Liters get { return _cubicMeters*1e3; } } + /// + /// Get Volume in MetricCups. + /// + public double MetricCups + { + get { return _cubicMeters/0.00025; } + } + /// /// Get Volume in Milliliters. /// @@ -198,6 +206,14 @@ public double Teaspoons get { return _cubicMeters/4.92892159e-6; } } + /// + /// Get Volume in UsCustomaryCups. + /// + public double UsCustomaryCups + { + get { return _cubicMeters/0.0002365882365; } + } + /// /// Get Volume in UsGallons. /// @@ -206,6 +222,14 @@ public double UsGallons get { return _cubicMeters/0.00378541; } } + /// + /// Get Volume in UsLegalCups. + /// + public double UsLegalCups + { + get { return _cubicMeters/0.00024; } + } + /// /// Get Volume in UsOunces. /// @@ -343,6 +367,14 @@ public static Volume FromLiters(double liters) return new Volume(liters/1e3); } + /// + /// Get Volume from MetricCups. + /// + public static Volume FromMetricCups(double metriccups) + { + return new Volume(metriccups*0.00025); + } + /// /// Get Volume from Milliliters. /// @@ -367,6 +399,14 @@ public static Volume FromTeaspoons(double teaspoons) return new Volume(teaspoons*4.92892159e-6); } + /// + /// Get Volume from UsCustomaryCups. + /// + public static Volume FromUsCustomaryCups(double uscustomarycups) + { + return new Volume(uscustomarycups*0.0002365882365); + } + /// /// Get Volume from UsGallons. /// @@ -375,6 +415,14 @@ public static Volume FromUsGallons(double usgallons) return new Volume(usgallons*0.00378541); } + /// + /// Get Volume from UsLegalCups. + /// + public static Volume FromUsLegalCups(double uslegalcups) + { + return new Volume(uslegalcups*0.00024); + } + /// /// Get Volume from UsOunces. /// @@ -424,14 +472,20 @@ public static Volume From(double value, VolumeUnit fromUnit) return FromImperialOunces(value); case VolumeUnit.Liter: return FromLiters(value); + case VolumeUnit.MetricCup: + return FromMetricCups(value); case VolumeUnit.Milliliter: return FromMilliliters(value); case VolumeUnit.Tablespoon: return FromTablespoons(value); case VolumeUnit.Teaspoon: return FromTeaspoons(value); + case VolumeUnit.UsCustomaryCup: + return FromUsCustomaryCups(value); case VolumeUnit.UsGallon: return FromUsGallons(value); + case VolumeUnit.UsLegalCup: + return FromUsLegalCups(value); case VolumeUnit.UsOunce: return FromUsOunces(value); @@ -597,14 +651,20 @@ public double As(VolumeUnit unit) return ImperialOunces; case VolumeUnit.Liter: return Liters; + case VolumeUnit.MetricCup: + return MetricCups; case VolumeUnit.Milliliter: return Milliliters; case VolumeUnit.Tablespoon: return Tablespoons; case VolumeUnit.Teaspoon: return Teaspoons; + case VolumeUnit.UsCustomaryCup: + return UsCustomaryCups; case VolumeUnit.UsGallon: return UsGallons; + case VolumeUnit.UsLegalCup: + return UsLegalCups; case VolumeUnit.UsOunce: return UsOunces; diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 7c3cba51e0..34f44e565c 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1959,6 +1959,11 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "l"), new AbbreviationsForCulture("ru-RU", "л"), }), + new CulturesForEnumValue((int) VolumeUnit.MetricCup, + new[] + { + new AbbreviationsForCulture("en-US", ""), + }), new CulturesForEnumValue((int) VolumeUnit.Milliliter, new[] { @@ -1979,12 +1984,22 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("ru-RU", "чайная ложка"), new AbbreviationsForCulture("nb-NO", "ts", "ts."), }), + new CulturesForEnumValue((int) VolumeUnit.UsCustomaryCup, + new[] + { + new AbbreviationsForCulture("en-US", ""), + }), new CulturesForEnumValue((int) VolumeUnit.UsGallon, new[] { new AbbreviationsForCulture("en-US", "gal (U.S.)"), new AbbreviationsForCulture("ru-RU", "Американский галлон"), }), + new CulturesForEnumValue((int) VolumeUnit.UsLegalCup, + new[] + { + new AbbreviationsForCulture("en-US", ""), + }), new CulturesForEnumValue((int) VolumeUnit.UsOunce, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/Volume.json b/UnitsNet/Scripts/UnitDefinitions/Volume.json index 88dd758177..2f191efcb9 100644 --- a/UnitsNet/Scripts/UnitDefinitions/Volume.json +++ b/UnitsNet/Scripts/UnitDefinitions/Volume.json @@ -268,6 +268,42 @@ "Abbreviations": ["ts", "ts."] } ] + }, + { + "SingularName": "MetricCup", + "PluralName": "MetricCups", + "FromUnitToBaseFunc": "x*0.00025", + "FromBaseToUnitFunc": "x/0.00025", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [] + } + ] + }, + { + "SingularName": "UsCustomaryCup", + "PluralName": "UsCustomaryCups", + "FromUnitToBaseFunc": "x*0.0002365882365", + "FromBaseToUnitFunc": "x/0.0002365882365", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [] + } + ] + }, + { + "SingularName": "UsLegalCup", + "PluralName": "UsLegalCups", + "FromUnitToBaseFunc": "x*0.00024", + "FromBaseToUnitFunc": "x/0.00024", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [] + } + ] } ] -} \ No newline at end of file +}