public ICalculable GetOperationClass(string command)
{
ICalculable calculateClass = default(ICalculable);
switch (command)
{
case "add":
calculateClass = new Addition();
break;
case "divide":
calculateClass = new Division();
break;
case "multiply":
calculateClass = new Multiplication();
break;
case "substract":
calculateClass = new Substraction();
break;
}
return(calculateClass);
}
private void AddExecute(object parameter)
{
ICalculable operationClass = calculationClass.GetOperationClass("add");
Calculation3 = operationClass.Calculate(Calculation1, Calculation2);
SendMessage();
}
public static ICalculable GetOperationClass(ModelCalculator.Operators selectedOperator)
{
ICalculable calculateClass = default(ICalculable);
switch (selectedOperator)
{
case ModelCalculator.Operators.Addition:
calculateClass = new Addition();
break;
case ModelCalculator.Operators.Division:
calculateClass = new Division();
break;
case ModelCalculator.Operators.Multiplication:
calculateClass = new Multiplication();
break;
case ModelCalculator.Operators.Subtraction:
calculateClass = new Subtraction();
break;
case ModelCalculator.Operators.SquareRoot:
calculateClass = new SquareRoot();
break;
}
return(calculateClass);
}
public Presenter(ICalculatorForm calculatorForm, ICalculable calculable)
{
this.calculatorForm = calculatorForm;
this.calculable = calculable;
calculatorForm.EquallyClick += CalculatorForm_EquallyClick;
}
static void Main(string[] args)
{
try
{
ICalculable calculadora = null;
int op = 0;
while (true)
{
Console.WriteLine("Presione 1 para sumas y restas, presione 2 para mulplicaciones y divisiones");
Console.Write("Opcion ");
op = Convert.ToInt32(Console.ReadLine());
if (op == 1)
{
calculadora = new Calculadora();
}
else if (op == 2)
{
calculadora = new Calculadora2();
}
calculadora.ImprimirOpciones();
Console.Write("Opcion: ");
int opcion = Convert.ToInt32(Console.ReadLine());
Console.WriteLine($"La resupuesta es: {calculadora.Calcular(opcion)}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
public async Task CalculateAsync_WhenCalled_ReturnsSameCalculable()
{
ICalculable <IAccounting> sut = CreateSut();
IAccounting result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
Assert.That(result, Is.SameAs(sut));
}
public ColaFinDia(ICalculable _calculable, string _eventoLlegada, string _nombre, int _servicio)
{
nombre = _nombre;
calculable = _calculable;
eventoLlegada = _eventoLlegada;
miembros = 0;
servicio = _servicio;
}
public async Task CalculateAsync_WhenCalledMultipleTimesWithSameStatusDate_ReturnsSameCalculable()
{
ICalculable <IAccounting> sut = CreateSut();
DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
IAccounting result = await(await(await sut.CalculateAsync(statusDate)).CalculateAsync(statusDate)).CalculateAsync(statusDate);
Assert.That(result, Is.SameAs(sut));
}
public async Task CalculateAsync_WhenCalled_ReturnsSameCalculableWhereStatusDateEqualDateFromCall()
{
ICalculable <IAccounting> sut = CreateSut();
DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
IAccounting result = await sut.CalculateAsync(statusDate);
Assert.That(result.StatusDate, Is.EqualTo(statusDate.Date));
}
public async Task CalculateAsync_WhenCalled_ReturnsSameCalculableWithCalculatedContactAccountCollection()
{
IContactAccountCollection calculatedContactAccountCollection = _fixture.BuildContactAccountCollectionMock().Object;
IContactAccountCollection contactAccountCollection = _fixture.BuildContactAccountCollectionMock(calculatedContactAccountCollection: calculatedContactAccountCollection).Object;
ICalculable <IAccounting> sut = CreateSut(contactAccountCollection: contactAccountCollection);
IAccounting result = await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
Assert.That(result.ContactAccountCollection, Is.EqualTo(calculatedContactAccountCollection));
}
public async Task CalculateAsync_WhenCalled_AssertCalculateAsyncWasCalledOnContactAccountCollection()
{
Mock <IContactAccountCollection> contactAccountCollectionMock = _fixture.BuildContactAccountCollectionMock();
ICalculable <IAccounting> sut = CreateSut(contactAccountCollection: contactAccountCollectionMock.Object);
DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
await sut.CalculateAsync(statusDate);
contactAccountCollectionMock.Verify(m => m.CalculateAsync(It.Is <DateTime>(value => value == statusDate.Date)), Times.Once);
}
public async Task CalculateAsync_WhenCalledMultipleTimesWithSameStatusDate_AssertCalculateAsyncWasCalledOnlyOnceOnBudgetAccountCollection()
{
Mock <IBudgetAccountCollection> budgetAccountCollectionMock = _fixture.BuildBudgetAccountCollectionMock();
ICalculable <IAccounting> sut = CreateSut(budgetAccountCollection: budgetAccountCollectionMock.Object);
DateTime statusDate = DateTime.Now.AddDays(_random.Next(1, 365) * -1);
await(await(await sut.CalculateAsync(statusDate)).CalculateAsync(statusDate)).CalculateAsync(statusDate);
budgetAccountCollectionMock.Verify(m => m.CalculateAsync(It.Is <DateTime>(value => value == statusDate.Date)), Times.Once);
}
//Instanciacion del servidor con una cola, una forma de calcular el proximo fin de atencion, el evento de fin de atencion, el nombre del servidor, si es primer servidor del sistema, si es ultimo servidor del sistema
public Servidor(IColeable _cola, ICalculable _calculable, string _eventoFat, string _nombre, bool _ultimo, bool _primero)
{
estado = 0;
cola = _cola;
eventoFat = _eventoFat;
calculable = _calculable;
nombre = _nombre;
proxFAT = -1;
ultimo = _ultimo;
primero = _primero;
}
private void DivideExecute(object parameter)
{
try
{
ICalculable operationClass = calculationClass.GetOperationClass("divide");
Calculation3 = operationClass.Calculate(Calculation1, Calculation2);
SendMessage();
}
catch (Exception)
{
}
}
private void FuncInput_TextChanged(object sender, TextChangedEventArgs e)
{
try
{
currentFunc = ExpressionParser.FromText(FuncInput.Text);
FuncInput.Foreground = Brushes.AntiqueWhite;
Graph.CurrentFunction = currentFunc;
Graph.DrawCartesian();
}
catch
{
FuncInput.Foreground = new SolidColorBrush(Color.FromArgb(255, 230, 150, 150));
}
}
public void Initialize()
{
_defaultCalc = new DefaultCalculable();
_ejercito = new Ejercito(_defaultCalc);
_transporteMX7899 = FakeUnidades.GetTransporterMX7899();
_tanqueAtaqueSombrasVB98 = FakeUnidades.GetTanqueAtaqueSombrasVB98();
_transporteTAXIN66 = FakeUnidades.GetTransporteTAXIN66();
_infanteriaBasica = FakeUnidades.GetInfanteriaBasica();
_ametrallador = FakeUnidades.GetAmetrallador();
_sanitario = FakeUnidades.GetSanitario();
_canonAntiaereo = FakeUnidades.GetCanonAntiaereo();
_torpederoMovil = FakeUnidades.GetTorpederoMovil();
_canon = FakeUnidades.GetCanon();
}
//inicializa al servidor con lo mismo que un servidor estandar y con la condicion de interrupcion junto con su calculo
public ServidorInterrupcion(IColeable _cola, ICalculable _calculableInterrupcion, ICalculable _calculable, string _eventoFat, string _nombre, string _eventoFinInterrupcion, int _cantLimite, bool _ultimo, bool _primero)
{
estado = 0;
cola = _cola;
eventoFat = _eventoFat;
calculable = _calculable;
nombre = _nombre;
proxFAT = -1;
eventoFinInterrupcion = _eventoFinInterrupcion;
cantLimite = _cantLimite;
interrumpido = false;
atendidos = 0;
calculableInterrupcion = _calculableInterrupcion;
ultimo = _ultimo;
primero = _primero;
}
public async Task CalculateAsync_WhenCalled_AssertPostingLineCollectionWasCalledOnEachAccountFromCalculatedAccountCollection()
{
IList <Mock <IAccount> > accountMockCollection = new List <Mock <IAccount> >
{
_fixture.BuildAccountMock(),
_fixture.BuildAccountMock(),
_fixture.BuildAccountMock(),
_fixture.BuildAccountMock(),
_fixture.BuildAccountMock(),
_fixture.BuildAccountMock(),
_fixture.BuildAccountMock()
};
IAccountCollection calculatedAccountCollection = _fixture.BuildAccountCollectionMock(accountCollection: accountMockCollection.Select(m => m.Object).ToArray()).Object;
IAccountCollection accountCollection = _fixture.BuildAccountCollectionMock(calculatedAccountCollection: calculatedAccountCollection).Object;
ICalculable <IAccounting> sut = CreateSut(accountCollection);
await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
foreach (Mock <IAccount> accountMock in accountMockCollection)
{
accountMock.Verify(m => m.PostingLineCollection, Times.Once);
}
}
public async Task CalculateAsync_WhenCalled_AssertApplyCalculationAsyncWasCalledOnEachPostingLineCollectionForEachAccountFromCalculatedAccountCollection()
{
IList <Mock <IPostingLineCollection> > postingLineCollectionMockCollection = new List <Mock <IPostingLineCollection> >
{
_fixture.BuildPostingLineCollectionMock(isEmpty: true),
_fixture.BuildPostingLineCollectionMock(isEmpty: true),
_fixture.BuildPostingLineCollectionMock(isEmpty: true),
_fixture.BuildPostingLineCollectionMock(isEmpty: true),
_fixture.BuildPostingLineCollectionMock(isEmpty: true),
_fixture.BuildPostingLineCollectionMock(isEmpty: true),
_fixture.BuildPostingLineCollectionMock(isEmpty: true)
};
IAccountCollection calculatedAccountCollection = _fixture.BuildAccountCollectionMock(accountCollection: postingLineCollectionMockCollection.Select(m => _fixture.BuildAccountMock(postingLineCollection: m.Object).Object).ToArray()).Object;
IAccountCollection accountCollection = _fixture.BuildAccountCollectionMock(calculatedAccountCollection: calculatedAccountCollection).Object;
ICalculable <IAccounting> sut = CreateSut(accountCollection);
await sut.CalculateAsync(DateTime.Now.AddDays(_random.Next(1, 365) * -1));
foreach (Mock <IPostingLineCollection> postingLineCollectionMock in postingLineCollectionMockCollection)
{
postingLineCollectionMock.Verify(m => m.ApplyCalculationAsync(It.Is <IAccounting>(value => value != null && value == sut)), Times.Once);
}
}
public void setCalculadora(ICalculable _calculable)
{
calculable = _calculable;
}
public void DetalleDePropuesta(ICalculable publicidad)
{
}
public void AddProvider(string provider, ICalculable calculator)
{
_providers.Add(provider, calculator);
}
public Ejercito(ICalculable calculable, double fondo = double.PositiveInfinity)
{
_fondo = fondo;
_unidades = new List <Unidad>();
_calculable = calculable;
}
public void agregarMedio(ICalculable medio)
{
medios.Add(medio);
}
