public void DeveEntenderLancesEmOrdemCrescente()
        {
            Leilao leilao = new CriadorDeLeilao().Para("Playstation 3 Novo")
                            .Lance(maria, 250.0)
                            .Lance(joao, 300.0)
                            .Lance(jose, 400.0)
                            .Constroi();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(400, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(250, leiloeiro.MenorLance, 0.0001);
        }
        public static void Main(String[] args)
        {
            Usuario joao  = new Usuario("João");
            Usuario jose  = new Usuario("Jose");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Carro");

            leilao.Propoe(new Lance(joao, 1000));
            leilao.Propoe(new Lance(jose, 4000));
            leilao.Propoe(new Lance(maria, 3000));
            leilao.Propoe(new Lance(maria, 7500));
            leilao.Propoe(new Lance(maria, 933));

            Avaliador avaliador = new Avaliador();

            avaliador.Avalia(leilao);

            double menorEsperado = 933;
            double maiorEsperado = 7500;

            Console.WriteLine(maiorEsperado == avaliador.MaiorLance);
            Console.WriteLine(menorEsperado == avaliador.MenorLance);
            Console.WriteLine(avaliador.MediaLances(leilao));

            Palindromo palindromo = new Palindromo();

            Console.WriteLine(palindromo.EhPalindromo("Socorram-me subi no onibus em Marrocos"));
            Console.ReadKey();
        }
Exemple #3
0
        public void DeveEntenderLancesEmOrdemCrescente()
        {
            // cenario: 3 lances em ordem crescente
            Usuario morgan = new Usuario("Arthur Morgan");
            Usuario dutch  = new Usuario("Dutch Van Der Linde");
            Usuario maria  = new Usuario("maria");

            Leilao leilao = new Leilao("Red Dead Redemption II");

            leilao.Propoe(new Lance(maria, 250.0));
            leilao.Propoe(new Lance(morgan, 300.0));
            leilao.Propoe(new Lance(dutch, 400.0));

            //executando a acao
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            // comparando a saida com o esperado
            double maiorEsperado = 400;
            double menorEsperado = 250;

            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance, 0.00001);
            Assert.AreEqual(menorEsperado, leiloeiro.MenorLance, 0.00001);
        }
Exemple #4
0
        public void Main()
        {
            //1a parte: Cenario
            Usuario joao      = new Usuario("Joao");
            Usuario jose      = new Usuario("José");
            Usuario maria     = new Usuario("Maria");
            Usuario Bob       = new Usuario("Bob");
            Usuario Marley    = new Usuario("Marley");
            Usuario Steav     = new Usuario("Steav");
            Usuario Jon       = new Usuario("Jon");
            Usuario Bills     = new Usuario("Bills");
            Usuario Hohenhain = new Usuario("Hohenhain");

            Leilao leilao = new Leilao("Playstation 3 Novo");


            leilao.Propoe(new Lance(Bob, 400.0));
            leilao.Propoe(new Lance(Bills, 300.0));
            leilao.Propoe(new Lance(Marley, 200.0));
            leilao.Propoe(new Lance(Hohenhain, 100.0));


            //2a parte: acao
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            //3a parte: validacao
            Assert.AreEqual(400, leiloeiro.MaiorLance, 0.00001);
            Assert.AreEqual(100, leiloeiro.MenorLance, 0.00001);
        }
        public void DeveEntenderLancesEmOrdemCrescente()
        {
            Leilao leilao = new CriadorDeLeilao().Para("Playstation")
                            .Lance(maria, 250.0)
                            .Lance(joao, 300)
                            .Lance(jose, 400)
                            .Constroi();

            leiloeiro.Avalia(leilao);

            double maiorEsperado = 400;
            double menorEsperado = 250;

            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance, 0.00001);
            Assert.AreEqual(menorEsperado, leiloeiro.MenorLance, 0.00001);
        }
        static void Main(string[] args)
        {
            // 1st part: scenario (ARRANGE)
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("Jose");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 250.0));
            leilao.Propoe(new Lance(joao, 300.0));
            leilao.Propoe(new Lance(jose, 400.0));

            // 2nd part: ACT
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            // 3rd part: validation (ASSERT)
            double maiorEsperado = 400;
            double menorEsperado = 250;

            Console.WriteLine(maiorEsperado == leiloeiro.MaiorLance);
            Console.WriteLine(menorEsperado == leiloeiro.MenorLance);

            Console.ReadKey();
        }
        public void DeveEntenderLancesEmOrdemCrescente()
        {
            //1a Parte: cenário
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("Jose");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 250.0));
            leilao.Propoe(new Lance(joao, 300.0));
            leilao.Propoe(new Lance(jose, 400.0));

            //2a Parte: acao
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            //3a Parte: validacao
            double maiorEsperado = 400;
            double menorEsperado = 250;

            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(menorEsperado, leiloeiro.MenorLance, 0.0001);
        }
Exemple #8
0
        public void NenhumLance()
        {
            Leilao    leilao    = new Leilao("Playstation 3 Novo");
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);
            List <Lance> resultado = leiloeiro.TresMaiores;

            Assert.AreEqual(0, resultado[0].Valor, 0.0001);
        }
        public void DeveEntenderLancesEmOrdemCrescente()
        {
            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 250.0));
            leilao.Propoe(new Lance(joao, 300.0));
            leilao.Propoe(new Lance(jose, 400.0));



            leiloeiro.Avalia(leilao);

            double maiorEsperado = 400;
            double menorEsperado = 250;


            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance);
            Assert.AreEqual(menorEsperado, leiloeiro.MenorLance);
        }
Exemple #10
0
        public void DeveEntenderLancesEmOrdemCrescenteComOutrosValores()
        {
            //1º Parte: Cenário


            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 1000.0));
            leilao.Propoe(new Lance(henrique, 2000.0));
            leilao.Propoe(new Lance(maria, 3000.0));

            //2º Parte: Ação
            CriaAvaliador();
            leiloeiro.Avalia(leilao);

            //3º Parte: Validação
            Assert.AreEqual(3000, leiloeiro.maiorLance);
            Assert.AreEqual(1000, leiloeiro.menorLance);
        }
Exemple #11
0
        public void ListaNula()
        {
            Leilao leilao = new Leilao("Playstation 3 Novo");

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(0, leiloeiro.TresMaiores.Count);
        }
Exemple #12
0
        public void DeveEntenderLancesEmOrdeCrescente()
        {
            //1º parte : cenario

            Leilao leilao = new Leilao("Playstation 4");

            leilao.Propoe(new Lance(joao, 250.0));
            leilao.Propoe(new Lance(jose, 300.0));
            leilao.Propoe(new Lance(maria, 400.0));

            //2º parte : executa uma ação
            leiloeiro.Avalia(leilao);

            //3º parte : validação
            double menorValor = 250.0;
            double maiorValor = 400.0;

            Assert.AreEqual(maiorValor, leiloeiro.ObterMaiorLance);
            Assert.AreEqual(menorValor, leiloeiro.ObterMenorLance);
        }
Exemple #13
0
        public void Main()
        {
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("José");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 300.0));
            leilao.Propoe(new Lance(jose, 400.0));
            leilao.Propoe(new Lance(maria, 250.0));

            leiloeiro.Avalia(leilao);

            double maiorEsperado = 400;
            double menorEsperado = 250;

            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(menorEsperado, leiloeiro.MenorLance, 0.0001);
        }
        public void DeveDevolverListaVaziaCasoNaoHajaLances()
        {
            Leilao leilao = new Leilao("Playstation 3 Novo");

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            var maiores = leiloeiro.TresMaiores;

            Assert.AreEqual(0, maiores.Count);
        }
Exemple #15
0
        public void DeveEntenderLancesCrescentes()
        {
            var leilao = new LeilaoTDBuilder()
                         .NovoLeilaoDe("Galaxy S9+")
                         .comLance(joao, 200)
                         .comLance(pedro, 300)
                         .comLance(maria, 500)
                         .Constroi();

            //2-AÇÃO:
            avaliador.Avalia(leilao);

            //3-VALIDAÇÃO:
            Assert.AreEqual(200, avaliador.MenorLance, 0.00001);
            Assert.AreEqual(500, avaliador.MaiorLance, 0.00001);
        }
        public void DeveEntenderLeilaoComApenasUmLance()
        {
            Usuario joao   = new Usuario("Joao");
            Leilao  leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 1000.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(1000, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(1000, leiloeiro.MenorLance, 0.0001);
        }
Exemple #17
0
        public void DoisLances()
        {
            Usuario joao   = new Usuario("Joao");
            Usuario joao2  = new Usuario("Joao2");
            Leilao  leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 400.0));
            leilao.Propoe(new Lance(joao2, 300.0));
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);
            List <Lance> resultado = leiloeiro.TresMaiores;

            Assert.AreEqual(400, resultado[0].Valor, 0.0001);
            Assert.AreEqual(300, resultado[1].Valor, 0.0001);
        }
Exemple #18
0
        public void DeveEntenderLancesEmOrdemCrescente()
        {
            Leilao leilao = new CriadorDeLeilao().Para("Playstation 3 Novo")
                            .Lance(maria, 250)
                            .Lance(joao, 300)
                            .Lance(jose, 400)
                            .Constroi();

            // 2a parte: acao
            leiloeiro.Avalia(leilao);

            // 3a parte: validacao
            double maiorEsperado = 400;
            double menorEsperado = 250;

            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance);
            Assert.AreEqual(menorEsperado, leiloeiro.Menorlance);
        }
Exemple #19
0
        public void TestandoOAvaliador()
        {
            //1a parte: cenario
            Leilao leilao = new CriadorDeLeilao().Para("GeForce GTX 1080Ti")
                            .Lance(alex, 3000.0)
                            .Lance(maria, 1500.0)
                            .Lance(lucas, 1500.0)
                            .Constroi();

            //2a parte: ação
            leiloeiro.Avalia(leilao);

            //3a parte: validação

            Assert.AreEqual(1500, leiloeiro.menorLance, 0.00001);
            Assert.AreEqual(3000, leiloeiro.maiorLance, 0.00001);
            Assert.AreEqual(2000, leiloeiro.Media, 0.00001);
        }
Exemple #20
0
        public void DoisValores()
        {
            Usuario joao = new Usuario("Joao");
            Usuario jose = new Usuario("José");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(jose, 395.0));
            leilao.Propoe(new Lance(joao, 200.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(2, leiloeiro.TresMaiores.Count);
            Assert.AreEqual(395, leiloeiro.TresMaiores[0].Valor);
            Assert.AreEqual(200, leiloeiro.TresMaiores[1].Valor);
        }
        public void TesteOutroCenarioLances()
        {
            Usuario   Luan      = new Usuario("Luan");
            Leilao    leilao    = new Leilao("TV");
            Avaliador leiloeiro = new Avaliador();
            string    Message;

            leilao.Propoe(new Lance(Luan, 0));

            try
            {
                leiloeiro.Avalia(leilao);
            }
            catch (Exception ex)
            {
                Message = ex.ToString();
            }
        }
Exemple #22
0
        public void DeveEntenderLancesEmOrdemCrescenteComOutrosValores()
        {
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("José");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 1000.0));
            leilao.Propoe(new Lance(joao, 2000.0));
            leilao.Propoe(new Lance(jose, 3000.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(3000, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(1000, leiloeiro.MenorLance, 0.0001);
        }
        public void DeveDevolverTodosLancesCasoNaoHajaNoMinimo3()
        {
            Usuario joao   = new Usuario("Joao");
            Usuario maria  = new Usuario("maria");
            Leilao  leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 800.0));
            leilao.Propoe(new Lance(maria, 400.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            var maiores = leiloeiro.TresMaiores;

            Assert.AreEqual(2, maiores.Count);
            Assert.AreEqual(800, maiores[0].Valor, 0.0001);
            Assert.AreEqual(400, maiores[1].Valor, 0.0001);
        }
        public void DeveEncontrarOsTresMaioresLances()
        {
            Usuario joao   = new Usuario("Joao");
            Usuario maria  = new Usuario("maria");
            Leilao  leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 200.0));
            leilao.Propoe(new Lance(joao, 300.0));
            leilao.Propoe(new Lance(maria, 400.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            var maiores = leiloeiro.TresMaiores;

            Assert.AreEqual(3, maiores.Count);
            Assert.AreEqual(400, maiores[0].Valor, 0.0001);
            Assert.AreEqual(300, maiores[1].Valor, 0.0001);
            Assert.AreEqual(200, maiores[2].Valor, 0.0001);
        }
        public void DeveCalcularAMedia()
        {
            //1a Parte: cenário
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("Jose");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 300.0));
            leilao.Propoe(new Lance(joao, 400.0));
            leilao.Propoe(new Lance(jose, 500.0));

            //2a Parte: acao
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            //3a Parte: validacao
            Assert.AreEqual(400, leiloeiro.ValorMedio, 0.0001);
        }
Exemple #26
0
        [Test]                              // Adc
        public void TesteOrdemDecrescente() // Deixar publico e sem nada dentro do Main()
        {                                   // Cenário - 1° parte do teste
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("José");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 900.0));
            leilao.Propoe(new Lance(jose, 500.0));
            leilao.Propoe(new Lance(maria, 50.0));

            // Ação - 2° parte
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            // Validação - 3° parte
            Assert.AreEqual(900, leiloeiro.MaiorLance, 0.00001); // imprime 400.0
            Assert.AreEqual(50, leiloeiro.MenorLance, 0.0001);   // imprime 200.0
        }
Exemple #27
0
        public void TestDeMedia()
        {
            // cenario: 3 lances em ordem crescente
            Usuario joao  = new Usuario("Joao");
            Usuario jose  = new Usuario("José");
            Usuario maria = new Usuario("Maria");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(maria, 300.0));
            leilao.Propoe(new Lance(joao, 400.0));
            leilao.Propoe(new Lance(jose, 500.0));

            // executando a acao
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            // comparando a saida com o esperado
            Assert.AreEqual(400, leiloeiro.Media, 0.0001);
        }
Exemple #28
0
        public void ValoresDecrescente()
        {
            Usuario joao   = new Usuario("Joao");
            Usuario joao2  = new Usuario("Joao2");
            Usuario joao3  = new Usuario("Joao3");
            Usuario joao4  = new Usuario("Joao4");
            Leilao  leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 400.0));
            leilao.Propoe(new Lance(joao2, 300.0));
            leilao.Propoe(new Lance(joao3, 200.0));
            leilao.Propoe(new Lance(joao4, 100.0));
            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);
            double maiorEsperado = 400;
            double menorEsperado = 100;

            Assert.AreEqual(maiorEsperado, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(menorEsperado, leiloeiro.MenorLance, 0.0001);
        }
Exemple #29
0
        public void DeveEntenderLancesAleatorios()
        {
            Usuario joao   = new Usuario("joao");
            Usuario maria  = new Usuario("maria");
            Leilao  leilao = new Leilao("Xbox Novo");

            leilao.Propoe(new Lance(joao, 100.0));
            leilao.Propoe(new Lance(maria, 200.0));
            leilao.Propoe(new Lance(joao, 300.0));
            leilao.Propoe(new Lance(maria, 400.0));
            leilao.Propoe(new Lance(joao, 700.0));
            leilao.Propoe(new Lance(maria, 550.0));
            leilao.Propoe(new Lance(joao, 120.0));
            leilao.Propoe(new Lance(maria, 50.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(50, leiloeiro.MenorLance, 0.0001);
            Assert.AreEqual(700, leiloeiro.MaiorLance, 0.0001);
        }
        public void DeveEntenderLancesEmOrdemRandomica()
        {
            Usuario joao  = new Usuario("Joao");
            Usuario maria = new Usuario("Maria");
            Usuario jose  = new Usuario("Jose");

            Leilao leilao = new Leilao("Playstation 3 Novo");

            leilao.Propoe(new Lance(joao, 200.0));
            leilao.Propoe(new Lance(maria, 450.0));
            leilao.Propoe(new Lance(jose, 120.0));
            leilao.Propoe(new Lance(maria, 700.0));
            leilao.Propoe(new Lance(joao, 630.0));
            leilao.Propoe(new Lance(jose, 230.0));

            Avaliador leiloeiro = new Avaliador();

            leiloeiro.Avalia(leilao);

            Assert.AreEqual(700, leiloeiro.MaiorLance, 0.0001);
            Assert.AreEqual(120, leiloeiro.MenorLance, 0.0001);
        }