public void RaizCuadrada()
        {
            CalculadoraSimple cal       = new CalculadoraSimple();
            double            resultado = cal.raizcuadrada(9);

            Assert.AreEqual(3, resultado);
        }
        public void SumarDigitoCadenasVacias()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.sumar("", "");

            Assert.AreEqual(0, resultado);
        }
        public void Potencias()
        {
            CalculadoraSimple cal       = new CalculadoraSimple();
            double            resultado = cal.potencia(10, 2);

            Assert.AreEqual(100, resultado);
        }
        public void DividirSeisVivididoEnDosTres()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.dividir(6, 2);

            Assert.AreEqual(3, resultado);
        }
        public void MultiplicarDosPorDosIgualCuatro()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.multiplicar(2, 2);

            Assert.AreEqual(4, resultado);
        }
        public void RestaDosMenosUnoIgualUno()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.restar(2, 1);

            Assert.AreEqual(1, resultado);
        }
        public void Residuo()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.residuo(5, 2);

            Assert.AreEqual(1, resultado);
        }
        public void MultiplicarCero()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.multiplicarceroC(0, 4);

            Assert.AreEqual(0, resultado);
        }
        public void SumarDosMasIgualCuatro()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.sumar(2, 2);

            Assert.AreEqual(4, resultado);
        }
Esempio n. 10
0
        public void SumarDosDigitosCaracter()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultados        = cal.suma("1", "1");

            Assert.AreEqual(2, resultados);
        }
Esempio n. 11
0
        public void ResultadoDeUnaPotencia()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            double resultado = cal.Potencia(8, 2);

            Assert.AreEqual(64, resultado);
        }
Esempio n. 12
0
        public void RaizCuadradaDeDosNumeros()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            double resultado = cal.RaizCuadrada(49);

            Assert.AreEqual(7, resultado);
        }
Esempio n. 13
0
        public void MultiplicarDosNumeros2()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            int resultado = cal.Multiplicacion2(5, 0);

            Assert.AreEqual(0, resultado);
        }
Esempio n. 14
0
        public void SumarDosDigitosTipoCaracterCero()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            int resultado = cal.SumaChar2(" ", " ");

            Assert.AreEqual(0, resultado);
        }
Esempio n. 15
0
        public void SumaDosDigitosTipoCaracter()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            int resultado = cal.SumaChar("4", "2");

            Assert.AreEqual(6, resultado);
        }
Esempio n. 16
0
        public void ResiduoDivision()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            double resultado = cal.Residuo(7, 3);

            Assert.AreEqual(1, resultado);
        }
Esempio n. 17
0
        public void RedondearDecimal()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            double resultado = cal.Redondear(7, 2);

            Assert.AreEqual(Math.Round(3.5), resultado);
        }
Esempio n. 18
0
        public void SumaNumerica()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            int resultado = cal.Suma(1, 1);

            Assert.AreEqual(2, resultado);
        }
Esempio n. 19
0
        public void DividirDosNumeros()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            int resultado = cal.Division(9, 3);

            Assert.AreEqual(3, resultado);
        }
Esempio n. 20
0
        public void RestarDosNumeros()
        {
            CalculadoraSimple cal = new CalculadoraSimple();

            int resultado = cal.Resta(3, 1);

            Assert.AreEqual(2, resultado);
        }
        public void MultiplicarTresPorCero()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.Multiplicar(0, 2);

            Assert.AreEqual(0, resultado);
            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void SumarDosMasDosIgualCuatro()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.Sumar(2, 2);

            Assert.AreEqual(4, resultado);
            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void RestarTresMenosUno()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.Restar(3, 1);

            Assert.AreEqual(2, resultado);

            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void SumarCaracteres()
        {
            CalculadoraSimple calcu = new CalculadoraSimple();
            int resultado           = calcu.Sumar("1", "2");

            Assert.AreEqual(3, resultado);

            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void RaizCuadrada()
        {
            CalculadoraSimple cal       = new CalculadoraSimple();
            double            resultado = cal.Raiz(4);

            Assert.AreEqual(2, resultado);

            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void Potencias()
        {
            CalculadoraSimple cal       = new CalculadoraSimple();
            double            resultado = cal.Elevar(2, 2);

            Assert.AreEqual(4, resultado);

            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void ResiduoDeDivisiones()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.Residuo(5, 4);

            Assert.AreEqual(1, resultado);

            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void DividirSeisEnDos()
        {
            CalculadoraSimple cal = new CalculadoraSimple();
            int resultado         = cal.Dividir(6, 2);

            Assert.AreEqual(3, resultado);

            if ((resultado) >= 0)
            {
                Console.WriteLine("El Resultado es : " + resultado);
            }
            else
            {
                Console.WriteLine("Esta Incorrecto");
            }
        }
        public void RedondeoDeDivisiones()
        {
            CalculadoraSimple cal       = new CalculadoraSimple();
            double            resultado = cal.Redondeo(7, 4);
            double            a         = resultado;


            Assert.AreEqual(1, 2, resultado);

            if (a < 0.5)
            {
                Console.WriteLine("Su resultado es elevado hacia abajo :" + Math.Round(a));
            }
            else if (a >= 0.5)
            {
                Console.WriteLine("Su Resultado es elevado hacia arriba :" + Math.Ceiling(a));
            }
        }
Esempio n. 30
0
        static void Main(string[] args)
        {
            #region Prueba1

            //CalculadoraSimple cs = new CalculadoraSimple();
            //cs.Ejecuta(new Operacion('+', 2));
            //cs.Ejecuta(new Operacion('+', 3));
            //cs.Ejecuta(new Operacion('*', 10));
            //Console.WriteLine(cs.ResultadoActual()); //imprime 50
            //cs.Undo();
            //Console.WriteLine(cs.ResultadoActual()); //imprime 5
            //cs.Undo();
            //Console.WriteLine(cs.ResultadoActual()); //imprime 2
            //cs.Redo();
            //Console.WriteLine(cs.ResultadoActual()); //imprime 5



            #endregion
            #region Prueba2
            //CalculadoraSimple cs = new CalculadoraSimple();
            //cs.Ejecuta(new Operacion('*', 0)); //operacion 1
            //Console.WriteLine(cs.ResultadoActual()); // imprime 0
            //cs.Ejecuta(new Operacion('/', 5)); //operacion 2
            //Console.WriteLine(cs.ResultadoActual()); // imprime 0
            //cs.Ejecuta(new Operacion('+', 10)); //operacion 3
            //cs.Ejecuta(new Operacion('+', 10)); //operacion 4
            //cs.Ejecuta(new Operacion('+', 10)); //operacion 5
            //cs.Ejecuta(new Operacion('+', 10)); //operacion 6
            //Console.WriteLine(cs.ResultadoActual()); // imprime 40
            //cs.Undo(); //des-hace la opereación 6
            //Console.WriteLine(cs.ResultadoActual()); // imprime 30
            //cs.Ejecuta(new Operacion('+', 5)); //operacion 7
            //cs.Redo(); //sin efecto pq la instrucción inmediata anterior no fue "Undo"
            //Console.WriteLine(cs.ResultadoActual()); // imprime 35
            //cs.Undo(); //des-hace la opereación 7
            //cs.Undo(); //des-hace la opereación 5 (la operacion 6 ya había sido des-hecha)
            //Console.WriteLine(cs.ResultadoActual()); // imprime 20
            //cs.Redo(); //re-hace la operacion 5
            //cs.Redo(); //re-hace la operacion 7
            //cs.Redo(); //sin efecto porque solo se habían hecho dos Undo inmediatamente antes
            //Console.WriteLine(cs.ResultadoActual()); // imprime 35 //Note que en este caso la operacion 6 fue des-hecha y no interviene en el resultado
            //foreach (var operacion in cs.OperacionesEfectivas())
            //{
            //    Console.WriteLine(operacion);
            //}
            ////Note que la operación 6 no se considera efectiva (fue deshecha y no se rehízo)
            ////Esto imprime las operaciones 1, 2, 3, 4, 5 y 7, es decir se escribiría
            //// (* 0) // (/ 5) // (+ 10) // (+ 10) // (+ 10)// (+,5)



            #endregion
            #region Prueba3

            CalculadoraSimple cs = new CalculadoraSimple();
            cs.Ejecuta(new Operacion('+', 5));       //operacion 1
            cs.Undo();                               //des-hace la operacion 1
            cs.Undo();                               //sin efecto, no existen instrucciones efectivas
            Console.WriteLine(cs.ResultadoActual()); //imprime 0
            cs.Ejecuta(new Operacion('/', 0));       //lanza DivideByZeroException



            #endregion
        }