Beispiel #1
0
        public void MinOrValue_NegativeInt_ReturnsMinIntValue()
        {
            const int NEGATIVE_VALUE = -1;
            IGenericValueComparer <int> intValueComparer = CreateIntValueComparer();

            int returnValue = intValueComparer.MinOrValue(NEGATIVE_VALUE);

            Assert.AreEqual(returnValue, MIN_INT_VALUE);
        }
Beispiel #2
0
        public void MinOrValue_ZeroInt_ReturnsMinIntValue()
        {
            const int ZERO_VALUE = 0;
            IGenericValueComparer <int> intValueComparer = CreateIntValueComparer();

            int returnValue = intValueComparer.MinOrValue(ZERO_VALUE);

            Assert.AreEqual(returnValue, MIN_INT_VALUE);
        }
Beispiel #3
0
        public void MinOrValue_LowerValueFourthCharacter_ReturnsMinStringValue()
        {
            const string LOWER_VALUE_STRING = "moo ";
            IGenericValueComparer <string> stringValueComparer = CreateStringValueComparer();

            string returnValue = stringValueComparer.MinOrValue(LOWER_VALUE_STRING);

            Assert.AreEqual(returnValue, MIN_STRING_VALUE);
        }
Beispiel #4
0
        public void MinOrValue_PositiveFloat_ReturnsSameValue()
        {
            const float POSITIVE_VALUE = 12.1F;
            IGenericValueComparer <float> floatValueComparer = CreateFloatValueComparer();

            float returnValue = floatValueComparer.MinOrValue(POSITIVE_VALUE);

            Assert.AreEqual(returnValue, POSITIVE_VALUE);
        }
Beispiel #5
0
        public void MinOrValue_EqualValueFloat_ReturnsSameValue()
        {
            const float EQUAL_VALUE = 11.1F;
            IGenericValueComparer <float> floatValueComparer = CreateFloatValueComparer();

            float returnValue = floatValueComparer.MinOrValue(EQUAL_VALUE);

            Assert.AreEqual(returnValue, EQUAL_VALUE);
        }
Beispiel #6
0
        public void MinOrValue_NegativeFloat_ReturnsMinFloatValue()
        {
            const float NEGATIVE_VALUE = -1.0F;
            IGenericValueComparer <float> floatValueComparer = CreateFloatValueComparer();

            float returnValue = floatValueComparer.MinOrValue(NEGATIVE_VALUE);

            Assert.AreEqual(returnValue, MIN_FLOAT_VALUE);
        }
Beispiel #7
0
        public void MinOrValue_ZeroFloat_ReturnsMinFloatValue()
        {
            const float ZERO_VALUE = 0.0F;
            IGenericValueComparer <float> floatValueComparer = CreateFloatValueComparer();

            float returnValue = floatValueComparer.MinOrValue(ZERO_VALUE);

            Assert.AreEqual(returnValue, MIN_FLOAT_VALUE);
        }
Beispiel #8
0
        public void MinOrValue_EqualValueDecimal_ReturnsSameValue()
        {
            const decimal EQUAL_VALUE = 10.1M;
            IGenericValueComparer <decimal> decimalValueComparer = CreateDecimalValueComparer();

            decimal returnValue = decimalValueComparer.MinOrValue(EQUAL_VALUE);

            Assert.AreEqual(returnValue, EQUAL_VALUE);
        }
Beispiel #9
0
        public void MinOrValue_PositiveDecimal_ReturnsSameValue()
        {
            const decimal POSITIVE_VALUE = 22.1M;
            IGenericValueComparer <decimal> decimalValueComparer = CreateDecimalValueComparer();

            decimal returnValue = decimalValueComparer.MinOrValue(POSITIVE_VALUE);

            Assert.AreEqual(returnValue, POSITIVE_VALUE);
        }
Beispiel #10
0
        public void MinOrValue_ZeroDecimal_ReturnsMinDecimalValue()
        {
            const decimal ZERO_VALUE = 0.0M;
            IGenericValueComparer <decimal> decimalValueComparer = CreateDecimalValueComparer();

            decimal returnValue = decimalValueComparer.MinOrValue(ZERO_VALUE);

            Assert.AreEqual(returnValue, MIN_DECIMAL_VALUE);
        }
Beispiel #11
0
        public void MinOrValue_HigherValueFourthCharacter_ReturnsSameValue()
        {
            const string HIGHER_VALUE_STRING = "moo\"";
            IGenericValueComparer <string> stringValueComparer = CreateStringValueComparer();

            string returnValue = stringValueComparer.MinOrValue(HIGHER_VALUE_STRING);

            Assert.AreEqual(returnValue, HIGHER_VALUE_STRING);
        }
Beispiel #12
0
        public void MinOrValue_EqualValueString_ReturnsSameValue()
        {
            const string SAME_VALUE_STRING = "moo!";
            IGenericValueComparer <string> stringValueComparer = CreateStringValueComparer();

            string returnValue = stringValueComparer.MinOrValue(SAME_VALUE_STRING);

            Assert.AreEqual(returnValue, SAME_VALUE_STRING);
        }
Beispiel #13
0
        public void MinOrValue_EqualValueLong_ReturnsSameValue()
        {
            const long EQUAL_VALUE = 10L;
            IGenericValueComparer <long> longValueComparer = CreateLongValueComparer();

            long returnValue = longValueComparer.MinOrValue(EQUAL_VALUE);

            Assert.AreEqual(returnValue, EQUAL_VALUE);
        }
Beispiel #14
0
        public void MinOrValue_PositiveLong_ReturnsSameValue()
        {
            const long POSITIVE_VALUE = 12L;
            IGenericValueComparer <long> longValueComparer = CreateLongValueComparer();

            long returnValue = longValueComparer.MinOrValue(POSITIVE_VALUE);

            Assert.AreEqual(returnValue, POSITIVE_VALUE);
        }
Beispiel #15
0
        public void MinOrValue_NegativeDecimal_ReturnsMinDecimalValue()
        {
            const decimal NEGATIVE_VALUE = -1.0M;
            IGenericValueComparer <decimal> decimalValueComparer = CreateDecimalValueComparer();

            decimal returnValue = decimalValueComparer.MinOrValue(NEGATIVE_VALUE);

            Assert.AreEqual(returnValue, MIN_DECIMAL_VALUE);
        }
Beispiel #16
0
        public void MinOrValue_NegativeLong_ReturnsMinLongValue()
        {
            const long NEGATIVE_VALUE = -1L;
            IGenericValueComparer <long> longValueComparer = CreateLongValueComparer();

            long returnValue = longValueComparer.MinOrValue(NEGATIVE_VALUE);

            Assert.AreEqual(returnValue, MIN_LONG_VALUE);
        }
Beispiel #17
0
        public void MinOrValue_ZeroLong_ReturnsMinLongValue()
        {
            const long ZERO_VALUE = 0L;
            IGenericValueComparer <long> longValueComparer = CreateLongValueComparer();

            long returnValue = longValueComparer.MinOrValue(ZERO_VALUE);

            Assert.AreEqual(returnValue, MIN_LONG_VALUE);
        }
Beispiel #18
0
        public void MinOrValue_EqualValueInt_ReturnsSameValue()
        {
            const int EQUAL_VALUE = 1;
            IGenericValueComparer <int> intValueComparer = CreateIntValueComparer();

            int returnValue = intValueComparer.MinOrValue(EQUAL_VALUE);

            Assert.AreEqual(returnValue, EQUAL_VALUE);
        }
Beispiel #19
0
        public void MinOrValue_PositiveInt_ReturnsSameValue()
        {
            const int POSITIVE_VALUE = 2;
            IGenericValueComparer <int> intValueComparer = CreateIntValueComparer();

            int returnValue = intValueComparer.MinOrValue(POSITIVE_VALUE);

            Assert.AreEqual(returnValue, POSITIVE_VALUE);
        }
Beispiel #20
0
        public void MinOrValue_HigerValueAge_ReturnsSameValue()
        {
            var higherValueAge = new TestComparable()
            {
                Name = "B",
                Age  = 3
            };

            IGenericValueComparer <TestComparable> stringValueComparer = CreateTestComparableComparer();

            TestComparable returnValue = stringValueComparer.MinOrValue(higherValueAge);

            Assert.AreEqual(returnValue, higherValueAge);
        }
Beispiel #21
0
        public void MinOrValue_SameValueAgeAndName_ReturnsSameValue()
        {
            var sameValueComparable = new TestComparable()
            {
                Name = "B",
                Age  = 2
            };

            IGenericValueComparer <TestComparable> stringValueComparer = CreateTestComparableComparer();

            TestComparable returnValue = stringValueComparer.MinOrValue(sameValueComparable);

            Assert.AreEqual(returnValue, sameValueComparable);
        }
Beispiel #22
0
        public void MinOrValue_LowerValueAge_ReturnsMinTestComparable()
        {
            var lowerValueAgeComparable = new TestComparable()
            {
                Name = "B",
                Age  = 1
            };

            IGenericValueComparer <TestComparable> stringValueComparer = CreateTestComparableComparer();

            TestComparable returnValue = stringValueComparer.MinOrValue(lowerValueAgeComparable);

            Assert.AreEqual(returnValue, MinTestComparableValue);
        }