package facema.teste;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import facema.modelo.banco.Agencia;
import facema.modelo.banco.Cliente;
import facema.modelo.banco.Conta;
import facema.modelo.banco.Pessoa;
import facema.modelo.banco.Poupanca;
import facema.modelo.operacional.Deposito;
import facema.modelo.operacional.Extrato;
import facema.modelo.operacional.Operacao;
import facema.modelo.operacional.Saque;
import facema.regras.RegrasDepositoEnum;
import facema.regras.RegrasExtratoEnum;
import facema.regras.RegrasSaqueEnum;

public class TesteRegras {

	Extrato extrato = new Extrato();
	Saque saque = new Saque();
	List<Operacao> operacoes;
	Deposito deposito = new Deposito();
	Pessoa pessoa = new Pessoa();
	Cliente cliente = new Cliente();
	Agencia agencia = new Agencia();
	List<Conta> contas;
	Poupanca poupanca = new Poupanca();

	private static Conta conta;

	@BeforeClass
	public static void configurarConta() {
		conta = new Conta();
		conta.setSaldo(new BigDecimal("250"));
	}

	@Test
	public void testeValorSaqueMaiorQueZero() throws Exception {

		saque.setConta(conta);
		saque.setValor(new BigDecimal("100"));

		boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertTrue(aplicavel);

	}

	@Test
	public void testeValorSaqueIgualAZero() throws Exception {

		BigDecimal valor = new BigDecimal("0.00");

		saque.setConta(conta);
		saque.setValor(valor);

		boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeValorSaqueMenorQueZero() throws Exception {

		BigDecimal valor = new BigDecimal("-100");

		saque.setConta(conta);
		saque.setValor(valor);

		boolean aplicavel = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeLimiteDiarioValorSuperiorLimitePorDia() throws Exception {

		saque.setConta(conta);
		saque.setValor(new BigDecimal("100.00"));
		conta.setSaqueHoje(new BigDecimal("50.00"));

		boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);

		Assert.assertTrue(aplicavel);
	}

	@Test
	public void testeLimiteDiarioValorInferiorLimitePorDia() throws Exception {

		BigDecimal valor = new BigDecimal("150.00");

		Saque saque = new Saque();
		saque.setConta(conta);
		saque.setValor(valor);

		boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);

		Assert.assertTrue(aplicavel);
	}

	@Test
	public void testeLimiteDiarioValorIgualAoLimite() throws Exception {

		BigDecimal valor = new BigDecimal("200.00");

		Saque saque = new Saque();
		saque.setConta(conta);
		saque.setValor(valor);

		boolean aplicavel = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);

		Assert.assertFalse(aplicavel);
	}

	@Test
	public void testeValorInferiorDisponivelParaSaqueNaConta() throws Exception {

		saque.setConta(conta);
		saque.setValor(new BigDecimal("100.00"));

		boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);

		Assert.assertTrue(aplicavel);
	}

	@Test
	public void testeValorIgualDisponivelParaSaqueNaConta() throws Exception {

		saque.setConta(conta);
		saque.setValor(new BigDecimal("250.00"));

		boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);

		Assert.assertTrue(aplicavel);
	}

	@Test
	public void testeValorSuperiorAoDisponivelParaSaqueNaConta()
			throws Exception {

		saque.setConta(conta);
		saque.setValor(new BigDecimal("300.00"));

		boolean aplicavel = RegrasSaqueEnum.LIMITE_CONTA.aplicavel(saque);

		Assert.assertFalse(aplicavel);
	}

	@Test
	public void testeFullDadosCliente() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2014");
		Date dataFinal = formatador.parse("22/11/2014");

		// Dados da agência

		agencia.setContas(contas);
		agencia.setEndereco("Rua 20 de Abril");
		agencia.setNome("Volta Redonda");

		// Dados do cliente

		cliente.setPessoa(pessoa);
		cliente.setAgencia(agencia);
		cliente.setConta(conta);
		cliente.getPessoa().setNome("Israel de Sousa Costa");
		cliente.getPessoa().setContato("9998152-7619");
		cliente.getPessoa().setCpf("99192213-11");

		// Dados de depósito

		BigDecimal valorDeposito = new BigDecimal("100.00");
		deposito.setConta(new BigDecimal("2302"));
		deposito.setDepositante(pessoa);
		deposito.setValor(valorDeposito);

		// Dados da conta

		BigDecimal saldo = new BigDecimal("500.00");

		conta.setCliente(cliente);
		conta.setExtratosMes(2);
		conta.setNumero("2302");
		conta.setPoupanca(poupanca);
		conta.setSaldo(saldo.add(valorDeposito));
		conta.setSaqueHoje(new BigDecimal("200.00"));
		conta.setTipoConta("Fisica");

		// Dados da poupança

		poupanca.setConta(conta);
		poupanca.setSaldo(new BigDecimal("500.00"));

		// Dados de extrato

		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);
		extrato.setConta(conta);
		extrato.setOperacoes(operacoes);

		// Dados de saque

		BigDecimal saqueValor = new BigDecimal("50.00");
		saque.setConta(conta);
		saque.setValor(saqueValor);

		// Saque menor que zero
		BigDecimal saqueValorMenorQueZero = new BigDecimal("-0.50");
		saque.setConta(conta);
		saque.setValor(saqueValorMenorQueZero);

		// Saque igual limite diário
		BigDecimal saqueiHoje = new BigDecimal("0.00");
		saque.setConta(conta);
		saque.setValor(saqueiHoje);
		conta.setSaqueHoje(new BigDecimal("200.00"));

		// Saque acima limite diário
		BigDecimal saqueiHojeAcima = new BigDecimal("0.00");
		saque.setConta(conta);
		saque.setValor(saqueiHojeAcima);
		conta.setSaqueHoje(new BigDecimal("500.00"));

		// Saque inferior limite diário
		BigDecimal saqueiHojeInferior = new BigDecimal("0.00");
		saque.setConta(conta);
		saque.setValor(saqueiHojeInferior);
		conta.setSaqueHoje(new BigDecimal("100.00"));

		// Saque inferior limite diário menor que zero
		BigDecimal saqueiHojeInferiorMenorQueZero = new BigDecimal("0.00");
		saque.setConta(conta);
		saque.setValor(saqueiHojeInferiorMenorQueZero);
		conta.setSaqueHoje(new BigDecimal("-20.00"));

		boolean aplicavel2 = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel2);

		boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

		Assert.assertTrue(aplicavel);

		boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertFalse(aplicavel1);

		boolean aplicavel3 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);
		Assert.assertFalse(aplicavel3);

		boolean aplicavel4 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
		Assert.assertTrue(aplicavel4);

		boolean aplicavel5 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
		Assert.assertTrue(aplicavel5);

		boolean aplicavel6 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
		Assert.assertTrue(aplicavel6);

		boolean aplicavel7 = RegrasSaqueEnum.LIMITE_DIARIO.aplicavel(saque);
		Assert.assertTrue(aplicavel7);

		System.out.println("- Dados da Agência - \n" + "Nome: "
				+ agencia.getNome() + "\nEndereço: " + agencia.getEndereco());

		System.out.println("\n- Dados de Depósito recente - " + "\nValor: R$ "
				+ deposito.getValor() + "\nDepositante: "
				+ cliente.getPessoa().getNome() + "\nContato: "
				+ cliente.getPessoa().getContato() + "\nCPF: "
				+ cliente.getPessoa().getCpf());

		System.out.println("\n- Dados de extrato - " + "\nCliente: "
				+ cliente.getPessoa().getNome() + "\nAgência: "
				+ agencia.getNome() + "\nConta: "
				+ extrato.getConta().getNumero() + "\nData inicial: "
				+ extrato.getDataInicial() + "\nData final: "
				+ extrato.getDataFinal() + "\nMês do extrato: "
				+ extrato.getConta().getExtratosMes() + "\nSaldo da conta: R$ "
				+ extrato.getConta().getSaldo());

		System.out.println("\n- Dados de saque: " + "\nCliente: "
				+ cliente.getPessoa().getNome() + "\nAgência: "
				+ agencia.getNome() + "\nConta: "
				+ saque.getConta().getNumero() + "\nValor: R$ "
				+ saque.getValor());

		System.out.println("\n- Dados da poupança após o saque - "
				+ "\nNúmero: " + poupanca.getConta().getNumero()
				+ "\nSaldo: R$ " + poupanca.getConta().getSaldo());

		System.out.println(conta.getSaldo());

	}

	@Test
	public void testeDeposito01() throws Exception {

		// Este é o teste feito com todos os campos vazios e valor inferior ao
		// mínimo permitido.

		pessoa.setCpf("");
		pessoa.setNome("");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel1);

	}

	@Test
	public void testeDeposito026() throws Exception {

		// Este é o teste feito com todos os campos vazios e valor igual ao
		// mínimo permitido.

		pessoa.setCpf("");
		pessoa.setNome("");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito027() throws Exception {

		// Este é o teste feito com todos os campos vazios e valor superior ao
		// mínimo permitido.

		pessoa.setCpf("");
		pessoa.setNome("");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito02() throws Exception {

		// Este é o teste feito apenas com os campos CPF e Nome vazios e valor
		// acima do mínimo permitido.

		pessoa.setCpf("");
		pessoa.setNome("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito03() throws Exception {

		// Este é o teste com identificação anônima feito com os campos CPF e
		// Contato vazio e valor acima do mínimo permitido.

		pessoa.setCpf("");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito04() throws Exception {

		// Este é o teste com identificação anônima com os campos CPF e Nome
		// vazios, e valor inferior ao mínimo permitido.

		pessoa.setCpf("");
		pessoa.setNome("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.VALOR_MINIMO.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito05() throws Exception {

		// Este é o teste com depósito identificado com todos os campos
		// preenchidos e valor superior ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setNome("Israel de Sousa Costa");
		pessoa.setContato("9998152-7619");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel);

	}

	@Test
	public void testeDeposito06() throws Exception {

		// Este é o teste com depósito identificado com todos os campos
		// preenchidos e valor inferior ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setNome("Israel de Sousa Costa");
		pessoa.setContato("9998152-7619");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel);

	}

	@Test
	public void testeDeposito07() throws Exception {

		// Este é o teste com depósito identificado com todos os campos
		// preenchidos e valor igual ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setNome("Israel de Sousa Costa");
		pessoa.setContato("9998152-7619");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel);

	}

	@Test
	public void testeDeposito08() throws Exception {

		// Este é o teste feito com depósito identificado apenas com o campo
		// Contato preenchido e valor inferior ao mínimo permitido.

		pessoa.setContato("9998152-7619");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito09() throws Exception {

		// Este é o teste feito com depósito identificado apenas com o campo
		// Contato preenchido e valor igual ao mínimo permitido.

		pessoa.setContato("9998152-7619");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito10() throws Exception {

		// Este é o teste feito com depósito identificado apenas com o campo
		// Contato preenchido e valor superior ao mínimo permitido.

		pessoa.setContato("9998152-7619");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito11() throws Exception {

		// Este é o teste com depósito identificado apenas com o campo CPF e
		// valor inferior ao mínimo permitido

		pessoa.setCpf("991231311231");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel1);

	}

	@Test
	public void testeDeposito12() throws Exception {

		// Este é o teste com depósito identificado apenas com o campo CPF e
		// valor igual ao mínimo permitido

		pessoa.setCpf("991231311231");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito13() throws Exception {

		// Este é o teste com depósito identificado apenas com o campo CPF e
		// valor superior ao mínimo permitido

		pessoa.setCpf("991231311231");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito14() throws Exception {

		// Este é o teste com depósito identificao apenas com o campo Nome e
		// valor inferior ao mínimo permitido.

		pessoa.setNome("Israel de Sousa Costa");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel1);

	}

	@Test
	public void testeDeposito15() throws Exception {

		// Este é o teste com depósito identificao apenas com o campo Nome e
		// valor igual ao mínimo permitido.

		pessoa.setNome("Israel de Sousa Costa");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito16() throws Exception {

		// Este é o teste com depósito identificao apenas com o campo Nome e
		// valor superior ao mínimo permitido.

		pessoa.setNome("Israel de Sousa Costa");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito17() throws Exception {

		// Este é o teste feito com depósito identificado com o campo Nome
		// preenchido e CPF vazio e valor inferior ao mínimo permitido.

		pessoa.setNome("Israel de Sousa Costa");
		pessoa.setCpf("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeDeposito18() throws Exception {

		// Este é o teste feito com depósito identificado com o campo Nome
		// preenchido e CPF vazio e valor igual ao mínimo permitido.

		pessoa.setNome("Israel de Sousa Costa");
		pessoa.setCpf("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito19() throws Exception {

		// Este é o teste feito com depósito identificado com o campo Nome
		// preenchido e CPF vazio e valor superior ao mínimo permitido.

		pessoa.setNome("Israel de Sousa Costa");
		pessoa.setCpf("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito20() throws Exception {

		// Este é o teste feito com depósito identificado apenas com o campo CPF
		// preenchido e Nome vazio com valor inferior ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setNome("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel1);
	}

	@Test
	public void testeDeposito21() throws Exception {

		// Este é o teste feito com depósito identificado apenas com o campo CPF
		// preenchido e Nome vazio com valor igual ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setNome("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito22() throws Exception {

		// Este é o teste feito com depósito identificado apenas com o campo CPF
		// preenchido e Nome vazio com valor superior ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setNome("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito23() throws Exception {

		// Este é o teste feito com depósito identificado com apenas com o campo
		// CPF preenchido e contato vazio e valor inferior ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("0.50"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel1);

	}

	@Test
	public void testeDeposito24() throws Exception {

		// Este é o teste feito com depósito identificado com apenas com o campo
		// CPF preenchido e contato vazio e valor igual ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("1.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDeposito25() throws Exception {

		// Este é o teste feito com depósito identificado com apenas com o campo
		// CPF preenchido e contato vazio e valor superior ao mínimo permitido.

		pessoa.setCpf("39485819123");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal conta = new BigDecimal("2394");

		deposito.setConta(conta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasDepositoEnum.VALOR_MINIMO
				.aplicavel(deposito);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeDepositoESaque() throws Exception {

		// Este é o teste feito com depósito identificado com apenas com o campo
		// CPF preenchido e contato vazio e valor superior ao mínimo permitido.

		Saque saque = new Saque();
		Conta conta = new Conta();

		pessoa.setCpf("39485819123");
		pessoa.setContato("");
		cliente.setPessoa(pessoa);
		conta.setCliente(cliente);

		BigDecimal numConta = new BigDecimal("2394");

		deposito.setConta(numConta);
		deposito.setValor(new BigDecimal("2.00"));
		deposito.setDepositante(pessoa);
		saque.setConta(conta);
		saque.setValor(new BigDecimal("100"));

		boolean aplicavel = RegrasDepositoEnum.DADOS_DEPOSITANTE
				.aplicavel(deposito);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertTrue(aplicavel1);

	}

	@Test
	public void testeSaqueEExtratoEmPeriodoDeUmAno() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2014");
		Date dataFinal = formatador.parse("22/11/2014");

		saque.setConta(conta);
		saque.setValor(new BigDecimal("120"));

		conta.setExtratosMes(2);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);

		boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

		Assert.assertTrue(aplicavel);

		boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertTrue(aplicavel1);
	}

	@Test
	public void testeSaqueEExtratoComDiferencaDeUmAno() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2013");
		Date dataFinal = formatador.parse("22/11/2014");

		saque.setConta(conta);
		saque.setValor(new BigDecimal("120"));

		conta.setExtratosMes(2);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);

		boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

		Assert.assertFalse(aplicavel);

		boolean aplicavel1 = RegrasSaqueEnum.VALIDACAO_VALOR.aplicavel(saque);

		Assert.assertTrue(aplicavel1);
	}

	@Test
	public void testeExtratoDiferencaDeUmAno() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2011");
		Date dataFinal = formatador.parse("22/11/2014");

		conta.setExtratosMes(2);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);

		boolean aplicavel = RegrasExtratoEnum.PERIODO_1_ANO.aplicavel(extrato);

		Assert.assertFalse(aplicavel);

	}

	@Test
	public void testeExtratoMensalGratuito() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2014");
		Date dataFinal = formatador.parse("22/11/2014");

		conta.setExtratosMes(1);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);
		extrato.setConta(conta);

		boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
				.aplicavel(extrato);

		Assert.assertFalse(aplicavel);
	}

	@Test
	public void testeExtratoMensalGratuitoPeriodoUmAno() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2014");
		Date dataFinal = formatador.parse("22/11/2014");

		conta.setExtratosMes(5);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);
		extrato.setConta(conta);

		boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
				.aplicavel(extrato);

		Assert.assertFalse(aplicavel);
	}

	@Test
	public void testeExtratoMensalGratuitoDiferencaUmAno() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2010");
		Date dataFinal = formatador.parse("22/11/2014");

		conta.setExtratosMes(5);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);
		extrato.setConta(conta);

		boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
				.aplicavel(extrato);

		Assert.assertFalse(aplicavel);
	}

	@Test
	public void testeExtratoMensalCobrado() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2014");
		Date dataFinal = formatador.parse("22/11/2014");

		conta.setExtratosMes(0);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);
		extrato.setConta(conta);

		boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
				.aplicavel(extrato);

		Assert.assertTrue(aplicavel);
	}

	@Test
	public void testeExtratoMensalCobradoDiferencaDeUmAno() throws Exception {

		SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
		Date dataInicial = formatador.parse("10/11/2011");
		Date dataFinal = formatador.parse("22/11/2014");

		conta.setExtratosMes(0);
		extrato.setDataInicial(dataInicial);
		extrato.setDataFinal(dataFinal);
		extrato.setConta(conta);

		boolean aplicavel = RegrasExtratoEnum.EXTRATO_MENSAL_GRATUITO
				.aplicavel(extrato);

		Assert.assertTrue(aplicavel);
	}

}