@Test
public void testaGetLogin() {
Assert.assertEquals("presley", usuario1.getLogin());
Assert.assertEquals("michael", usuario2.getLogin());
Assert.assertEquals("princess", usuario3.getLogin());
Assert.assertEquals("bob", usuario4.getLogin());
}
@Test
public void testaGetEmail() {
Assert.assertEquals("*****@*****.**", usuario1.getEmail());
Assert.assertEquals("*****@*****.**", usuario2.getEmail());
Assert.assertEquals("*****@*****.**", usuario3.getEmail());
Assert.assertEquals("*****@*****.**", usuario4.getEmail());
}
@Test
public void testaGetCaronasNaoFuncionaram() {
Assert.assertTrue(usuario1.getCaronasNaoFuncionaram() == 0);
Assert.assertTrue(usuario2.getCaronasNaoFuncionaram() == 0);
Assert.assertTrue(usuario3.getCaronasNaoFuncionaram() == 0);
Assert.assertTrue(usuario4.getCaronasNaoFuncionaram() == 0);
}
@Test
public void testaGetEndereco() {
Assert.assertEquals("Rua do Sucesso", usuario1.getEndereco());
Assert.assertEquals("Rua da Felicidade", usuario2.getEndereco());
Assert.assertEquals("Rua da Beleza", usuario3.getEndereco());
Assert.assertEquals("Rua da Tranquilidade", usuario4.getEndereco());
}
@Test
public void testaGetCaronas() {
Assert.assertTrue(usuario1.getCaronas().size() == 0);
Assert.assertTrue(usuario2.getCaronas().size() == 0);
Assert.assertTrue(usuario3.getCaronas().size() == 0);
Assert.assertTrue(usuario4.getCaronas().size() == 0);
}
// Testando Metodos Get
@Test
public void testaGetNome() {
Assert.assertEquals("Elvis Presley", usuario1.getNome());
Assert.assertEquals("Michael Jackson", usuario2.getNome());
Assert.assertEquals("Princess Dianna", usuario3.getNome());
Assert.assertEquals("Bob Marley", usuario4.getNome());
}
@Test
public void testaGetPresencaEmVagas() {
Assert.assertTrue(usuario1.getPresencaEmVagas() == 0);
Assert.assertTrue(usuario2.getPresencaEmVagas() == 0);
Assert.assertTrue(usuario3.getPresencaEmVagas() == 0);
Assert.assertTrue(usuario4.getPresencaEmVagas() == 0);
}
@Test
public void testaGetListaDeSolicitacaoDeVagas() {
Assert.assertTrue(usuario1.getListaDeSolicitacaoDeVagas().size() == 0);
Assert.assertTrue(usuario2.getListaDeSolicitacaoDeVagas().size() == 0);
Assert.assertTrue(usuario3.getListaDeSolicitacaoDeVagas().size() == 0);
Assert.assertTrue(usuario4.getListaDeSolicitacaoDeVagas().size() == 0);
}
@Test
public void testaGetSolicitacaoAceitas() {
Assert.assertTrue(usuario1.getSolicitacaoAceitas().size() == 0);
Assert.assertTrue(usuario2.getSolicitacaoAceitas().size() == 0);
Assert.assertTrue(usuario3.getSolicitacaoAceitas().size() == 0);
Assert.assertTrue(usuario4.getSolicitacaoAceitas().size() == 0);
}
@Test
public void testaToString() {
Assert.assertEquals("Nome: Elvis Presley Login: presley", usuario1.toString());
Assert.assertEquals("Nome: Michael Jackson Login: michael", usuario2.toString());
Assert.assertEquals("Nome: Princess Dianna Login: princess", usuario3.toString());
Assert.assertEquals("Nome: Bob Marley Login: bob", usuario4.toString());
}
@Test
public void testaGetSenha() {
Assert.assertEquals("123mudar", usuario1.getSenha());
Assert.assertEquals("minhasenhasecreta", usuario2.getSenha());
Assert.assertEquals("soulinda", usuario3.getSenha());
Assert.assertEquals("pazeamor", usuario4.getSenha());
}
/**
* Metodo que verifica se ja existe algum usuario cadastrado com esse login
*
* @param login - recebe uma String login
* @return - Retorna True caso exista algum Usuario com esse login ou False caso nao exista.
*/
public boolean checaExisteLogin(String login) {
for (Usuario UsuarioTemp : listaDeUsuarios) {
if (UsuarioTemp.getLogin().equals(login)) {
return true;
}
}
return false;
}
/**
* Metodo que retorna das as caronas do sistema
*
* @return - retorna uma List<Carona> com todas as caronas
*/
public List<Carona> getCaronas() {
List<Carona> retorno = new LinkedList<Carona>();
for (Usuario UsuarioTemp : listaDeUsuarios) {
retorno.addAll(UsuarioTemp.getCaronas());
}
return retorno;
}
/**
* Metodo que verifica se ja existe algum usuario cadastrado com esse email
*
* @param email - Recebe uma String email
* @return - Retorna True caso exista algum Usuario com esse email ou False caso nao exista.
*/
public boolean checaExisteEmail(String email) {
for (Usuario UsuarioTemp : listaDeUsuarios) {
if (UsuarioTemp.getEmail().equals(email)) {
return true;
}
}
return false;
}
/**
* Metodo que busca um usuário através do seu login
*
* @param login - recebe um login como paramêtro
* @return - Retorna um Usuario caso exista algum com esse login ou retorna null caso não exista.
*/
public Usuario buscaUsuarioLogin(String login) {
Usuario retorno = null;
for (Usuario usuario : listaDeUsuarios) {
if (usuario.getLogin().equals(login)) {
retorno = usuario;
}
}
return retorno;
}
/**
* Metodo que procura uma carona pelo seu ID
*
* @param idCarona - Recebe uma String ID
* @return - Retorna uma Carona caso exista uma carona com o ID passado
* @throws CaronaException - Lança exceção caso nao exista esse ID associado a uma carona
*/
public Carona getCaronaId(String idCarona) throws CaronaException {
for (Usuario usuario : listaDeUsuarios) {
for (Carona caronaTemp : usuario.getCaronas()) {
if (caronaTemp.getIdCarona().equals(idCarona)) {
return caronaTemp;
}
}
}
return null;
}
/**
* Metodo que localiza uma carona pelo seu ID
*
* @param idCarona - Recebe uma String idCarona
* @return - retrorna uma Carona caso exista alguma com o ID passado
*/
public Carona localizaCaronaPorId(String idCarona) {
for (Usuario usuarioTemp : listaDeUsuarios) {
for (Carona caronaTemp : usuarioTemp.getCaronas()) {
if (caronaTemp.getIdCarona().equals(idCarona)) {
return caronaTemp;
}
}
}
return null;
}
/**
* Metodo que localiza uma solicitacao de vaga por um ID
*
* @param idSolicitacao - Recebe uma String idSolicitacao
* @return - Retorna uma SolicitacaoDeVaga caso exista alguma solicitacao com o Id passado.
*/
public SolicitacaoDeVaga localizaSolicitacaoPorId(String idSolicitacao) {
for (Usuario usuarioTemp : listaDeUsuarios) {
for (SolicitacaoDeVaga solicitacaoTemp : usuarioTemp.getListaDeSolicitacaoDeVagas()) {
if (solicitacaoTemp.getIdSolicitacao().equals(idSolicitacao)) {
return solicitacaoTemp;
}
}
}
return null;
}
/**
* Metodo que retorna todas as Caronas cadastradas no sistema.
*
* @return - Retorna uma List<Carona> com todas as caronas cadastradas no sistema.
*/
public List<Carona> getTodasAsCaronas() {
List<Carona> retorno = new LinkedList<Carona>();
for (Usuario usuario : listaDeUsuarios) {
for (Carona caronaTemp : usuario.getCaronas()) {
retorno.add(caronaTemp);
}
}
return retorno;
}
/**
* Metodo que busca um Usuario através do email
*
* @param email - Recebe uma String email e procura algum Usuario com esse Email
* @return - Retorna o Usuario caso exista ou null se nao existir.
*/
public Usuario buscaUsuarioEmail(String email) {
Usuario retorno = null;
for (Usuario usuario : listaDeUsuarios) {
if (usuario.getEmail().equals(email)) {
retorno = usuario;
}
}
return retorno;
}
// Testando Metodos especificos
@Test
public void testaCadastrarCarona() throws CaronaException, NumeroMaximoException {
calendar = UtilInfo.converteStringEmCalendar("22/12/2013", "22:00");
usuario1.cadastrarCarona("Campina Grande", "João Pessoa", calendar, 3, id.gerarId());
calendar = UtilInfo.converteStringEmCalendar("10/10/2013", "10:00");
usuario2.cadastrarCarona("Campina Grande", "Recife", calendar, 1, id.gerarId());
calendar = UtilInfo.converteStringEmCalendar("06/08/2013", "12:00");
usuario3.cadastrarCarona("João Pessoa", "Natal", calendar, 2, id.gerarId());
}
/**
* Metodo que localiza um Usuario pelo seu nome
*
* @param nome - Recebe um String nome como parametro
* @return - Retorna uma List<Usuario> com os Usuario que possuem esse nome.
*/
public List<Usuario> buscaUsuarioNome(String nome) {
List<Usuario> retorno = new LinkedList<Usuario>();
for (Usuario usuario : listaDeUsuarios) {
if (usuario.getNome().equals(nome)) {
retorno.add(usuario);
}
}
return retorno;
}
/**
* Metodo que localiza uma carona que possua destino específico
*
* @param destino- Recebe uma String destino
* @return - Retorna uma Carona que possua o destino especificado
*/
public List<Carona> localizaCaronaPorDestino(String destino) {
List<Carona> retorno = new LinkedList<Carona>();
for (Usuario UsuarioTemp : listaDeUsuarios) {
for (Carona caronaTemp : UsuarioTemp.getCaronas()) {
if (caronaTemp.getDestino().equals(destino)) {
retorno.add(caronaTemp);
}
}
}
return retorno;
}
/**
* Metodo que localiza uma carona que possua uma origem específica
*
* @param origem- Recebe uma String origem
* @return - Retorna uma Carona que possua a origem especificada
*/
public List<Carona> localizaCaronaPorOrigem(String origem) {
List<Carona> retorno = new LinkedList<Carona>();
for (Usuario UsuarioTemp : listaDeUsuarios) {
for (Carona caronaTemp : UsuarioTemp.getCaronas()) {
if (caronaTemp.getOrigem().equals(origem)) {
retorno.add(caronaTemp);
}
}
}
return retorno;
}
@Test
public void testaSetCaronasSeguras() {
Assert.assertFalse(usuario1.getCaronasSeguras() < 0);
Assert.assertFalse(usuario2.getCaronasSeguras() < 0);
Assert.assertFalse(usuario3.getCaronasSeguras() < 0);
Assert.assertFalse(usuario4.getCaronasSeguras() < 0);
Assert.assertTrue(usuario3.getCaronasSeguras() == 0);
usuario3.setCaronasSeguras();
usuario3.setCaronasSeguras();
Assert.assertTrue(usuario3.getCaronasSeguras() == 2);
Assert.assertTrue(usuario4.getCaronasSeguras() == 0);
usuario4.setCaronasSeguras();
Assert.assertTrue(usuario4.getCaronasSeguras() == 1);
}
@Test
public void testaSetCaronasNaoFuncionaram() {
Assert.assertFalse(usuario1.getCaronasNaoFuncionaram() < 0);
Assert.assertFalse(usuario2.getCaronasNaoFuncionaram() < 0);
Assert.assertFalse(usuario3.getCaronasNaoFuncionaram() < 0);
Assert.assertFalse(usuario4.getCaronasNaoFuncionaram() < 0);
Assert.assertTrue(usuario1.getCaronasNaoFuncionaram() == 0);
usuario1.setCaronasNaoFuncionaram();
usuario1.setCaronasNaoFuncionaram();
Assert.assertTrue(usuario1.getCaronasNaoFuncionaram() == 2);
Assert.assertTrue(usuario2.getCaronasNaoFuncionaram() == 0);
usuario2.setCaronasNaoFuncionaram();
Assert.assertTrue(usuario2.getCaronasNaoFuncionaram() == 1);
}
/**
* Metodo que retorna uma lista com as Caronas Rachadas que possuem origem e destino passado como
* parametro.
*
* @param origem - Recebe uma String origem
* @param destino - Recebe uma String destino
* @return - Retorna uma List<Carona> com as caronas Rachadas.
*/
public List<Carona> localizarCaronaRachada(String origem, String destino) {
List<Carona> retorno = new LinkedList<Carona>();
for (Usuario usuarioTemp : listaDeUsuarios) {
for (Carona caronaTemp : usuarioTemp.getCaronas()) {
if (caronaTemp.getTipoCarona().equals(TiposCarona.RACHADACOMUM)
|| caronaTemp.getTipoCarona().equals(TiposCarona.RACHADAESCAPADA)
|| caronaTemp.getTipoCarona().equals(TiposCarona.RACHADAMUNICIPAL)) {
if (caronaTemp.getOrigem().equals(origem) && caronaTemp.getDestino().equals(destino)) {
retorno.add(caronaTemp);
}
}
}
}
return retorno;
}
@Test
public void testaSetFaltasEmVagas() {
Assert.assertTrue(usuario1.getFaltasEmVagas() == 0);
Assert.assertTrue(usuario2.getFaltasEmVagas() == 0);
Assert.assertTrue(usuario3.getFaltasEmVagas() == 0);
Assert.assertTrue(usuario4.getFaltasEmVagas() == 0);
usuario3.setFaltasEmVagas();
usuario3.setFaltasEmVagas();
usuario3.setFaltasEmVagas();
usuario3.setFaltasEmVagas();
Assert.assertTrue(usuario3.getFaltasEmVagas() == 4);
usuario4.setFaltasEmVagas();
usuario4.setFaltasEmVagas();
usuario4.setFaltasEmVagas();
Assert.assertTrue(usuario4.getFaltasEmVagas() == 3);
}
/**
* Metodo que localiza uma CaronaMunicipal através da CIDADE
*
* @param cidade - Recebe uma String cidade
* @return - retorna uma List<Carona> com as carona municipais que possuem a Cidade passada
* @throws CaronaException - Lança exceção caso nao exista essa cidade.
*/
public List<Carona> localizarCaronaMunicipal(String cidade) throws CaronaException {
List<Carona> retorno = new LinkedList<Carona>();
boolean existeCidade = false;
for (Usuario UsuarioTemp : listaDeUsuarios) {
for (Carona caronaTemp : UsuarioTemp.getCaronas()) {
if (caronaTemp.getTipoCarona().equals(TiposCarona.MUNICIPAL)) {
if (((CaronaMunicipal) caronaTemp).getCidade().equals(cidade)) {
existeCidade = true;
retorno.add(caronaTemp);
}
}
}
}
if (!existeCidade) {
throw new CaronaException("Cidade inexistente");
}
return retorno;
}
@Test
public void testaEquals() {
Assert.assertTrue(usuario1.equals(usuario1));
Assert.assertTrue(usuario2.equals(usuario2));
Assert.assertTrue(usuario3.equals(usuario3));
Assert.assertTrue(usuario4.equals(usuario4));
Assert.assertFalse(usuario1.equals(usuario2));
Assert.assertFalse(usuario1.equals(usuario3));
Assert.assertFalse(usuario1.equals(usuario4));
Assert.assertFalse(usuario2.equals(usuario3));
Assert.assertFalse(usuario2.equals(usuario4));
Assert.assertFalse(usuario3.equals(usuario4));
}