public void VerifyAllEnums()
{
var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit);
var angle = new Angle(1, AngleUnit.BaseUnit);
var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit);
var area = new Area(1, AreaUnit.BaseUnit);
var density = new MassDensity(1, MassDensityUnit.BaseUnit);
var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit);
var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit);
var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit);
var energy = new Energy(1, EnergyUnit.BaseUnit);
var force = new Force(1, ForceUnit.BaseUnit);
var frequency = new Frequency(1, FrequencyUnit.BaseUnit);
var jerk = new Jerk(1, JerkUnit.BaseUnit);
var length = new Length(1, LengthUnit.BaseUnit);
var mass = new Mass(1, MassUnit.BaseUnit);
var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit);
var momentum = new Momentum(1, MomentumUnit.BaseUnit);
var numeric = new Numeric(1, NumericUnit.BaseUnit);
var power = new Power(1, PowerUnit.BaseUnit);
var pressure = new Pressure(1, PressureUnit.BaseUnit);
var speed = new Speed(1, SpeedUnit.BaseUnit);
var temperature = new Temperature(1, TemperatureUnit.BaseUnit);
var time = new Time(1, TimeUnit.BaseUnit);
var torque = new Torque(1, TorqueUnit.BaseUnit);
var volume = new Volume(1, VolumeUnit.BaseUnit);
var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit);
}
public void OpAddition()
{
var resistance1 = new ElectricResistance(3000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(1, ElectricResistanceUnit.Kiloohm);
var expected = new ElectricResistance(4000, ElectricResistanceUnit.Ohm);
(resistance1 + resistance2).ShouldEqual(expected);
(resistance2 + resistance1).ShouldEqual(expected);
}
public void OpDivision()
{
var resistance1 = new ElectricResistance(2000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(2, ElectricResistanceUnit.Kiloohm);
(resistance1 / resistance2).ShouldBeWithinEpsilonOf(1);
(resistance2 / resistance1).ShouldBeWithinEpsilonOf(1);
(resistance1 / 2).ShouldEqual(new ElectricResistance(1000, ElectricResistanceUnit.Ohm));
(resistance2 / 2).ShouldEqual(new ElectricResistance(1, ElectricResistanceUnit.Kiloohm));
}
public void OpGreaterThanOrEqual()
{
var resistance1 = new ElectricResistance(3000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(3, ElectricResistanceUnit.Kiloohm);
var resistance3 = new ElectricResistance(4, ElectricResistanceUnit.Kiloohm);
(resistance1 >= resistance3).ShouldBeFalse();
(resistance3 >= resistance1).ShouldBeTrue();
(resistance1 >= resistance2).ShouldBeTrue();
(resistance2 >= resistance1).ShouldBeTrue();
}
public void OpInverseEquals()
{
var resistance1 = new ElectricResistance(3000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(3, ElectricResistanceUnit.Kiloohm);
var resistance3 = new ElectricResistance(4, ElectricResistanceUnit.Kiloohm);
(resistance1 != resistance2).ShouldBeFalse();
(resistance2 != resistance1).ShouldBeFalse();
(resistance1 != resistance3).ShouldBeTrue();
(resistance3 != resistance1).ShouldBeTrue();
}
public void OpEquals()
{
var resistance1 = new ElectricResistance(3000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(3, ElectricResistanceUnit.Kiloohm);
var resistance3 = new ElectricResistance(4, ElectricResistanceUnit.Kiloohm);
(resistance1 == resistance2).ShouldBeTrue();
(resistance2 == resistance1).ShouldBeTrue();
(resistance1 == resistance3).ShouldBeFalse();
(resistance3 == resistance1).ShouldBeFalse();
resistance1.Equals(resistance2)
.ShouldBeTrue();
resistance1.Equals((object)resistance2)
.ShouldBeTrue();
resistance2.Equals(resistance1)
.ShouldBeTrue();
resistance2.Equals((object)resistance1)
.ShouldBeTrue();
}
/// <summary>
/// Gets a <see cref="AmplitudeRatio" /> from a <see cref="PowerRatio" />.
/// </summary>
/// <param name="powerRatio">The power ratio.</param>
/// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
/// <remarks>http://www.maximintegrated.com/en/app-notes/index.mvp/id/808</remarks>
public static AmplitudeRatio ToAmplitudeRatio(PowerRatio powerRatio, ElectricResistance impedance)
{
// E(dBV) = 10*log10(Z(Ω)/1) + P(dBW)
return AmplitudeRatio.FromDecibelVolts(10*Math.Log10(impedance.Ohms/1) + powerRatio.DecibelWatts);
}
public void Convert_ToDecimal_EqualsValueAsSameType()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity));
}
/// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" /> public static ElectricResistance Milliohms(this decimal value) => ElectricResistance.FromMilliohms(Convert.ToDouble(value));
/// <inheritdoc cref="ElectricResistance.FromOhms(UnitsNet.QuantityValue)" /> public static ElectricResistance?Ohms(this int?value) => ElectricResistance.FromOhms(value);
public void ElectricCurrentTimesElectricResistanceEqualsElectricPotential(float current, float resistance, float expected)
{
ElectricPotential potential = ElectricCurrent.FromAmperes(current) * ElectricResistance.FromOhms(resistance);
Assert.Equal(expected, potential.Volts);
}
/// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" /> public static ElectricResistance Milliohms(this double value) => ElectricResistance.FromMilliohms(value);
public void Convert_ChangeType_UnitType_EqualsUnit()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(ElectricResistanceUnit)));
}
public void EqualsReturnsFalseOnTypeMismatch()
{
ElectricResistance ohm = ElectricResistance.FromOhms(1);
Assert.False(ohm.Equals(new object()));
}
public void Convert_ToUInt64_EqualsValueAsSameType()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
}
public void Convert_ChangeType_SelfType_EqualsSelf()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(ElectricResistance)));
}
public void Convert_ToString_EqualsToString()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
}
public void Convert_ToSingle_EqualsValueAsSameType()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
}
public void Convert_ToInt32_EqualsValueAsSameType()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
}
public void ToString_NullProvider_EqualsCurrentUICulture()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
}
public void Convert_ChangeType_QuantityType_EqualsQuantityType()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(QuantityType.ElectricResistance, Convert.ChangeType(quantity, typeof(QuantityType)));
}
/// <summary>
/// Gets the conversion function for the upper resistor of a voltage divider.
/// </summary>
/// <param name="lowerResistorValue">The lower resistor value.</param>
/// <returns>
/// The function.
/// </returns>
public static Func<AnalogValue, ElectricResistance> ForUpperResistor(ElectricResistance lowerResistorValue)
{
return v => v.Relative != 0
? lowerResistorValue * (double)((1 - v.Relative) / v.Relative)
: ElectricResistance.FromOhms(double.MaxValue);
}
public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(ElectricResistance.Info, Convert.ChangeType(quantity, typeof(QuantityInfo)));
}
public void EqualsReturnsFalseOnNull()
{
ElectricResistance ohm = ElectricResistance.FromOhms(1);
Assert.False(ohm.Equals(null));
}
public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(ElectricResistance.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
}
/// <inheritdoc cref="ElectricResistance.FromMegaohms(UnitsNet.QuantityValue)" /> public static ElectricResistance Megaohms(this float value) => ElectricResistance.FromMegaohms(value);
public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
}
/// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" /> public static ElectricResistance?Milliohms(this float?value) => ElectricResistance.FromMilliohms(value);
public void GetHashCode_Equals()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Equal(new { ElectricResistance.Info.Name, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
}
/// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" /> public static ElectricResistance?Milliohms(this decimal?value) => ElectricResistance.FromMilliohms(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void ToBaseUnit_ReturnsQuantityWithBaseUnit()
{
var quantityInBaseUnit = ElectricResistance.FromOhms(1).ToBaseUnit();
Assert.Equal(ElectricResistance.BaseUnit, quantityInBaseUnit.Unit);
}
public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException()
{
var v = ElectricResistance.FromOhms(1);
Assert.Throws <ArgumentOutOfRangeException>(() => v.Equals(ElectricResistance.FromOhms(1), -1, ComparisonType.Relative));
}
public void OpSubtraction()
{
var resistance1 = new ElectricResistance(7000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(1, ElectricResistanceUnit.Kiloohm);
(resistance1 - resistance2).ShouldEqual(new ElectricResistance(6000, ElectricResistanceUnit.Ohm));
(resistance2 - resistance1).ShouldEqual(new ElectricResistance(-6, ElectricResistanceUnit.Kiloohm));
}
/// <summary>
/// Gets a <see cref="AmplitudeRatio" /> from a <see cref="PowerRatio" />.
/// </summary>
/// <param name="powerRatio">The power ratio.</param>
/// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
public static AmplitudeRatio ToAmplitudeRatio(this PowerRatio powerRatio, ElectricResistance impedance)
{
return PowerRatio.ToAmplitudeRatio(powerRatio, impedance);
}
public void Convert_ToDateTime_ThrowsInvalidCastException()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity));
}
public void OpMultiplicationScaler()
{
var resistance = new ElectricResistance(1, ElectricResistanceUnit.Ohm);
var expected = new ElectricResistance(2, ElectricResistanceUnit.Ohm);
(resistance * 2).ShouldEqual(expected);
(2 * resistance).ShouldEqual(expected);
}
/// <summary>
/// Converts a <see cref="AmplitudeRatio"/> to a <see cref="PowerRatio"/>.
/// </summary>
/// <param name="amplitudeRatio">The amplitude ratio to convert.</param>
/// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
/// <remarks>http://www.maximintegrated.com/en/app-notes/index.mvp/id/808</remarks>
public static PowerRatio ToPowerRatio(AmplitudeRatio amplitudeRatio, ElectricResistance impedance)
{
// P(dBW) = E(dBV) - 10*log10(Z(Ω)/1)
return PowerRatio.FromDecibelWatts(amplitudeRatio.DecibelVolts - 10 * Math.Log10(impedance.Ohms / 1));
}
public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
{
var quantity = ElectricResistance.FromOhms(value);
Assert.Equal(ElectricResistance.FromOhms(-value), -quantity);
}
public void ToString_NullArgs_ThrowsArgumentNullException()
{
var quantity = ElectricResistance.FromOhms(1.0);
Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null));
}
/// <summary>
/// Converts a <see cref="AmplitudeRatio" /> to a <see cref="PowerRatio" />.
/// </summary>
/// <param name="amplitudeRatio">The amplitude ratio to convert.</param>
/// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
/// <remarks>http://www.maximintegrated.com/en/app-notes/index.mvp/id/808</remarks>
public static PowerRatio ToPowerRatio(this AmplitudeRatio amplitudeRatio, ElectricResistance impedance)
{
return(AmplitudeRatio.ToPowerRatio(amplitudeRatio, impedance));
}
public void CompareToThrowsOnTypeMismatch()
{
ElectricResistance ohm = ElectricResistance.FromOhms(1);
Assert.Throws <ArgumentException>(() => ohm.CompareTo(new object()));
}
public void OpLessThan()
{
var resistance1 = new ElectricResistance(3000, ElectricResistanceUnit.Ohm);
var resistance2 = new ElectricResistance(3, ElectricResistanceUnit.Kiloohm);
var resistance3 = new ElectricResistance(4, ElectricResistanceUnit.Kiloohm);
(resistance1 < resistance3).ShouldBeTrue();
(resistance3 < resistance1).ShouldBeFalse();
(resistance1 < resistance2).ShouldBeFalse();
(resistance2 < resistance1).ShouldBeFalse();
}
public void CompareToThrowsOnNull()
{
ElectricResistance ohm = ElectricResistance.FromOhms(1);
Assert.Throws <ArgumentNullException>(() => ohm.CompareTo(null));
}
/// <summary>
/// Converts a <see cref="AmplitudeRatio"/> to a <see cref="PowerRatio"/>.
/// </summary>
/// <param name="amplitudeRatio">The amplitude ratio to convert.</param>
/// <param name="impedance">The input impedance of the load. This is usually 50, 75 or 600 ohms.</param>
/// <remarks>http://www.maximintegrated.com/en/app-notes/index.mvp/id/808</remarks>
public static PowerRatio ToPowerRatio(this AmplitudeRatio amplitudeRatio, ElectricResistance impedance)
{
return AmplitudeRatio.ToPowerRatio(amplitudeRatio, impedance);
}
/// <summary>
/// Gets the conversion function for the lower resistor of a voltage divider.
/// </summary>
/// <param name="upperResistorValue">The upper resistor value.</param>
/// <returns>
/// The function.
/// </returns>
public static Func<AnalogValue, ElectricResistance> ForLowerResistor(ElectricResistance upperResistorValue)
{
return v => v.Relative != 1
? upperResistorValue * (double)(v.Relative / (1 - v.Relative))
: ElectricResistance.FromOhms(double.MaxValue);
}
