@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));
 }