diff --git a/Src/UnitsNet/Flow.cs b/Src/UnitsNet/Flow.cs
new file mode 100644
index 0000000000..295e6bf2e8
--- /dev/null
+++ b/Src/UnitsNet/Flow.cs
@@ -0,0 +1,150 @@
+using System;
+using System.Globalization;
+
+namespace UnitsNet
+{
+ ///
+ /// A class for representing flow.
+ ///
+ public struct Flow : IComparable, IComparable
+ {
+ private const double SecondToMinuteRatio = 60;
+ private const double SecondToHourRatio = 3600;
+
+ public readonly double CubicMeterPerSecond;
+
+ private Flow(double cubicMeterPerSecond)
+ : this()
+ {
+ CubicMeterPerSecond = cubicMeterPerSecond;
+ }
+
+ public double CubicMeterPerHour
+ {
+ get { return CubicMeterPerSecond / SecondToHourRatio; }
+ }
+
+ #region Static
+
+ public static Flow Zero
+ {
+ get { return new Flow(); }
+ }
+
+ public static Flow FromCubicMeterPerHour(double cmh)
+ {
+ return new Flow(cmh * SecondToHourRatio);
+ }
+
+ public static Flow FromCubicMeterPerSecond(double cms)
+ {
+ return new Flow(cms);
+ }
+
+ #endregion
+
+ #region Equality / IComparable
+
+ public int CompareTo(object obj)
+ {
+ if (obj == null) throw new ArgumentNullException("obj");
+ if (!(obj is Flow)) throw new ArgumentException("Expected type Flow.", "obj");
+ return CompareTo((Flow)obj);
+ }
+
+ public int CompareTo(Flow other)
+ {
+ return CubicMeterPerSecond.CompareTo(other.CubicMeterPerSecond);
+ }
+
+ public static bool operator <=(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond <= right.CubicMeterPerSecond;
+ }
+
+ public static bool operator >=(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond >= right.CubicMeterPerSecond;
+ }
+
+ public static bool operator <(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond < right.CubicMeterPerSecond;
+ }
+
+ public static bool operator >(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond > right.CubicMeterPerSecond;
+ }
+
+ public static bool operator ==(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond == right.CubicMeterPerSecond;
+ }
+
+ public static bool operator !=(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond != right.CubicMeterPerSecond;
+ }
+
+ public override bool Equals(object obj)
+ {
+ if (obj == null || GetType() != obj.GetType())
+ {
+ return false;
+ }
+
+ return CubicMeterPerSecond.Equals(((Flow)obj).CubicMeterPerSecond);
+ }
+
+ public override int GetHashCode()
+ {
+ return CubicMeterPerSecond.GetHashCode();
+ }
+ #endregion
+
+ #region Arithmetic operators
+
+ public static Flow operator -(Flow right)
+ {
+ return new Flow(-right.CubicMeterPerSecond);
+ }
+
+ public static Flow operator +(Flow left, Flow right)
+ {
+ return new Flow(left.CubicMeterPerSecond + right.CubicMeterPerSecond);
+ }
+
+ public static Flow operator -(Flow left, Flow right)
+ {
+ return new Flow(left.CubicMeterPerSecond - right.CubicMeterPerSecond);
+ }
+
+ public static Flow operator *(double left, Flow right)
+ {
+ return new Flow(left * right.CubicMeterPerSecond);
+ }
+
+ public static Flow operator *(Flow left, double right)
+ {
+ return new Flow(left.CubicMeterPerSecond * right);
+ }
+
+ public static Flow operator /(Flow left, double right)
+ {
+ return new Flow(left.CubicMeterPerSecond / right);
+ }
+
+ public static double operator /(Flow left, Flow right)
+ {
+ return left.CubicMeterPerSecond / right.CubicMeterPerSecond;
+ }
+
+ #endregion
+
+ public override string ToString()
+ {
+ return CubicMeterPerSecond + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit.CubicMeterPerSecond);
+ }
+ }
+}
diff --git a/Src/UnitsNet/Pressure.cs b/Src/UnitsNet/Pressure.cs
index f2c6544585..29f51a7ab8 100644
--- a/Src/UnitsNet/Pressure.cs
+++ b/Src/UnitsNet/Pressure.cs
@@ -30,6 +30,7 @@ namespace UnitsNet
public struct Pressure : IComparable, IComparable
{
private const double KpaToPaRatio = 1000;
+ private const double MpaToPaRatio = 1000000;
private const double Nm2ToPaRatio = 1;
private const double Ncm2ToPaRatio = 1E+4;
private const double Nmm2ToPaRatio = 1E+6;
@@ -38,6 +39,7 @@ public struct Pressure : IComparable, IComparable
private const double AtmToPaRatio = 101325;
private const double TorrToPaRatio = 1.3332266752*1E2;
private const double PsiToPaRatio = 6.89464975179*1E3;
+ private const double KFSCToPaRatio = 98066.5;
///
/// Pressure in pascal.
@@ -56,6 +58,16 @@ public double KiloPascals
get { return Pascals/KpaToPaRatio; }
}
+ public double MegaPascals
+ {
+ get { return Pascals / MpaToPaRatio; }
+ }
+
+ public double KilogramForcePerSquareCentimeter
+ {
+ get { return Pascals / KFSCToPaRatio; }
+ }
+
public double NewtonsPerSquareMeter
{
get { return Pascals/Nm2ToPaRatio; }
@@ -131,6 +143,16 @@ public static Pressure FromKiloPascals(double kpa)
return new Pressure(KpaToPaRatio*kpa);
}
+ public static Pressure FromMegaPascals(double mpa)
+ {
+ return new Pressure(MpaToPaRatio * mpa);
+ }
+
+ public static Pressure FromKilogramForcePerSquareCentimeter(double kfsc)
+ {
+ return new Pressure(KFSCToPaRatio * kfsc);
+ }
+
public static Pressure FromNewtonsPerSquareCentimeter(double nsc)
{
return new Pressure(Ncm2ToPaRatio*nsc);
diff --git a/Src/UnitsNet/Revolution.cs b/Src/UnitsNet/Revolution.cs
new file mode 100644
index 0000000000..37546d7eab
--- /dev/null
+++ b/Src/UnitsNet/Revolution.cs
@@ -0,0 +1,150 @@
+using System;
+using System.Globalization;
+
+namespace UnitsNet
+{
+ ///
+ /// A class for representing revolution.
+ ///
+ public struct Revolution : IComparable, IComparable
+ {
+ private const double MinuteToSecondRatio = 0.0166666666666667;
+ private const double SecondToMinuteRatio = 60;
+
+ public readonly double RevolutionsPerSecond;
+
+ private Revolution(double revolutionsPerSecond)
+ : this()
+ {
+ RevolutionsPerSecond = revolutionsPerSecond;
+ }
+
+ public double RevolutionsPerMinute
+ {
+ get { return RevolutionsPerSecond * SecondToMinuteRatio; }
+ }
+
+ #region Static
+
+ public static Revolution Zero
+ {
+ get { return new Revolution(); }
+ }
+
+ public static Revolution FromRevolutionsPerMinute(double revolutionsPerMinute)
+ {
+ return new Revolution(revolutionsPerMinute * MinuteToSecondRatio);
+ }
+
+ public static Revolution FromRevolutionsPerSecond(double revolutionsPerSecond)
+ {
+ return new Revolution(revolutionsPerSecond);
+ }
+
+ #endregion
+
+ #region Equality / IComparable
+
+ public int CompareTo(object obj)
+ {
+ if (obj == null) throw new ArgumentNullException("obj");
+ if (!(obj is Revolution)) throw new ArgumentException("Expected type Revolution.", "obj");
+ return CompareTo((Revolution)obj);
+ }
+
+ public int CompareTo(Revolution other)
+ {
+ return RevolutionsPerSecond.CompareTo(other.RevolutionsPerSecond);
+ }
+
+ public static bool operator <=(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond <= right.RevolutionsPerSecond;
+ }
+
+ public static bool operator >=(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond >= right.RevolutionsPerSecond;
+ }
+
+ public static bool operator <(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond < right.RevolutionsPerSecond;
+ }
+
+ public static bool operator >(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond > right.RevolutionsPerSecond;
+ }
+
+ public static bool operator ==(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond == right.RevolutionsPerSecond;
+ }
+
+ public static bool operator !=(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond != right.RevolutionsPerSecond;
+ }
+
+ public override bool Equals(object obj)
+ {
+ if (obj == null || GetType() != obj.GetType())
+ {
+ return false;
+ }
+
+ return RevolutionsPerSecond.Equals(((Revolution)obj).RevolutionsPerSecond);
+ }
+
+ public override int GetHashCode()
+ {
+ return RevolutionsPerSecond.GetHashCode();
+ }
+ #endregion
+
+ #region Arithmetic operators
+
+ public static Revolution operator -(Revolution right)
+ {
+ return new Revolution(-right.RevolutionsPerSecond);
+ }
+
+ public static Revolution operator +(Revolution left, Revolution right)
+ {
+ return new Revolution(left.RevolutionsPerSecond + right.RevolutionsPerSecond);
+ }
+
+ public static Revolution operator -(Revolution left, Revolution right)
+ {
+ return new Revolution(left.RevolutionsPerSecond - right.RevolutionsPerSecond);
+ }
+
+ public static Revolution operator *(double left, Revolution right)
+ {
+ return new Revolution(left * right.RevolutionsPerSecond);
+ }
+
+ public static Revolution operator *(Revolution left, double right)
+ {
+ return new Revolution(left.RevolutionsPerSecond * right);
+ }
+
+ public static Revolution operator /(Revolution left, double right)
+ {
+ return new Revolution(left.RevolutionsPerSecond / right);
+ }
+
+ public static double operator /(Revolution left, Revolution right)
+ {
+ return left.RevolutionsPerSecond / right.RevolutionsPerSecond;
+ }
+
+ #endregion
+
+ public override string ToString()
+ {
+ return RevolutionsPerSecond + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit.RevolutionsPerSecond);
+ }
+ }
+}
diff --git a/Src/UnitsNet/Unit.cs b/Src/UnitsNet/Unit.cs
index 660baaa448..873d4c1aff 100644
--- a/Src/UnitsNet/Unit.cs
+++ b/Src/UnitsNet/Unit.cs
@@ -70,14 +70,16 @@ public enum Unit
// Pressure
Pascal,
KiloPascal,
+ MegaPascal,
Psi,
NewtonPerSquareCentimeter,
NewtonPerSquareMillimeter,
NewtonPerSquareMeter,
- Bar,
+ Bar,
TechnicalAtmosphere,
Atmosphere,
Torr,
+ KilogramForcePerSquareCentimeter,
// Force
Kilonewton,
@@ -162,6 +164,14 @@ public enum Unit
// Cooking units
Tablespoon,
Teaspoon,
+
+ // Flow
+ CubicMeterPerSecond,
+ CubicMeterPerHour,
+
+ // Revolution
+ RevolutionsPerSecond,
+ RevolutionsPerMinute,
}
//public enum LengthUnit
diff --git a/Src/UnitsNet/UnitConverter.cs b/Src/UnitsNet/UnitConverter.cs
index dd0f2bd0b9..a78d3bbc89 100644
--- a/Src/UnitsNet/UnitConverter.cs
+++ b/Src/UnitsNet/UnitConverter.cs
@@ -51,6 +51,8 @@ public static double Convert(double value, Unit fromUnit, Unit toUnit)
if (TryConvertForce(value, fromUnit, toUnit, out newValue)) return newValue;
if (TryConvertTorque(value, fromUnit, toUnit, out newValue)) return newValue;
if (TryConvertTime(value, fromUnit, toUnit, out newValue)) return newValue;
+ if (TryConvertFlow(value, fromUnit, toUnit, out newValue)) return newValue;
+ if (TryConvertRevolutions(value, fromUnit, toUnit, out newValue)) return newValue;
throw new Exception(
string.Format("Conversion from unit [{0}] to [{1}] is either not valid or not yet implemented.",
@@ -83,6 +85,8 @@ public static bool TryConvert(double value, Unit fromUnit, Unit toUnit, out doub
if (TryConvertForce(value, fromUnit, toUnit, out newValue)) return true;
if (TryConvertTorque(value, fromUnit, toUnit, out newValue)) return true;
if (TryConvertTime(value, fromUnit, toUnit, out newValue)) return true;
+ if (TryConvertFlow(value, fromUnit, toUnit, out newValue)) return true;
+ if (TryConvertRevolutions(value, fromUnit, toUnit, out newValue)) return true;
return false;
}
@@ -164,6 +168,8 @@ private static bool TryConvertPressure(double value, Unit fromUnit, Unit toUnit,
return TryConvert(Pressure.FromPascals(value), toUnit, out newValue);
case Unit.KiloPascal:
return TryConvert(Pressure.FromKiloPascals(value), toUnit, out newValue);
+ case Unit.MegaPascal:
+ return TryConvert(Pressure.FromMegaPascals(value), toUnit, out newValue);
case Unit.Psi:
return TryConvert(Pressure.FromPsi(value), toUnit, out newValue);
case Unit.NewtonPerSquareCentimeter:
@@ -351,7 +357,37 @@ private static bool TryConvertMass(double value, Unit fromUnit, Unit toUnit, out
}
}
- private static bool TryConvert(Length l, Unit toUnit, out double newValue)
+ private static bool TryConvertFlow(double value, Unit fromUnit, Unit toUnit, out double newValue)
+ {
+ switch (fromUnit)
+ {
+ case Unit.CubicMeterPerSecond:
+ return TryConvert(Flow.FromCubicMeterPerSecond(value), toUnit, out newValue);
+ case Unit.CubicMeterPerHour:
+ return TryConvert(Flow.FromCubicMeterPerHour(value), toUnit, out newValue);
+
+ default:
+ newValue = 0;
+ return false;
+ }
+ }
+
+ private static bool TryConvertRevolutions(double value, Unit fromUnit, Unit toUnit, out double newValue)
+ {
+ switch (fromUnit)
+ {
+ case Unit.RevolutionsPerSecond:
+ return TryConvert(Revolution.FromRevolutionsPerSecond(value), toUnit, out newValue);
+ case Unit.RevolutionsPerMinute:
+ return TryConvert(Revolution.FromRevolutionsPerMinute(value), toUnit, out newValue);
+
+ default:
+ newValue = 0;
+ return false;
+ }
+ }
+
+ private static bool TryConvert(Length l, Unit toUnit, out double newValue)
{
switch (toUnit)
{
@@ -585,6 +621,12 @@ private static bool TryConvert(Pressure p, Unit toUnit, out double newValue)
case Unit.KiloPascal:
newValue = p.KiloPascals;
return true;
+ case Unit.MegaPascal:
+ newValue = p.MegaPascals;
+ return true;
+ case Unit.KilogramForcePerSquareCentimeter:
+ newValue = p.KilogramForcePerSquareCentimeter;
+ return true;
case Unit.Psi:
newValue = p.Psi;
return true;
@@ -702,5 +744,39 @@ private static bool TryConvert(TimeSpan t, Unit toUnit, out double newValue)
return false;
}
}
+
+ private static bool TryConvert(Flow p, Unit toUnit, out double newValue)
+ {
+ switch (toUnit)
+ {
+ case Unit.CubicMeterPerSecond:
+ newValue = p.CubicMeterPerSecond;
+ return true;
+ case Unit.CubicMeterPerHour:
+ newValue = p.CubicMeterPerHour;
+ return true;
+
+ default:
+ newValue = 0;
+ return false;
+ }
+ }
+
+ private static bool TryConvert(Revolution p, Unit toUnit, out double newValue)
+ {
+ switch (toUnit)
+ {
+ case Unit.RevolutionsPerSecond:
+ newValue = p.RevolutionsPerSecond;
+ return true;
+ case Unit.RevolutionsPerMinute:
+ newValue = p.RevolutionsPerMinute;
+ return true;
+
+ default:
+ newValue = 0;
+ return false;
+ }
+ }
}
}
\ No newline at end of file
diff --git a/Src/UnitsNet/UnitSystem.cs b/Src/UnitsNet/UnitSystem.cs
index 2ab5ae5a47..7c8ee0dade 100644
--- a/Src/UnitsNet/UnitSystem.cs
+++ b/Src/UnitsNet/UnitSystem.cs
@@ -62,8 +62,10 @@ private UnitSystem(CultureInfo cultureInfo = null)
CreateUsEnglish();
else if (cultureInfo.Name == "nb-NO")
CreateNorwegianBokmaal();
+ else if (cultureInfo.Name == "ru-RU")
+ CreateRussian();
else
- throw new ArgumentException("Expected only Norwegian Bokmål, US English and invariant cultures.");
+ throw new ArgumentException("Expected only Russian, Norwegian Bokmål, US English and invariant cultures.");
}
///
@@ -137,40 +139,210 @@ private void CreateNorwegianBokmaal()
MapUnitToAbbreviation(Unit.Piece, "stk", "stk.");
}
+ private void CreateRussian()
+ {
+ // Note: For units with multiple abbreviations, the first one is used in GetDefaultAbbreviation().
+ MapUnitToAbbreviation(Unit.Undefined, "(нет ед.изм.)");
+
+ // Length
+ MapUnitToAbbreviation(Unit.Kilometer, "км");
+ MapUnitToAbbreviation(Unit.Meter, "м");
+ MapUnitToAbbreviation(Unit.Decimeter, "дм");
+ MapUnitToAbbreviation(Unit.Centimeter, "см");
+ MapUnitToAbbreviation(Unit.Millimeter, "мм");
+ MapUnitToAbbreviation(Unit.Micrometer, "мкм");
+ MapUnitToAbbreviation(Unit.Nanometer, "нм");
+
+ // Masses
+ MapUnitToAbbreviation(Unit.Megatonne, "Мт");
+ MapUnitToAbbreviation(Unit.Kilotonne, "кт");
+ MapUnitToAbbreviation(Unit.Tonne, "т");
+ MapUnitToAbbreviation(Unit.Kilogram, "кг");
+ MapUnitToAbbreviation(Unit.Hectogram, "гг");
+ MapUnitToAbbreviation(Unit.Decagram, "даг");
+ MapUnitToAbbreviation(Unit.Gram, "г");
+ MapUnitToAbbreviation(Unit.Decigram, "дг");
+ MapUnitToAbbreviation(Unit.Centigram, "сг");
+ MapUnitToAbbreviation(Unit.Milligram, "мг");
+
+ // Pressures
+ MapUnitToAbbreviation(Unit.Pascal, "Па");
+ MapUnitToAbbreviation(Unit.KiloPascal, "кПа");
+ MapUnitToAbbreviation(Unit.MegaPascal, "МПа");
+ MapUnitToAbbreviation(Unit.KilogramForcePerSquareCentimeter, "кгс/см²");
+ MapUnitToAbbreviation(Unit.Psi, "psi");
+ MapUnitToAbbreviation(Unit.NewtonPerSquareCentimeter, "Н/см²");
+ MapUnitToAbbreviation(Unit.NewtonPerSquareMillimeter, "Н/мм²");
+ MapUnitToAbbreviation(Unit.NewtonPerSquareMeter, "Н/м²");
+ MapUnitToAbbreviation(Unit.Bar, "бар");
+ MapUnitToAbbreviation(Unit.TechnicalAtmosphere, "ат");
+ MapUnitToAbbreviation(Unit.Atmosphere, "атм");
+ MapUnitToAbbreviation(Unit.Torr, "торр");
+
+ // Forces
+ MapUnitToAbbreviation(Unit.Kilonewton, "кН");
+ MapUnitToAbbreviation(Unit.Newton, "Н");
+ MapUnitToAbbreviation(Unit.KilogramForce, "кгс");
+ MapUnitToAbbreviation(Unit.Dyn, "дин");
+
+ // Area
+ MapUnitToAbbreviation(Unit.SquareKilometer, "км²");
+ MapUnitToAbbreviation(Unit.SquareMeter, "м²");
+ MapUnitToAbbreviation(Unit.SquareDecimeter, "дм²");
+ MapUnitToAbbreviation(Unit.SquareCentimeter, "см²");
+ MapUnitToAbbreviation(Unit.SquareMillimeter, "мм²");
+
+ // Angle
+ MapUnitToAbbreviation(Unit.Degree, "°");
+ MapUnitToAbbreviation(Unit.Radian, "рад");
+ MapUnitToAbbreviation(Unit.Gradian, "g");
+
+ // Volumes
+ MapUnitToAbbreviation(Unit.CubicKilometer, "км³");
+ MapUnitToAbbreviation(Unit.CubicMeter, "м³");
+ MapUnitToAbbreviation(Unit.CubicDecimeter, "дм³");
+ MapUnitToAbbreviation(Unit.CubicCentimeter, "см³");
+ MapUnitToAbbreviation(Unit.CubicMillimeter, "мм³");
+ MapUnitToAbbreviation(Unit.Hectoliter, "гл");
+ MapUnitToAbbreviation(Unit.Liter, "л");
+ MapUnitToAbbreviation(Unit.Deciliter, "дл");
+ MapUnitToAbbreviation(Unit.Centiliter, "сл");
+ MapUnitToAbbreviation(Unit.Milliliter, "мл");
+
+ // Torque
+ MapUnitToAbbreviation(Unit.Newtonmeter, "Н·м");
+
+ // Generic / Other
+ MapUnitToAbbreviation(Unit.Piece, "штук");
+ MapUnitToAbbreviation(Unit.Percent, "%");
+
+ // Electric potential
+ MapUnitToAbbreviation(Unit.Volt, "В");
+
+ // Times
+ MapUnitToAbbreviation(Unit.Nanosecond, "нс");
+ MapUnitToAbbreviation(Unit.Microsecond, "мкс");
+ MapUnitToAbbreviation(Unit.Millisecond, "мс");
+ MapUnitToAbbreviation(Unit.Second, "с");
+ MapUnitToAbbreviation(Unit.Minute, "мин");
+ MapUnitToAbbreviation(Unit.Hour, "ч");
+ MapUnitToAbbreviation(Unit.Day, "д");
+
+ // Cooking units
+ MapUnitToAbbreviation(Unit.Tablespoon, "столовая ложка");
+ MapUnitToAbbreviation(Unit.Teaspoon, "чайная ложка");
+
+ // Flow
+ MapUnitToAbbreviation(Unit.CubicMeterPerSecond, "м³/с");
+ MapUnitToAbbreviation(Unit.CubicMeterPerHour, "м³/ч");
+
+ // Revolution
+ MapUnitToAbbreviation(Unit.RevolutionsPerSecond, "об/с");
+ MapUnitToAbbreviation(Unit.RevolutionsPerMinute, "об/мин");
+ }
+
private void CreateCultureInvariants()
{
// For correct abbreviations, see: http://lamar.colostate.edu/~hillger/correct.htm
// Note: For units with multiple abbreviations, the first one is used in GetDefaultAbbreviation().
MapUnitToAbbreviation(Unit.Undefined, "(no unit)");
- // Masses
- MapUnitToAbbreviation(Unit.Kilogram, "kg");
- MapUnitToAbbreviation(Unit.Hectogram, "hg");
- MapUnitToAbbreviation(Unit.Gram, "g");
- MapUnitToAbbreviation(Unit.Milligram, "mg");
-
- // Forces
- MapUnitToAbbreviation(Unit.Kilonewton, "kN");
- MapUnitToAbbreviation(Unit.Newton, "N");
-
- // Torque
- MapUnitToAbbreviation(Unit.Newtonmeter, "Nm");
-
- // Distances
- MapUnitToAbbreviation(Unit.Meter, "m");
- MapUnitToAbbreviation(Unit.Centimeter, "cm");
- MapUnitToAbbreviation(Unit.Millimeter, "mm");
-
- // Volumes
- MapUnitToAbbreviation(Unit.Liter, "l", "L");
- MapUnitToAbbreviation(Unit.Deciliter, "dl", "dL");
- MapUnitToAbbreviation(Unit.Centiliter, "cl", "cL");
- MapUnitToAbbreviation(Unit.Milliliter, "ml", "mL");
-
- // Other units
- MapUnitToAbbreviation(Unit.Volt, "V");
- MapUnitToAbbreviation(Unit.Percent, "%");
- MapUnitToAbbreviation(Unit.Second, "s");
+ // Length
+ MapUnitToAbbreviation(Unit.Kilometer, "km");
+ MapUnitToAbbreviation(Unit.Meter, "m");
+ MapUnitToAbbreviation(Unit.Decimeter, "dm");
+ MapUnitToAbbreviation(Unit.Centimeter, "cm");
+ MapUnitToAbbreviation(Unit.Millimeter, "mm");
+ MapUnitToAbbreviation(Unit.Micrometer, "μm");
+ MapUnitToAbbreviation(Unit.Nanometer, "nm");
+
+ // Masses
+ MapUnitToAbbreviation(Unit.Megatonne, "Mt");
+ MapUnitToAbbreviation(Unit.Kilotonne, "kt");
+ MapUnitToAbbreviation(Unit.Tonne, "t");
+ MapUnitToAbbreviation(Unit.Kilogram, "kg");
+ MapUnitToAbbreviation(Unit.Hectogram, "hg");
+ MapUnitToAbbreviation(Unit.Decagram, "dag");
+ MapUnitToAbbreviation(Unit.Gram, "g");
+ MapUnitToAbbreviation(Unit.Decigram, "dg");
+ MapUnitToAbbreviation(Unit.Centigram, "cg");
+ MapUnitToAbbreviation(Unit.Milligram, "mg");
+
+ // Pressures
+ MapUnitToAbbreviation(Unit.Pascal, "Pa");
+ MapUnitToAbbreviation(Unit.KiloPascal, "kPa");
+ MapUnitToAbbreviation(Unit.MegaPascal, "MPa");
+ MapUnitToAbbreviation(Unit.KilogramForcePerSquareCentimeter, "kgf/cm²");
+ MapUnitToAbbreviation(Unit.Psi, "psi");
+ MapUnitToAbbreviation(Unit.NewtonPerSquareCentimeter, "N/cm²");
+ MapUnitToAbbreviation(Unit.NewtonPerSquareMillimeter, "N/mm²");
+ MapUnitToAbbreviation(Unit.NewtonPerSquareMeter, "N/m²");
+ MapUnitToAbbreviation(Unit.Bar, "bar");
+ MapUnitToAbbreviation(Unit.TechnicalAtmosphere, "at");
+ MapUnitToAbbreviation(Unit.Atmosphere, "atm");
+ MapUnitToAbbreviation(Unit.Torr, "Torr");
+
+ // Forces
+ MapUnitToAbbreviation(Unit.Kilonewton, "kN");
+ MapUnitToAbbreviation(Unit.Newton, "N");
+ MapUnitToAbbreviation(Unit.KilogramForce, "kgf");
+ MapUnitToAbbreviation(Unit.Dyn, "dyn");
+
+ // Area
+ MapUnitToAbbreviation(Unit.SquareKilometer, "km²");
+ MapUnitToAbbreviation(Unit.SquareMeter, "m²");
+ MapUnitToAbbreviation(Unit.SquareDecimeter, "dm²");
+ MapUnitToAbbreviation(Unit.SquareCentimeter, "cm²");
+ MapUnitToAbbreviation(Unit.SquareMillimeter, "mm²");
+
+ // Angle
+ MapUnitToAbbreviation(Unit.Degree, "°");
+ MapUnitToAbbreviation(Unit.Radian, "rad");
+ MapUnitToAbbreviation(Unit.Gradian, "g");
+
+ // Volumes
+ MapUnitToAbbreviation(Unit.CubicKilometer, "km³");
+ MapUnitToAbbreviation(Unit.CubicMeter, "m³");
+ MapUnitToAbbreviation(Unit.CubicDecimeter, "dm³");
+ MapUnitToAbbreviation(Unit.CubicCentimeter, "cm³");
+ MapUnitToAbbreviation(Unit.CubicMillimeter, "mm³");
+ MapUnitToAbbreviation(Unit.Hectoliter, "hl");
+ MapUnitToAbbreviation(Unit.Liter, "l");
+ MapUnitToAbbreviation(Unit.Deciliter, "dl");
+ MapUnitToAbbreviation(Unit.Centiliter, "cl");
+ MapUnitToAbbreviation(Unit.Milliliter, "ml");
+
+ // Torque
+ MapUnitToAbbreviation(Unit.Newtonmeter, "N·m");
+
+ // Generic / Other
+ MapUnitToAbbreviation(Unit.Piece, "piece");
+ MapUnitToAbbreviation(Unit.Percent, "%");
+
+ // Electric potential
+ MapUnitToAbbreviation(Unit.Volt, "V");
+
+ // Times
+ MapUnitToAbbreviation(Unit.Nanosecond, "ns");
+ MapUnitToAbbreviation(Unit.Microsecond, "μs");
+ MapUnitToAbbreviation(Unit.Millisecond, "ms");
+ MapUnitToAbbreviation(Unit.Second, "s");
+ MapUnitToAbbreviation(Unit.Minute, "min");
+ MapUnitToAbbreviation(Unit.Hour, "h");
+ MapUnitToAbbreviation(Unit.Day, "d");
+ MapUnitToAbbreviation(Unit.Week, "week");
+
+ // Cooking units
+ MapUnitToAbbreviation(Unit.Tablespoon, "tbsp.");
+ MapUnitToAbbreviation(Unit.Teaspoon, "tsp.");
+
+ // Flow
+ MapUnitToAbbreviation(Unit.CubicMeterPerSecond, "m³/s");
+ MapUnitToAbbreviation(Unit.CubicMeterPerHour, "m³/h");
+
+ // Revolution
+ MapUnitToAbbreviation(Unit.RevolutionsPerSecond, "r/s");
+ MapUnitToAbbreviation(Unit.RevolutionsPerMinute, "r/min");
}
private void MapUnitToAbbreviation(Unit unit, params string[] abbreviations)
diff --git a/Src/UnitsNet/UnitsNet.net35.csproj b/Src/UnitsNet/UnitsNet.net35.csproj
index 6aeea05311..e81b796927 100644
--- a/Src/UnitsNet/UnitsNet.net35.csproj
+++ b/Src/UnitsNet/UnitsNet.net35.csproj
@@ -40,8 +40,10 @@
+
+
diff --git a/Src/UnitsNet/UnitsNet.netcore45.csproj b/Src/UnitsNet/UnitsNet.netcore45.csproj
index f1395edf5f..10713b4e54 100644
--- a/Src/UnitsNet/UnitsNet.netcore45.csproj
+++ b/Src/UnitsNet/UnitsNet.netcore45.csproj
@@ -97,8 +97,10 @@
+
+
diff --git a/Src/UnitsNet/UnitsNet.pcl.csproj b/Src/UnitsNet/UnitsNet.pcl.csproj
index 251638f06c..d16b4d7306 100644
--- a/Src/UnitsNet/UnitsNet.pcl.csproj
+++ b/Src/UnitsNet/UnitsNet.pcl.csproj
@@ -37,8 +37,10 @@
+
+
diff --git a/Src/UnitsNet/UnitsNet.sl4.csproj b/Src/UnitsNet/UnitsNet.sl4.csproj
index a9e8d9b1b3..ddce04d66a 100644
--- a/Src/UnitsNet/UnitsNet.sl4.csproj
+++ b/Src/UnitsNet/UnitsNet.sl4.csproj
@@ -58,7 +58,9 @@
+
+
diff --git a/Tests/FlowTests.cs b/Tests/FlowTests.cs
new file mode 100644
index 0000000000..48e92d9afd
--- /dev/null
+++ b/Tests/FlowTests.cs
@@ -0,0 +1,124 @@
+using System;
+using NUnit.Framework;
+
+namespace UnitsNet.Tests.net35
+{
+ [TestFixture]
+ public class FlowTests
+ {
+ private const double Delta = 1E-5;
+
+ [Test]
+ public void CubicMeterPerSecondToFlowUnits()
+ {
+ Flow cms = Flow.FromCubicMeterPerSecond(1);
+
+ Assert.AreEqual(1/3600.0, cms.CubicMeterPerHour, Delta);
+ Assert.AreEqual(1, cms.CubicMeterPerSecond);
+ }
+
+ [Test]
+ public void FlowUnitsRoundTrip()
+ {
+ Flow cms = Flow.FromCubicMeterPerSecond(1);
+
+ Assert.AreEqual(1, Flow.FromCubicMeterPerSecond(cms.CubicMeterPerSecond).CubicMeterPerSecond, Delta);
+ Assert.AreEqual(1, Flow.FromCubicMeterPerHour(cms.CubicMeterPerHour).CubicMeterPerSecond, Delta);
+ }
+
+ [Test]
+ public void ArithmeticOperators()
+ {
+ Flow v = Flow.FromCubicMeterPerSecond(1);
+ Assert.AreEqual(-1, -v.CubicMeterPerSecond, Delta);
+ Assert.AreEqual(2, (Flow.FromCubicMeterPerSecond(3) - v).CubicMeterPerSecond, Delta);
+ Assert.AreEqual(2, (v + v).CubicMeterPerSecond, Delta);
+ Assert.AreEqual(10, (v * 10).CubicMeterPerSecond, Delta);
+ Assert.AreEqual(10, (10 * v).CubicMeterPerSecond, Delta);
+ Assert.AreEqual(2, (Flow.FromCubicMeterPerSecond(10) / 5).CubicMeterPerSecond, Delta);
+ Assert.AreEqual(2, Flow.FromCubicMeterPerSecond(10) / Flow.FromCubicMeterPerSecond(5), Delta);
+ }
+
+ [Test]
+ public void ComparisonOperators()
+ {
+ Flow oneMeter = Flow.FromCubicMeterPerSecond(1);
+ Flow twoMeters = Flow.FromCubicMeterPerSecond(2);
+
+ Assert.True(oneMeter < twoMeters);
+ Assert.True(oneMeter <= twoMeters);
+ Assert.True(twoMeters > oneMeter);
+ Assert.True(twoMeters >= oneMeter);
+
+ Assert.False(oneMeter > twoMeters);
+ Assert.False(oneMeter >= twoMeters);
+ Assert.False(twoMeters < oneMeter);
+ Assert.False(twoMeters <= oneMeter);
+ }
+
+ [Test]
+ public void CompareToIsImplemented()
+ {
+ Flow meter = Flow.FromCubicMeterPerSecond(1);
+ Assert.AreEqual(0, meter.CompareTo(meter));
+ Assert.Greater(meter.CompareTo(Flow.Zero), 0);
+ Assert.Less(Flow.Zero.CompareTo(meter), 0);
+ }
+
+ [Test]
+ [ExpectedException(typeof(ArgumentException))]
+ public void CompareToThrowsOnTypeMismatch()
+ {
+ Flow meter = Flow.FromCubicMeterPerSecond(1);
+ // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+ meter.CompareTo(new object());
+ }
+
+ [Test]
+ [ExpectedException(typeof(ArgumentNullException))]
+ public void CompareToThrowsOnNull()
+ {
+ Flow meter = Flow.FromCubicMeterPerSecond(1);
+ // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+ meter.CompareTo(null);
+ }
+
+
+ [Test]
+ public void EqualityOperators()
+ {
+ Flow a = Flow.FromCubicMeterPerSecond(1);
+ Flow b = Flow.FromCubicMeterPerSecond(2);
+
+ // ReSharper disable EqualExpressionComparison
+ Assert.True(a == a);
+ Assert.True(a != b);
+
+ Assert.False(a == b);
+ Assert.False(a != a);
+ // ReSharper restore EqualExpressionComparison
+ }
+
+ [Test]
+ public void EqualsIsImplemented()
+ {
+ Flow v = Flow.FromCubicMeterPerSecond(1);
+ Assert.IsTrue(v.Equals(Flow.FromCubicMeterPerSecond(1)));
+ Assert.IsFalse(v.Equals(Flow.Zero));
+ }
+
+ [Test]
+ public void EqualsReturnsFalseOnTypeMismatch()
+ {
+ Flow meter = Flow.FromCubicMeterPerSecond(1);
+ Assert.IsFalse(meter.Equals(new object()));
+ }
+
+ [Test]
+ public void EqualsReturnsFalseOnNull()
+ {
+ Flow meter = Flow.FromCubicMeterPerSecond(1);
+ Assert.IsFalse(meter.Equals(null));
+ }
+ }
+}
diff --git a/Tests/PressureTests.cs b/Tests/PressureTests.cs
index ac9d76c11b..489c5fa647 100644
--- a/Tests/PressureTests.cs
+++ b/Tests/PressureTests.cs
@@ -17,6 +17,8 @@ public void PascalToPressureUnits()
Assert.AreEqual(9.8692*1E-6, pa.Atmosphere, Delta);
Assert.AreEqual(1E-5, pa.Bars, Delta);
Assert.AreEqual(1E-3, pa.KiloPascals);
+ Assert.AreEqual(1E-6, pa.MegaPascals);
+ Assert.AreEqual(1/98066.5, pa.KilogramForcePerSquareCentimeter);
Assert.AreEqual(1E-4, pa.NewtonsPerSquareCentimeter, Delta);
Assert.AreEqual(1E-6, pa.NewtonsPerSquareMillimeter, Delta);
Assert.AreEqual(1, pa.NewtonsPerSquareMeter, Delta);
@@ -34,6 +36,8 @@ public void PressureUnitsRoundTrip()
Assert.AreEqual(1, Pressure.FromAtmosphere(pa.Atmosphere).Pascals, Delta);
Assert.AreEqual(1, Pressure.FromBars(pa.Bars).Pascals, Delta);
Assert.AreEqual(1, Pressure.FromKiloPascals(pa.KiloPascals).Pascals, Delta);
+ Assert.AreEqual(1, Pressure.FromMegaPascals(pa.MegaPascals).Pascals, Delta);
+ Assert.AreEqual(1, Pressure.FromKilogramForcePerSquareCentimeter(pa.KilogramForcePerSquareCentimeter).Pascals, Delta);
Assert.AreEqual(1, Pressure.FromNewtonsPerSquareCentimeter(pa.NewtonsPerSquareCentimeter).Pascals, Delta);
Assert.AreEqual(1, Pressure.FromNewtonsPerSquareMeter(pa.NewtonsPerSquareMeter).Pascals, Delta);
Assert.AreEqual(1, Pressure.FromNewtonsPerSquareMillimeter(pa.NewtonsPerSquareMillimeter).Pascals, Delta);
diff --git a/Tests/RevolutionTests.cs b/Tests/RevolutionTests.cs
new file mode 100644
index 0000000000..ef1799297a
--- /dev/null
+++ b/Tests/RevolutionTests.cs
@@ -0,0 +1,124 @@
+using System;
+using NUnit.Framework;
+
+namespace UnitsNet.Tests.net35
+{
+ [TestFixture]
+ public class RevolutionTests
+ {
+ private const double Delta = 1E-5;
+
+ [Test]
+ public void CubicMeterPerSecondToRevolutionUnits()
+ {
+ Revolution cms = Revolution.FromRevolutionsPerSecond(1);
+
+ Assert.AreEqual(60.0, cms.RevolutionsPerMinute, Delta);
+ Assert.AreEqual(1, cms.RevolutionsPerSecond);
+ }
+
+ [Test]
+ public void RevolutionUnitsRoundTrip()
+ {
+ Revolution cms = Revolution.FromRevolutionsPerSecond(1);
+
+ Assert.AreEqual(1, Revolution.FromRevolutionsPerSecond(cms.RevolutionsPerSecond).RevolutionsPerSecond, Delta);
+ Assert.AreEqual(1, Revolution.FromRevolutionsPerMinute(cms.RevolutionsPerMinute).RevolutionsPerSecond, Delta);
+ }
+
+ [Test]
+ public void ArithmeticOperators()
+ {
+ Revolution v = Revolution.FromRevolutionsPerSecond(1);
+ Assert.AreEqual(-1, -v.RevolutionsPerSecond, Delta);
+ Assert.AreEqual(2, (Revolution.FromRevolutionsPerSecond(3) - v).RevolutionsPerSecond, Delta);
+ Assert.AreEqual(2, (v + v).RevolutionsPerSecond, Delta);
+ Assert.AreEqual(10, (v * 10).RevolutionsPerSecond, Delta);
+ Assert.AreEqual(10, (10 * v).RevolutionsPerSecond, Delta);
+ Assert.AreEqual(2, (Revolution.FromRevolutionsPerSecond(10) / 5).RevolutionsPerSecond, Delta);
+ Assert.AreEqual(2, Revolution.FromRevolutionsPerSecond(10) / Revolution.FromRevolutionsPerSecond(5), Delta);
+ }
+
+ [Test]
+ public void ComparisonOperators()
+ {
+ Revolution oneMeter = Revolution.FromRevolutionsPerSecond(1);
+ Revolution twoMeters = Revolution.FromRevolutionsPerSecond(2);
+
+ Assert.True(oneMeter < twoMeters);
+ Assert.True(oneMeter <= twoMeters);
+ Assert.True(twoMeters > oneMeter);
+ Assert.True(twoMeters >= oneMeter);
+
+ Assert.False(oneMeter > twoMeters);
+ Assert.False(oneMeter >= twoMeters);
+ Assert.False(twoMeters < oneMeter);
+ Assert.False(twoMeters <= oneMeter);
+ }
+
+ [Test]
+ public void CompareToIsImplemented()
+ {
+ Revolution meter = Revolution.FromRevolutionsPerSecond(1);
+ Assert.AreEqual(0, meter.CompareTo(meter));
+ Assert.Greater(meter.CompareTo(Revolution.Zero), 0);
+ Assert.Less(Revolution.Zero.CompareTo(meter), 0);
+ }
+
+ [Test]
+ [ExpectedException(typeof(ArgumentException))]
+ public void CompareToThrowsOnTypeMismatch()
+ {
+ Revolution meter = Revolution.FromRevolutionsPerSecond(1);
+ // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+ meter.CompareTo(new object());
+ }
+
+ [Test]
+ [ExpectedException(typeof(ArgumentNullException))]
+ public void CompareToThrowsOnNull()
+ {
+ Revolution meter = Revolution.FromRevolutionsPerSecond(1);
+ // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+ meter.CompareTo(null);
+ }
+
+
+ [Test]
+ public void EqualityOperators()
+ {
+ Revolution a = Revolution.FromRevolutionsPerSecond(1);
+ Revolution b = Revolution.FromRevolutionsPerSecond(2);
+
+ // ReSharper disable EqualExpressionComparison
+ Assert.True(a == a);
+ Assert.True(a != b);
+
+ Assert.False(a == b);
+ Assert.False(a != a);
+ // ReSharper restore EqualExpressionComparison
+ }
+
+ [Test]
+ public void EqualsIsImplemented()
+ {
+ Revolution v = Revolution.FromRevolutionsPerSecond(1);
+ Assert.IsTrue(v.Equals(Revolution.FromRevolutionsPerSecond(1)));
+ Assert.IsFalse(v.Equals(Revolution.Zero));
+ }
+
+ [Test]
+ public void EqualsReturnsFalseOnTypeMismatch()
+ {
+ Revolution meter = Revolution.FromRevolutionsPerSecond(1);
+ Assert.IsFalse(meter.Equals(new object()));
+ }
+
+ [Test]
+ public void EqualsReturnsFalseOnNull()
+ {
+ Revolution meter = Revolution.FromRevolutionsPerSecond(1);
+ Assert.IsFalse(meter.Equals(null));
+ }
+ }
+}
diff --git a/Tests/UnitConverterTests.cs b/Tests/UnitConverterTests.cs
index 2c5a1095ba..7d2ccdce45 100644
--- a/Tests/UnitConverterTests.cs
+++ b/Tests/UnitConverterTests.cs
@@ -102,8 +102,17 @@ public void PascalToPressureUnits()
Assert.AreEqual(1.450377*1E-4, UnitConverter.Convert(1, Unit.Pascal, Unit.Psi), Delta);
Assert.AreEqual(1.0197*1E-5, UnitConverter.Convert(1, Unit.Pascal, Unit.TechnicalAtmosphere), Delta);
Assert.AreEqual(7.5006*1E-3, UnitConverter.Convert(1, Unit.Pascal, Unit.Torr), Delta);
+ Assert.AreEqual(1E-6, UnitConverter.Convert(1, Unit.Pascal, Unit.MegaPascal), Delta);
+ Assert.AreEqual(1/98066.5, UnitConverter.Convert(1, Unit.Pascal, Unit.KilogramForcePerSquareCentimeter), Delta);
}
+ [Test]
+ public void CubicMeterPerSecondToFlowUnits()
+ {
+ Assert.AreEqual(1, UnitConverter.Convert(1, Unit.CubicMeterPerSecond, Unit.CubicMeterPerSecond), Delta);
+ Assert.AreEqual(1/3600.0, UnitConverter.Convert(1, Unit.CubicMeterPerSecond, Unit.CubicMeterPerHour), Delta);
+ }
+
[Test]
public void ThrowsOnIncompatibleUnits()
{
@@ -113,7 +122,9 @@ public void ThrowsOnIncompatibleUnits()
Assert.Throws(() => UnitConverter.Convert(1, Unit.Newton, Unit.Second));
Assert.Throws(() => UnitConverter.Convert(1, Unit.Pascal, Unit.Second));
Assert.Throws(() => UnitConverter.Convert(1, Unit.Kilogram, Unit.Second));
- Assert.Throws(() => UnitConverter.Convert(1, Unit.Degree, Unit.Second));
+ Assert.Throws(() => UnitConverter.Convert(1, Unit.Degree, Unit.Second));
+ Assert.Throws(() => UnitConverter.Convert(1, Unit.CubicMeterPerSecond, Unit.Second));
+ Assert.Throws(() => UnitConverter.Convert(1, Unit.RevolutionsPerSecond, Unit.Second));
}
[Test]
@@ -128,7 +139,9 @@ public void TryConvertReturnsFalseOnIncompatibleUnits()
Assert.False(UnitConverter.TryConvert(1, Unit.Newton, Unit.Second, out newValue));
Assert.False(UnitConverter.TryConvert(1, Unit.Pascal, Unit.Second, out newValue));
Assert.False(UnitConverter.TryConvert(1, Unit.Kilogram, Unit.Second, out newValue));
- Assert.False(UnitConverter.TryConvert(1, Unit.Degree, Unit.Second, out newValue));
+ Assert.False(UnitConverter.TryConvert(1, Unit.Degree, Unit.Second, out newValue));
+ Assert.False(UnitConverter.TryConvert(1, Unit.CubicMeterPerSecond, Unit.Second, out newValue));
+ Assert.False(UnitConverter.TryConvert(1, Unit.RevolutionsPerSecond, Unit.Second, out newValue));
// Assert to-unit cases. One for each class of unit.
Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.Meter, out newValue));
@@ -137,7 +150,9 @@ public void TryConvertReturnsFalseOnIncompatibleUnits()
Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.Newton, out newValue));
Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.Pascal, out newValue));
Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.Kilogram, out newValue));
- Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.Degree, out newValue));
+ Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.Degree, out newValue));
+ Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.CubicMeterPerSecond, out newValue));
+ Assert.False(UnitConverter.TryConvert(1, Unit.Second, Unit.RevolutionsPerSecond, out newValue));
}
[Test]
@@ -152,7 +167,9 @@ public void TryConvertReturnsTrueOnCompatibleUnits()
Assert.True(UnitConverter.TryConvert(1, Unit.Newton, Unit.KilogramForce, out newValue));
Assert.True(UnitConverter.TryConvert(1, Unit.Pascal, Unit.KiloPascal, out newValue));
Assert.True(UnitConverter.TryConvert(1, Unit.Kilogram, Unit.Gram, out newValue));
- Assert.True(UnitConverter.TryConvert(1, Unit.Degree, Unit.Radian, out newValue));
+ Assert.True(UnitConverter.TryConvert(1, Unit.Degree, Unit.Radian, out newValue));
+ Assert.True(UnitConverter.TryConvert(1, Unit.CubicMeterPerSecond, Unit.CubicMeterPerHour, out newValue));
+ Assert.True(UnitConverter.TryConvert(1, Unit.RevolutionsPerSecond, Unit.RevolutionsPerMinute, out newValue));
// Assert to-unit cases. One for each class of unit.
Assert.True(UnitConverter.TryConvert(1, Unit.Centimeter, Unit.Meter, out newValue));
@@ -161,7 +178,8 @@ public void TryConvertReturnsTrueOnCompatibleUnits()
Assert.True(UnitConverter.TryConvert(1, Unit.KilogramForce, Unit.Newton, out newValue));
Assert.True(UnitConverter.TryConvert(1, Unit.KiloPascal, Unit.Pascal, out newValue));
Assert.True(UnitConverter.TryConvert(1, Unit.Gram, Unit.Kilogram, out newValue));
- Assert.True(UnitConverter.TryConvert(1, Unit.Radian, Unit.Degree, out newValue));
+ Assert.True(UnitConverter.TryConvert(1, Unit.CubicMeterPerHour, Unit.CubicMeterPerSecond, out newValue));
+ Assert.True(UnitConverter.TryConvert(1, Unit.RevolutionsPerMinute, Unit.RevolutionsPerSecond, out newValue));
}
}
}
diff --git a/Tests/UnitValueTests.cs b/Tests/UnitValueTests.cs
index aa36ba7314..5773423f8b 100644
--- a/Tests/UnitValueTests.cs
+++ b/Tests/UnitValueTests.cs
@@ -16,6 +16,8 @@ public void TryConvertReturnsFalseOnIncompatibleUnits()
Assert.False(new UnitValue(1, Unit.Pascal).TryConvert(Unit.Second, out newValue));
Assert.False(new UnitValue(1, Unit.Kilogram).TryConvert(Unit.Second, out newValue));
Assert.False(new UnitValue(1, Unit.Degree).TryConvert(Unit.Second, out newValue));
+ Assert.False(new UnitValue(1, Unit.CubicMeterPerSecond).TryConvert(Unit.Second, out newValue));
+ Assert.False(new UnitValue(1, Unit.RevolutionsPerSecond).TryConvert(Unit.Second, out newValue));
}
}
}
diff --git a/Tests/UnitsNet.Tests.net35.csproj b/Tests/UnitsNet.Tests.net35.csproj
index e48adfa777..00cf5ce0d7 100644
--- a/Tests/UnitsNet.Tests.net35.csproj
+++ b/Tests/UnitsNet.Tests.net35.csproj
@@ -9,7 +9,7 @@
Properties
UnitsNet.Tests.net35
UnitsNet.Tests.net35
- v4.5
+ v4.0
512
..\Src\
true
@@ -46,6 +46,8 @@
+
+