[MÚSICA] Estamos de volta com o hands on de desenvolvimento da nossa pilha, certo? Temos aqui os dois primeiros testes, não é, o teste que a gente verificou a pilha vazia. A gente fez teste onde a gente empilha elemento, e gente executou e viu que a nossa barrinha está verde. Está tudo certinho. Vamos então para o próximo teste que seria para empilhar dois elementos. Então vou pegar como base o teste anterior, vou criar "empilhaDoisElementos". Então eu vou arrumar aqui o teste, eu vou empilhar. Depois de empilhar o primeiro, eu vou empilhar o segundo. O "estaVazia" aqui eu estou confiante que já está funcionando, então eu sei que o tamanho precisa ser dois, e o meu topo tem que ser segundo. Será que minha pilha funciona aqui com dois elementos? Então eu vou salvar o teste, vou executar. Funcionou, funcionou! Então o que significa isso? Significa que esse teste, pro meu TDD, ele não é bom. É bom o teste que faz falhar alguma coisa. Quando isso acontece, a gente normalmente volta no mesmo teste a não ser que seja teste que você queira para refinar alguma funcionalidade, para verificar se algum caso realmente está funcionando. Mas para o TDD mesmo, a gente precisa de teste falhando. Então ao invés de empilhar dois elementos, eu vou "empilha dois e desempilha ". Ou melhor, vou chamar de ''empilha e desempilha". Então o que que eu vou fazer, eu vou empilhar dois elementos, vou verificar se isso daqui é verdade. Aí eu vou pegar aqui, vamos chamar aqui de "desempilhado" então, aquele teste que eu tinha antes, ele vai ser só o começo para mim. Então, eu vou chamar a pilha, ".desempilha". Ele tem que me retornar, qual que é o elemento que está cima. Eu vou verificar novamente que o tamanho ele vai ser agora que eu desempilhei. O topo agora tem que ser o primeiro. Opa ficou errado, ficou "primieiro". Tem que ser "primeiro". E o meu, esse "desempilhado" [SEM_ÁUDIO] ele vai ser segundo, vai ser o segundo aqui. Então vou colocar aqui "desempilhado". Então ele vai ser aqui o segundo. Novamente eu vou ter que criar esse método "desempilha" porque ele não existe. Crie aqui método "desempilha" na pilha. Salva. Agora o teste, ele está compilando. Eu vou executar aqui, e agora sim eu vou ter teste que falha para eu poder trabalhar cima dele. Bom, Vamos lá, agora esse elemento aqui sozinho ele já não vai adiantar, porque eu preciso ter histórico. Porque no momento que ele desempilha ele vai desempilhar o segundo, e o primeiro que estava por baixo ali do segundo, ele vai ficar no topo. E aqui eu estou guardando só. Eu vou criar aqui array de elementos. Eu vou chamar de elementos. Então, eu vou vir aqui vou dar Refactor, Rename. Para ele mudar todo mundo alí que está usando ele para mim. Eu vou colocar o S alí no final, para ficar mais adequado. E eu vou vir aqui por exemplo no meu método "empilha" ele vai vir aqui na minha quantidade, ela começa com o que? Vou colocar aqui que ele começa com o 0. Está explicitamente Java inteiros já começam com 0, mas eu vou colocar aqui de uma forma explicita. Então o que é que eu vou fazer? Quando eu empilhar eu vou colocar o elemento na posição "quantidade". E aí quando eu somo ali ele vai adicionando. E o topo ele vai ser o que estiver alí no array elementos na posição "quantidade- 1". Depois obviamente a gente vai rodar o teste para ver se esse negócio etá funcionando. [SEM_ÁUDIO] Eu preciso também criar aqui o array, que eu não cheguei a criar. A princípio eu vou criar com 10, depois a gente avalia isso aqui. "new Object[10]" [SEM_ÁUDIO] E aqui no "desempilha" vamos ver como é que vai ser. Eu tenho que pegar o elemento que está no topo. Então, eu já vou usar o próprio método "topo". "object" Vamos colocar aqui, vamos chamar de topo mesmo, a gente pega alí quem está no topo. Eu vou fazer que a "quantidade menos menos" E vou retornar o topo. Bom, será que vai funcionar aqui a minha pilha? Eu vou salvar e vou rodar teste para ver. Olha que interessante que aconteceu. O meu teste pilha desempilha que eu estava tentando desenvolver agora, esse teste ele está funcionando. Só que a minha pilha vazia, que é aquele primeiro teste que eu fiz lá, que eu aposto muitos de vocês pensaram, "Nossa mas que teste inútil, não serve para nada você verificar uma pilha vazia". Justamente ele está dando problema agora. Ele não é teste inútil não, porque ele pegou bug que ficou na minha pilha. Vamos ver o que aconteceu? Ele não está ele está retornando falso como a pilha vazia. Vamos ver o que aconteceu? Olha aqui o porquê ele está verificando se esses elementos aqui, se isso aqui é new. Nunca vai ser new, porque vai estar com o meu array. O que eu tenho que verificar agora é se a quantidade é igual a 0. Então a quantidade igual a 0. Então vamos ver se o teste roda agora? Agora funcionou. Então preste atenção, às vezes aquele teste que você acha que não vai servir para nada, que é bobo ele pode ser teste que vai ser sim importante dentro da suíte de testes da sua classe. Além de ser o primeiro passo dentro do seu TDD. Aposto que muitos de vocês não perceberam esse erro. Talvez alguns mais experientes tenham já batido o olho alí no ''está vazia" e visto que ia dar problema, mas talvez alguns até não porque não são experiente mas as vezes por falta de atenção acabaram não percebendo essa questão. Isso é uma coisa bem interessante. A gente aprende uma lição no TDD, nenhum teste é bobo. Às vezes aquele teste que você acha que não está testando muita coisa, quando as coisas começam a se complicar aquilo alí pode as vezes pegar bug importante que de outras formas você poderia não pegar. Ok? Então seguimos mais passinho aqui, criamos mais testezinho aqui, agora já temos uma pilha que empilha e desempilha. E a gente volta na terceira parte aqui do nosso hands-on e eu vou voltar mostrando para vocês a gente verificando aqui as situações de erro da pilha. Quando a pilha estoura, ou quando a pilha, ou quando alguém tenta tirar alguma coisa de uma pilha que está vazia. Certo? Até à próxima parte do vídeo, espero vocês lá. [MÚSICA]
