// Realizamos la operacion escogida por menu
// Suma = num1 + num2
// Resta = num1 - num2
// Multiplicacion = num1 * num2
// Division = num1/ num2
public static void MostrarResultado(OpcionMenuType op, ICalculadora calcu)
{
Console.WriteLine("Entra valor num1: ");
var num1 = Console.ReadLine();
Console.WriteLine("Entra valor num2: ");
var num2 = Console.ReadLine();
var result = 0;
switch (op)
{
case OpcionMenuType.Suma:
result = calcu.Suma(int.Parse(num1), int.Parse(num2));
break;
case OpcionMenuType.Resta:
result = calcu.Resta(int.Parse(num1), int.Parse(num2));
break;
case OpcionMenuType.Mult:
result = calcu.Multiplicacion(int.Parse(num1), int.Parse(num2));
break;
case OpcionMenuType.Div:
result = calcu.Division(int.Parse(num1), int.Parse(num2));
break;
default:
break;
}
Console.WriteLine("Resultado: " + result);
}
public static void ClassInitializeMethod(TestContext context)
{
calculadora = new Calculadora();
//calculadora = new CalculadoraCientifica();
// calculadora = new OtraCalculadora();
System.Diagnostics.Debug.WriteLine("ClassInitialize - Se ejecuta UNA SOLA VEZ por clase de test. ANTES de ejecutar ningún test.");
}
public DivisaoTest()
{
_mockCalc = new Mock <ICalculadora>();
//_mockCalc.Setup(m => m.Somar(2, 2)).Returns(4);
//_mockCalc.Setup(m => m.Somar(It.IsAny<int>(), -1)).Throws<ArgumentOutOfRangeException>();
_mockCalc.Setup(m => m.Dividir(It.IsAny <int>(), 0)).Throws <DivideByZeroException>();
_mockCalc.Setup(m => m.Dividir(6, 6)).Returns(1);
_calc = _mockCalc.Object;
}
public void setup()
{
var mock = new Mock <ICalculadora>();
mock.Setup(x => x.Suma(2, 2)).Returns(4);
mock.Setup(x => x.Resta(4, 2)).Returns(2);
mock.Setup(x => x.Dividir(4, 2)).Returns(2);
mock.Setup(x => x.multiplicar(4, 2)).Returns(8);
mockObject = mock.Object;// Es donde se coje el valor de la variable y se le asigna a MocKObject
}
public void TestInitialize()
{
calculadoraMock = Substitute.For <ICalculadora>();
testObject = new HojaCalculo(calculadoraMock)
{
PrimerNumero = 2,
SegundoNumero = 3
};
}
public void Setup()
{
var mock = new Mock <ICalculadora>();
mock.Setup(x => x.Suma(2, 2)).Returns(4);
mock.Setup(x => x.Resta(4, 2)).Returns(2);
mock.Setup(x => x.Division(4, 2)).Returns(2);
mock.Setup(x => x.Multiplicacion(4, 2)).Returns(8);
mockObject = mock.Object; //recupera el objeto mockado y se la asigna a la nueva variable objeto
}
public void Setup()//configuracion del comportamiento de la clase que genera la interfaz
{
var mock = new Mock <ICalculadora>();
mock.Setup(x => x.Suma(2, 2)).Returns(4);
mock.Setup(x => x.Resta(4, 2)).Returns(2);
mock.Setup(x => x.Division(4, 2)).Returns(2);
mock.Setup(x => x.Multiplicacion(4, 2)).Returns(8);
mockObject = mock.Object;
}
[TestInitialize] // s'executa abans que el metode de Test.
public void Setup()
{
var mock = new Mock <ICalculadora>();
mock.Setup(X => X.Suma(2, 2)).Returns(4);
mock.Setup(X => X.Resta(4, 2)).Returns(2);
mock.Setup(X => X.Division(4, 2)).Returns(2);
mock.Setup(X => X.Multiplicacion(4, 2)).Returns(8);
mockObject = mock.Object;
}
public CalculadoraTestFixture()
{
// Create the Mock Object "factory"
var objmock = mockfactor.CreateMock <ICalculadora>();
objmock.Expects.One.MethodWith(x => x.Suma(2, 2)).WillReturn(4);
objmock.Expects.One.MethodWith(x => x.Resta(4, 2)).WillReturn(2);
objmock.Expects.One.MethodWith(x => x.Division(4, 2)).WillReturn(2);
objmock.Expects.One.MethodWith(x => x.Multiplicacion(4, 2)).WillReturn(8);
this.MockObject = objmock.MockObject;
}
public void Setup()
{
var mock = new Mock <ICalculadora>();
mock.Setup(x => x.Suma(2, 2)).Returns(4);
mock.Setup(x => x.Resta(4, 2)).Returns(2);
mock.Setup(x => x.Division(4, 2)).Returns(2);
mock.Setup(x => x.Division(4, 0)).Throws <DivideByZeroException>();
mock.Setup(x => x.Multiplicacion(4, 2)).Returns(8);
mockObject = mock.Object;
}
public CalculadoraFixture()
{
var mock = _factory.CreateMock <ICalculadora>();
mock.Expects.One.MethodWith(x => x.Division(9, 3)).WillReturn(3);
mock.Expects.One.MethodWith(x => x.Multiplicacion(3, 2)).WillReturn(6);
mock.Expects.One.MethodWith(x => x.Resta(7, 3)).WillReturn(4);
mock.Expects.One.MethodWith(x => x.Suma(2, 5)).WillReturn(7);
MockObject = mock.MockObject;
}
public Funcion2D(string expresionY, Intervalo intervalo, uint puntosPorUnidad, Color color, float grosor, string nombre, bool dibujar, bool autoCalcularPuntos, ICalculadora calculadora, MetodoCalculoDelegate metodoCalculo)
: base()
{
base.puntos = null;
base.colorLinea = color;
base.grosor = grosor;
base.dib = dibujar;
base.nom = nombre;
ecuX = "x";
ecuY = expresionY;
interv = intervalo;
this.prof = puntosPorUnidad;
calc = calculadora;
metodo = metodoCalculo;
if (autoCalcularPuntos) CalcularPuntos(metodo);
}
public void SetUp()
{
var mock = new Mock<ICalculadora>();
// posso simular situações
mock.Setup(c => c.Soma(1, 2)).Returns(6);
// posso simular erros
mock.Setup(c => c.Soma(2, 1)).Throws(
new Exception("Deu ruim!"));
// posso manipular estados
this.dividiu = false;
mock.Setup(c => c.Divide(It.IsAny<int>(), It.IsAny<int>()))
.Callback(() => dividiu = true);
this.calculadora = mock.Object;
}
public void DivisionTest(int num1, int num2, int resultado)
{
_cal = new Calculo();
Assert.Equal(_cal.Division(num1, num2), resultado);
}
public void MultiplicacionTest(int num1, int num2, int resultado)
{
_cal = new Calculo();
Assert.Equal(_cal.Multiplicacion(num1, num2), resultado);
}
public CalculadoraController(ICalculadora calculadora)
{
this._calculadora = calculadora;
}
public Carrinho()
{
_calculadora = new Calculadora();
}
public Teste(ICalculadora lastName)
{
calc = lastName;
}
public ItemDeMenuCalculadora(ICalculadora calculadora)
{
_calculadora = calculadora;
}
public void Init()
{
iCalculadora = new Calculadora();
}
public static PointF[] Normal(ICalculadora calc, string expresionX, string expresionY, Intervalo intervalo, uint puntosPorUnidad)
{
PointF[] puntos;
int numtotal = ((int)Math.Round((Math.Abs(intervalo.Fin - intervalo.Inicio) * puntosPorUnidad),0, MidpointRounding.AwayFromZero) + 1);
try
{
puntos = new PointF[numtotal];
for (int k = 0; k < calc.Variables.Count; k++)
{
calc.Variables[calc.Variables.Keys[k]] = intervalo.Inicio;
}
for (int i = 0; i < puntos.Length; i++)
{
puntos[i].X = (float)calc.EvaluarExpresion(expresionX);
puntos[i].Y = (float)calc.EvaluarExpresion(expresionY);
float a = 1f / (float)(puntosPorUnidad);
for (int j = 0; j < calc.Variables.Count; j++)
{
calc.Variables[calc.Variables.Keys[j]] += a;
}
}
return puntos;
}
catch (Exception ex)
{
throw ex;
//PointF[] po = new PointF[]{PointF.Empty};
//return po;
}
}
public Calculadora(ICalculadora calculadora)
{
instancia = calculadora;
}
public TransacaoController(ICalculadora calculadora)
{
_calculadora = calculadora;
}
/// <summary>
/// Genera un MetodoCalculoDelegate que hace derivadas de la variable deseada. El delegado encapsula un método anónimo por lo que el rendimiento se puede ver deteriorado. Es preferible crear un método propio en vez de usar este.
/// </summary>
/// <param name="calc">Calculadora que se va a utilizar</param>
/// <param name="expresionX">Expresion para PointF.X</param>
/// <param name="expresionY">Expresion para PointF.Y</param>
/// <param name="variableADerivar">Identificador de la variable a Derivar (Debe estar ya definida en la Calculadora)</param>
/// <param name="intervalo">Intervalo de Cálculo</param>
/// <param name="puntosPorUnidad">Puntos a calcular por unidad</param>
/// <returns>MetodoCalculoDelegate</returns>
public static MetodoCalculoDelegate GenerarMetodoDerivada(ICalculadora calc, string expresionX, string expresionY, string variableADerivar, Intervalo intervalo, uint puntosPorUnidad)
{
return delegate(ICalculadora calcu, string expresX, string expresY, Intervalo interv, uint PPU)
{
PointF[] puntos;
try
{
puntos = new PointF[(int)Math.Round((Math.Abs(intervalo.Fin - intervalo.Inicio) * puntosPorUnidad), 0, MidpointRounding.AwayFromZero)];
for (int k = 0; k < calc.Variables.Count; k++)
{
calc.Variables[calc.Variables.Keys[k]] = intervalo.Inicio;
}
for (int i = 0; i < puntos.Length; i++)
{
puntos[i].X = (float)calc.EvaluarExpresion(expresionX);
puntos[i].Y = (float)calc.EvaluarDerivada1(expresionY, variableADerivar);
float a = 1f / (float)(puntosPorUnidad);
for (int j = 0; j < calc.Variables.Count; j++)
{
calc.Variables[calc.Variables.Keys[j]] += a;
}
}
return puntos;
}
catch (Exception ex)
{
throw ex;
//PointF[] po = new PointF[]{PointF.Empty};
//return po;
}
};
}
public void Dispose()
{
_calc = null;
}
public CalculadoraRomanaController(ICalculadora calc, IReadOnlyRepository readOnlyRepository, IWriteOnlyRepository writeOnlyRepository)
{
_calc = calc;
_readOnlyRepository = readOnlyRepository;
_writeOnlyRepository = writeOnlyRepository;
}
public HojaCalculo(ICalculadora calculadora)
{
mCalculadora = calculadora;
}
public MaquinaCalculadoraAppService(ICalculadora calc)
{
this._calc = calc;
}
public Calculadora(ICalculadora calculadora)
{
instancia = calculadora;
}
public CalculadoraRoyalties(IVendaRepository repository, ICalculadora calculadora)
{
this.repository = repository;
this.calculadora = calculadora;
}
public Display(ICalculadora calculadora)
{
_calculadora = calculadora;
}
public void RestaTest(int num1, int num2, int resultado)
{
_cal = new Calculo();
Assert.Equal(_cal.Resta(num1, num2), resultado);
}
public int F(ICalculadora x, int a, int b)
{
return(x.Soma(a, b));
}
public Carrinho()
{
_calculadora = new Calculadora();
}