Example #1
0
        public void CalcularParcelaPrice()
        {
            var EsperadoPrestacao = 1000;

            var valorPrestacao = SistemaDeAmortizacaoPrice.CalcularValorPrestacao(valorFinanciamento, taxaDeJuros, numeroDeParcelas);

            Assert.IsTrue(EsperadoPrestacao == valorPrestacao);
        }
Example #2
0
        public void ValorPrimeiraAmortizacao()
        {
            decimal amortizacaoEsperada = 744.09M;

            var primeiraAmortizacao = SistemaDeAmortizacaoPrice.ValorPrimeiraAmortizacao(valorFinanciamento, taxaDeJuros, numeroDeParcelas);

            Assert.IsTrue(amortizacaoEsperada == primeiraAmortizacao);
        }
Example #3
0
        public void ValorAmortizacaoAcumuladaEmT()
        {
            int     ordem = 10;
            decimal amortizacaoEsperada = 8530.20M;

            var amortizacao = SistemaDeAmortizacaoPrice.ValorAmortizacaoAcumuladaAteOrdemT(valorFinanciamento, taxaDeJuros, numeroDeParcelas, ordem);

            Assert.IsTrue(amortizacaoEsperada == amortizacao);
        }
Example #4
0
        public void CalcularValorJurosEmOrdemT()
        {
            int     t = 6;
            decimal valorJurosEsperado = 137.39M;

            var valorJuros = SistemaDeAmortizacaoPrice.ValorParcelaJurosEmOrdemT(valorFinanciamento, taxaDeJuros, numeroDeParcelas, t);

            Assert.IsTrue(valorJurosEsperado == valorJuros);
        }
Example #5
0
        public void CalcularSaldoDevedorEmOrdemTMenosUm()
        {
            int     t = 6;
            decimal saldoDevedorEsperado = 4579.71M;

            var saldoDevedor = SistemaDeAmortizacaoPrice.SaldoDevedorEmOrdemT(valorFinanciamento, taxaDeJuros, numeroDeParcelas, t - 1);

            Assert.IsTrue(saldoDevedorEsperado == saldoDevedor);
        }
Example #6
0
        public void JurosAcumuladosAteT()
        {
            int     ordem         = 5;
            decimal jurosEsperado = 1049.51M;

            var jurosAcumulado = SistemaDeAmortizacaoPrice.ValorJurosAcumuladoEmOrdemT(valorFinanciamento, taxaDeJuros, numeroDeParcelas, ordem);

            Assert.IsTrue(jurosAcumulado == jurosEsperado);
        }
Example #7
0
        public void ValorAmortizacaoAcumuladaEntreTeK()
        {
            int     ordem = 2;
            int     k     = 5;
            decimal amortizacaoEsperada = 2439.98M;

            var amortizacao = SistemaDeAmortizacaoPrice.AmortizacaoAcumuladaEntreTeK(valorFinanciamento, taxaDeJuros, numeroDeParcelas, ordem, k);

            Assert.IsTrue(amortizacaoEsperada == amortizacao);
        }
Example #8
0
        public void ValorJurosAcumuladaEntreTeK()
        {
            int     ordem         = 2;
            int     k             = 5;
            decimal jurosEsperado = 560.02M;

            var juros = SistemaDeAmortizacaoPrice.JurosAcumuladoEntreTeK(valorFinanciamento, taxaDeJuros, numeroDeParcelas, ordem, k);

            Assert.IsTrue(jurosEsperado == juros);
        }
Example #9
0
 public IActionResult GerarTabela(ValoresFinanciamento valores, string tipoSubmit, string opcoesCalcular, int t, int k, bool gerouTabela)
 {
     if (tipoSubmit.Equals("geraTabela"))
     {
         valores.Parcelas = SistemaDeAmortizacaoPrice.CalcularParcelas(valores.Valor, valores.TaxaJuros, valores.Prazo);
         return(View("Index", valores));
     }
     if (tipoSubmit.Equals("calcularOpcao"))
     {
         valores.Parcelas    = gerouTabela ? SistemaDeAmortizacaoPrice.CalcularParcelas(valores.Valor, valores.TaxaJuros, valores.Prazo) : null;
         ViewData["Calculo"] = valores.RetornaValorCalculoPrice(opcoesCalcular, t, k);
         return(View("Index", valores));
     }
     return(View());
 }
Example #10
0
        public decimal RetornaValorCalculoPrice(string opcaoCalcular, int t, int k)
        {
            var resultado = 0M;

            if (opcaoCalcular == "1")
            {
                resultado = SistemaDeAmortizacaoPrice.CalcularValorPrestacao(Valor, TaxaJuros, Prazo);
            }
            if (opcaoCalcular == "2")
            {
                resultado = SistemaDeAmortizacaoPrice.SaldoDevedorEmOrdemT(Valor, TaxaJuros, Prazo, t);
            }
            if (opcaoCalcular == "3")
            {
                resultado = SistemaDeAmortizacaoPrice.SaldoDevedorEmOrdemT(Valor, TaxaJuros, Prazo, t - 1);
            }
            if (opcaoCalcular == "4")
            {
                resultado = SistemaDeAmortizacaoPrice.ValorParcelaJurosEmOrdemT(Valor, TaxaJuros, Prazo, t);
            }
            if (opcaoCalcular == "5")
            {
                resultado = SistemaDeAmortizacaoPrice.ValorJurosAcumuladoEmOrdemT(Valor, TaxaJuros, Prazo, t);
            }
            if (opcaoCalcular == "6")
            {
                resultado = SistemaDeAmortizacaoPrice.JurosAcumuladoEntreTeK(Valor, TaxaJuros, Prazo, t, k);
            }
            if (opcaoCalcular == "7")
            {
                resultado = SistemaDeAmortizacaoPrice.ValorPrimeiraAmortizacao(Valor, TaxaJuros, Prazo);
            }
            if (opcaoCalcular == "8")
            {
                resultado = SistemaDeAmortizacaoPrice.ValorAmotizacaoEmOrdemT(Valor, TaxaJuros, Prazo, t);
            }
            if (opcaoCalcular == "9")
            {
                resultado = SistemaDeAmortizacaoPrice.ValorAmortizacaoAcumuladaAteOrdemT(Valor, TaxaJuros, Prazo, t);
            }
            if (opcaoCalcular == "10")
            {
                resultado = SistemaDeAmortizacaoPrice.AmortizacaoAcumuladaEntreTeK(Valor, TaxaJuros, Prazo, t, k);
            }

            return(resultado);
        }
Example #11
0
        public void DeveGerarTabelaPrice()
        {
            var price = SistemaDeAmortizacaoPrice.CalcularParcelas(valorFinanciamento, taxaDeJuros, numeroDeParcelas);

            Assert.AreNotEqual(null, price);
        }