Ejemplo n.º 1
0
        public void Setup()
        {
            Signed64BitIntegerConversionResult = new Signed64BitIntegerConversionResult();

            ConvertInteger = new ConvertInteger
                                 (Signed64BitIntegerConversionResult);
        }
        public void ConfirmThatNoTextValuesReturnFalse()
        {
            bool ResultActual;

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.IsFalse(ResultActual);
        }
Ejemplo n.º 3
0
        public void IfConvertedValueHasNonNumericIsConvertedEqualsFalse()
        {
            bool IsConvertedExpected = false;
            bool IsConvertedActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("$649594");

            IsConvertedActual = Signed64BitIntegerConversionResult.IsConverted;

            Assert.AreEqual(IsConvertedExpected, IsConvertedActual);
        }
Ejemplo n.º 4
0
        public void IfConvertedValueEqualsFalseWithInvalidValue()
        {
            long Signed64BitIntegerExpected = -1;
            long Signed64BitIntegerActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("#5");

            Signed64BitIntegerActual = Signed64BitIntegerConversionResult.ConvertedValue;

            Assert.AreEqual(Signed64BitIntegerExpected, Signed64BitIntegerActual);
        }
Ejemplo n.º 5
0
        public void IfConvertedValueHasNegitaveOverflowIsConvertedEqualsFalse()
        {
            bool IsConvertedExpected = false;
            bool IsConvertedActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("-9223372036854775809");

            IsConvertedActual = Signed64BitIntegerConversionResult.IsConverted;

            Assert.AreEqual(IsConvertedExpected, IsConvertedActual);
        }
Ejemplo n.º 6
0
        public void IfIsConvertedValueEqualsFalseWithInvalidValue()
        {
            bool IsConvertedExpected = false;
            bool IsConvertedActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("N5000");

            IsConvertedActual = Signed64BitIntegerConversionResult.IsConverted;

            Assert.AreEqual(IsConvertedExpected, IsConvertedActual);
        }
Ejemplo n.º 7
0
        public void IfConvertedValueIsFractionIsConvertedEqualsFalse()
        {
            bool IsConvertedExpected = false;
            bool IsConvertedActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("2.473");

            IsConvertedActual = Signed64BitIntegerConversionResult.IsConverted;

            Assert.AreEqual(IsConvertedExpected, IsConvertedActual);
        }
Ejemplo n.º 8
0
        public void ConvertStringToSigned32BitInteger()
        {
            long Signed64BitIntegerExpected = 10000;
            long Signed64BitIntegerActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("10000");

            Signed64BitIntegerActual = Signed64BitIntegerConversionResult.ConvertedValue;

            Assert.AreEqual(Signed64BitIntegerExpected, Signed64BitIntegerActual);
        }
Ejemplo n.º 9
0
        public void IfConvertedValueHasMinusInWrongPositionIsConvertedEqualsFalse()
        {
            bool IsConvertedExpected = false;
            bool IsConvertedActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("649-594");

            IsConvertedActual = Signed64BitIntegerConversionResult.IsConverted;

            Assert.AreEqual(IsConvertedExpected, IsConvertedActual);
        }
Ejemplo n.º 10
0
        public void IfConvertedValueHasValidLowerBoundsIsConvertedEqualsTrue()
        {
            bool IsConvertedExpected = true;
            bool IsConvertedActual;

            Signed64BitIntegerConversionResult = ConvertInteger.ConvertStringTo64BitSignedInteger("-9223372036854775808");

            IsConvertedActual = Signed64BitIntegerConversionResult.IsConverted;

            Assert.AreEqual(IsConvertedExpected, IsConvertedActual);
        }
        public void ConfirmThatLessThanTwoTextValuesReturnFalse()
        {
            bool ResultActual;

            IntegerStrings.Add("20");

            Integer64ConversionResult = SubtractInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.IsFalse(ResultActual);
        }
        public void ConfirmThatOnlyTwoTextValuesWereEntered()
        {
            bool ResultActual;

            IntegerStrings.Add("20");
            IntegerStrings.Add("30");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.IsTrue(ResultActual);
        }
        public void ConfirmThat10KPlusTwoKIs12K()
        {
            long ResultExpected = 12000;
            long ResultActual;

            IntegerStrings.Add("10000");
            IntegerStrings.Add("2000");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatNegitaveTwoKMinusNegitaveTwoKIsZero()
        {
            long ResultExpected = 0;
            long ResultActual;

            IntegerStrings.Add("-2000");
            IntegerStrings.Add("-2000");

            Integer64ConversionResult = SubtractInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatValidValuesReturnTrue()
        {
            bool ResultExpected = true;
            bool ResultActual;

            IntegerStrings.Add("3");
            IntegerStrings.Add("3");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatOverflowIntegerValuesInEachTextBoxIsNotValid()
        {
            bool ResultExpected = false;
            bool ResultActual;

            IntegerStrings.Add("214748364748364754634");
            IntegerStrings.Add("214748364748364754634");

            Integer64ConversionResult = SubtractInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatMaxNegativeIntegerValuesInEachTextBoxIsNotValid()
        {
            bool ResultExpected = false;
            bool ResultActual;

            IntegerStrings.Add("-2147483648");
            IntegerStrings.Add("-2147483648");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatNegitaveTenMinusTenIsNegativeTwenty()
        {
            long ResultExpected = -20;
            long ResultActual;

            IntegerStrings.Add("-10");
            IntegerStrings.Add("10");

            Integer64ConversionResult = SubtractInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatBlankTextOneValuesReturnfalse()
        {
            bool ResultActual;

            IntegerStrings.Add("");
            IntegerStrings.Add("3");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);
            ResultActual = Integer64ConversionResult.IsConverted;

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.IsFalse(ResultActual);
        }
        public void ConfirmThatnullTextTwoValuesReturnfalse()
        {
            bool ResultActual;

            IntegerStrings.Add("100");
            IntegerStrings.Add(null);

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);
            ResultActual = Integer64ConversionResult.IsConverted;

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.IsFalse(ResultActual);
        }
        public void ConfirmThatInvalidTextOneAndTextTwoValuesReturnfalse()
        {
            bool ResultActual;

            IntegerStrings.Add("3Q");
            IntegerStrings.Add("3f");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);
            ResultActual = Integer64ConversionResult.IsConverted;

            ResultActual = Integer64ConversionResult.IsConverted;

            Assert.IsFalse(ResultActual);
        }
        public void ConfirmThatInvalidTextOneAndTextTwoValuesReturnTextOneExceptionText()
        {
            string ResultExpected = "The value entered into integer one is not valid. Please enter a valid value.";
            string ResultActual;

            IntegerStrings.Add(null);
            IntegerStrings.Add(null);

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ExceptionText;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatTwoPlusTwoIsFour()
        {
            long ResultExpected = 4;
            long ResultActual;

            IntegerStrings.Add("2");
            IntegerStrings.Add("2");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatNegitaveTenPlusTenIsZero()
        {
            long ResultExpected = 0;
            long ResultActual;

            IntegerStrings.Add("-10");
            IntegerStrings.Add("10");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatNegitaveTwoKPlusNegitaveTwoKIsNegitaveFourK()
        {
            long ResultExpected = -4000;
            long ResultActual;

            IntegerStrings.Add("-2000");
            IntegerStrings.Add("-2000");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatOneHundredMinusTenIsNinty()
        {
            long ResultExpected = 90;
            long ResultActual;

            IntegerStrings.Add("100");
            IntegerStrings.Add("10");

            Integer64ConversionResult = SubtractInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatInvalidTextValuesReturnExceptionText()
        {
            string ResultExpected = "Two Values must be entered to add, one value, zero or less values or more than two values were entered.";
            string ResultActual;

            IntegerStrings.Add("20");
            IntegerStrings.Add("40");
            IntegerStrings.Add("60");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ExceptionText;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
        public void ConfirmThatInvalidTextValuesReturnAValueOfNegativeOne()
        {
            long ResultExpected = -1;
            long ResultActual;

            IntegerStrings.Add("50");
            IntegerStrings.Add("40");
            IntegerStrings.Add("60");

            Integer64ConversionResult = AddInteger.Compute(IntegerStrings);

            ResultActual = Integer64ConversionResult.ConvertedValue;

            Assert.AreEqual(ResultExpected, ResultActual);
        }
Ejemplo n.º 29
0
        public string AddIntegers
            (ObservableCollection <string> IntegerStrings)
        {
            if (IntegerStrings != null)
            {
                this.IntegerStrings = IntegerStrings;
            }

            IntegerConversionResult = AddIntegerValues.Compute(IntegerStrings);

            if (IntegerConversionResult.IsConverted == true)
            {
                TotalValue = IntegerConversionResult.ConvertedValue.ToString();
            }

            return(TotalValue);
        }
Ejemplo n.º 30
0
        public Signed64BitIntegerConversionResult Compute(ObservableCollection <string> IntegerStrings)
        {
            if (IntegerStrings != null)
            {
                this.IntegerStrings = IntegerStrings;
            }

            TotalConversionResult.ExceptionText = "";

            TotalConversionResult = ConfirmCountOnCollection();

            if (TotalConversionResult.IsConverted == false)
            {
                IntegerStrings.Clear();
                return(TotalConversionResult);
            }

            TotalConversionResult = ConvertStringValue1();

            if (TotalConversionResult.IsConverted == false)
            {
                IntegerStrings.Clear();
                return(TotalConversionResult);
            }

            TotalConversionResult = ConvertStringValue2();

            if (TotalConversionResult.IsConverted == false)
            {
                IntegerStrings.Clear();
                return(TotalConversionResult);
            }

            TotalConversionResult = AddValues(IntegerStrings);

            if (TotalConversionResult.IsConverted == false)
            {
                IntegerStrings.Clear();
                return(TotalConversionResult);
            }

            return(TotalConversionResult);
        }