Ejemplo n.º 1
0
        public void Equals_RelativeTolerance_IsImplemented()
        {
            var v = SpecificLength.FromMeterPerGrams(1);

            Assert.True(v.Equals(SpecificLength.FromMeterPerGrams(1), MeterPerGramsTolerance, ComparisonType.Relative));
            Assert.False(v.Equals(SpecificLength.Zero, MeterPerGramsTolerance, ComparisonType.Relative));
        }
Ejemplo n.º 2
0
        public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
        {
            var quantity = new SpecificLength();

            Assert.Equal(0, quantity.Value);
            Assert.Equal(SpecificLengthUnit.MeterPerGram, quantity.Unit);
        }
Ejemplo n.º 3
0
        public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
        {
            var quantity00 = SpecificLength.From(1, SpecificLengthUnit.MeterPerGram);

            AssertEx.EqualTolerance(1, quantity00.MeterPerGrams, MeterPerGramsTolerance);
            Assert.Equal(SpecificLengthUnit.MeterPerGram, quantity00.Unit);
        }
Ejemplo n.º 4
0
        public void Equals_SameType_IsImplemented()
        {
            var a = SpecificLength.FromMeterPerGrams(1);
            var b = SpecificLength.FromMeterPerGrams(2);

            Assert.True(a.Equals(a));
            Assert.False(a.Equals(b));
        }
Ejemplo n.º 5
0
        public void CompareToIsImplemented()
        {
            SpecificLength meterpergram = SpecificLength.FromMeterPerGrams(1);

            Assert.Equal(0, meterpergram.CompareTo(meterpergram));
            Assert.True(meterpergram.CompareTo(SpecificLength.Zero) > 0);
            Assert.True(SpecificLength.Zero.CompareTo(meterpergram) < 0);
        }
Ejemplo n.º 6
0
        public void SpecificLength_Ctor_SetExpectedLength_LengthSet()
        {
            const int length = 123;

            SpecificLength specificLength = new SpecificLength(length);

            Assert.AreEqual(length, specificLength.ExpectedLength);
        }
Ejemplo n.º 7
0
        public void Equals_QuantityAsObject_IsImplemented()
        {
            object a = SpecificLength.FromMeterPerGrams(1);
            object b = SpecificLength.FromMeterPerGrams(2);

            Assert.True(a.Equals(a));
            Assert.False(a.Equals(b));
            Assert.False(a.Equals((object)null));
        }
Ejemplo n.º 8
0
        public void SpecificLength_AssertString_LengthDoesNotMatch_Error(int length, string value)
        {
            SpecificLength specificLength = new SpecificLength(length);

            var exception = Assert.Throws <Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException>(()
                                                                                                               => specificLength.Assert(_testFramework, value, "Custom message"));

            Assert.AreEqual($"Assert.AreEqual failed. Expected:<{length}>. Actual:<{value?.Length ?? 0}>. Custom message has an unexpected length", exception.Message);
        }
Ejemplo n.º 9
0
        public void ToUnit()
        {
            var meterpergram = SpecificLength.FromMeterPerGrams(1);

            var meterpergramQuantity = meterpergram.ToUnit(SpecificLengthUnit.MeterPerGram);

            AssertEx.EqualTolerance(MeterPerGramsInOneMeterPerGram, (double)meterpergramQuantity.Value, MeterPerGramsTolerance);
            Assert.Equal(SpecificLengthUnit.MeterPerGram, meterpergramQuantity.Unit);
        }
Ejemplo n.º 10
0
        public void ArithmeticOperators()
        {
            SpecificLength v = SpecificLength.FromMeterPerGrams(1);

            AssertEx.EqualTolerance(-1, -v.MeterPerGrams, MeterPerGramsTolerance);
            AssertEx.EqualTolerance(2, (SpecificLength.FromMeterPerGrams(3) - v).MeterPerGrams, MeterPerGramsTolerance);
            AssertEx.EqualTolerance(2, (v + v).MeterPerGrams, MeterPerGramsTolerance);
            AssertEx.EqualTolerance(10, (v * 10).MeterPerGrams, MeterPerGramsTolerance);
            AssertEx.EqualTolerance(10, (10 * v).MeterPerGrams, MeterPerGramsTolerance);
            AssertEx.EqualTolerance(2, (SpecificLength.FromMeterPerGrams(10) / 5).MeterPerGrams, MeterPerGramsTolerance);
            AssertEx.EqualTolerance(2, SpecificLength.FromMeterPerGrams(10) / SpecificLength.FromMeterPerGrams(5), MeterPerGramsTolerance);
        }
Ejemplo n.º 11
0
        public void ComparisonOperators()
        {
            SpecificLength oneMeterPerGram  = SpecificLength.FromMeterPerGrams(1);
            SpecificLength twoMeterPerGrams = SpecificLength.FromMeterPerGrams(2);

            Assert.True(oneMeterPerGram < twoMeterPerGrams);
            Assert.True(oneMeterPerGram <= twoMeterPerGrams);
            Assert.True(twoMeterPerGrams > oneMeterPerGram);
            Assert.True(twoMeterPerGrams >= oneMeterPerGram);

            Assert.False(oneMeterPerGram > twoMeterPerGrams);
            Assert.False(oneMeterPerGram >= twoMeterPerGrams);
            Assert.False(twoMeterPerGrams < oneMeterPerGram);
            Assert.False(twoMeterPerGrams <= oneMeterPerGram);
        }
Ejemplo n.º 12
0
        public void EqualityOperators()
        {
            var a = SpecificLength.FromMeterPerGrams(1);
            var b = SpecificLength.FromMeterPerGrams(2);

            // ReSharper disable EqualExpressionComparison

            Assert.True(a == a);
            Assert.False(a != a);

            Assert.True(a != b);
            Assert.False(a == b);

            Assert.False(a == null);
            Assert.False(null == a);

// ReSharper restore EqualExpressionComparison
        }
Ejemplo n.º 13
0
        public void SpecificLength_QuantityInfo_ReturnsQuantityInfoDescribingQuantity()
        {
            var quantity = new SpecificLength(1, SpecificLengthUnit.MeterPerGram);

            QuantityInfo <SpecificLengthUnit> quantityInfo = quantity.QuantityInfo;

            Assert.Equal(SpecificLength.Zero, quantityInfo.Zero);
            Assert.Equal("SpecificLength", quantityInfo.Name);
            Assert.Equal(QuantityType.SpecificLength, quantityInfo.QuantityType);

            var units     = EnumUtils.GetEnumValues <SpecificLengthUnit>().Except(new[] { SpecificLengthUnit.Undefined }).ToArray();
            var unitNames = units.Select(x => x.ToString());

            // Obsolete members
#pragma warning disable 618
            Assert.Equal(units, quantityInfo.Units);
            Assert.Equal(unitNames, quantityInfo.UnitNames);
#pragma warning restore 618
        }
Ejemplo n.º 14
0
        public void Convert_ChangeType_UnitType_EqualsUnit()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(SpecificLengthUnit)));
        }
 public static SpecificLength MeterPerGrams <T>(this T value) =>
 SpecificLength.FromMeterPerGrams(Convert.ToDouble(value));
Ejemplo n.º 16
0
        public void GetHashCode_Equals()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(new { SpecificLength.QuantityType, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
        }
Ejemplo n.º 17
0
        public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
        {
            var quantity = SpecificLength.FromMeterPerGrams(value);

            Assert.Equal(SpecificLength.FromMeterPerGrams(-value), -quantity);
        }
Ejemplo n.º 18
0
        public void ToString_NullArgs_ThrowsArgumentNullException()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Throws <ArgumentNullException>(() => quantity.ToString(null, "g", null));
        }
Ejemplo n.º 19
0
        public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
        }
Ejemplo n.º 20
0
        public void EqualsReturnsFalseOnNull()
        {
            SpecificLength meterpergram = SpecificLength.FromMeterPerGrams(1);

            Assert.False(meterpergram.Equals(null));
        }
Ejemplo n.º 21
0
        public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(SpecificLength.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
        }
Ejemplo n.º 22
0
        public void Convert_ChangeType_SelfType_EqualsSelf()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(SpecificLength)));
        }
Ejemplo n.º 23
0
        public void SpecificLength_AssertString_LengthMatches_NoError(int length, string value)
        {
            SpecificLength specificLength = new SpecificLength(length);

            Assert.DoesNotThrow(() => specificLength.Assert(_testFramework, value, "Custom message"));
        }
Ejemplo n.º 24
0
        public void Convert_ToUInt64_EqualsValueAsSameType()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
        }
Ejemplo n.º 25
0
        public void ToString_NullProvider_EqualsCurrentUICulture()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g"));
        }
Ejemplo n.º 26
0
        public void Convert_ToSingle_EqualsValueAsSameType()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity));
        }
Ejemplo n.º 27
0
        public void Convert_ToInt32_EqualsValueAsSameType()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity));
        }
Ejemplo n.º 28
0
        public void Convert_ToDateTime_ThrowsInvalidCastException()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Throws <InvalidCastException>(() => Convert.ToDateTime(quantity));
        }
Ejemplo n.º 29
0
        public void Convert_ToString_EqualsToString()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
        }
Ejemplo n.º 30
0
        public void Convert_ChangeType_QuantityType_EqualsQuantityType()
        {
            var quantity = SpecificLength.FromMeterPerGrams(1.0);

            Assert.Equal(QuantityType.SpecificLength, Convert.ChangeType(quantity, typeof(QuantityType)));
        }