public void ObterInvalidoTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            BlocoModel       actual = target.Obter(-1);

            Assert.IsNull(actual);
        }
        public void GerenciadorBlocoConstructorTest()
        {
            IUnitOfWork      unitOfWork = null; // TODO: Initialize to an appropriate value
            GerenciadorBloco target     = new GerenciadorBloco(unitOfWork);

            Assert.Inconclusive("TODO: Implement code to verify target");
        }
 public MoradiaController()
 {
     gMoradia       = new GerenciadorMoradia();
     gBloco         = new GerenciadorBloco();
     gPessoa        = new GerenciadorPessoa();
     gCondominio    = new GerenciadorCondominio();
     gPessoaMoradia = new GerenciadorPessoaMoradia();
 }
Exemple #4
0
 public VeiculoController()
 {
     gVeiculo       = new GerenciadorVeiculo();
     gPessoaMoradia = new GerenciadorPessoaMoradia();
     gMoradia       = new GerenciadorMoradia();
     gCondominio    = new GerenciadorCondominio();
     gBloco         = new GerenciadorBloco();
 }
        public void ObterPorCondominioInvalidoTest()
        {
            GerenciadorBloco target         = new GerenciadorBloco();
            int idCondominio                = -1;
            IEnumerable <BlocoModel> actual = target.ObterPorCondominio(idCondominio);

            Assert.Equals(actual.Count(), 0);
        }
        public void ObterTodosTest()
        {
            GerenciadorBloco         target   = new GerenciadorBloco();
            IEnumerable <BlocoModel> expected = target.ObterTodos();

            Assert.IsInstanceOfType(expected, typeof(IEnumerable <BlocoModel>));
            Assert.Equals(expected.Count(), 5);
        }
 public PerfisController()
 {
     gMoradia         = new GerenciadorMoradia();
     gBloco           = new GerenciadorBloco();
     gPessoa          = new GerenciadorPessoa();
     gCondominio      = new GerenciadorCondominio();
     gPessoaMoradia   = new GerenciadorPessoaMoradia();
     gRestricaoAcesso = new GerenciadorRestricaoAcesso();
 }
        public void AtribuirTest()
        {
            GerenciadorBloco target = new GerenciadorBloco(); // TODO: Initialize to an appropriate value

            //BlocoModel blocoModel = null; // TODO: Initialize to an appropriate value
            //tb_bloco blocoE = null; // TODO: Initialize to an appropriate value
            //target.Atribuir(blocoModel, blocoE);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
        public void GetInstanceTest()
        {
            GerenciadorBloco expected = null; // TODO: Initialize to an appropriate value
            GerenciadorBloco actual;

            actual = GerenciadorBloco.GetInstance();
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }
        public void RemoverTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            int idBloco             = 5;

            target.Remover(idBloco);
            BlocoModel bloco = target.Obter(idBloco);

            Assert.IsNull(bloco);
        }
        public void ObterPorCondominioValidoTest()
        {
            GerenciadorBloco target         = new GerenciadorBloco();
            int idCondominio                = 4;
            IEnumerable <BlocoModel> actual = target.ObterPorCondominio(idCondominio);

            Assert.Equals(actual.Count(), 2);
            foreach (var bloco in actual)
            {
                Assert.Equals(idCondominio, bloco.IdCondominio);
            }
        }
        public void ObterValidoTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            BlocoModel       actual = target.Obter(3);

            Assert.IsNotNull(actual);
            Assert.Equals(actual.IdCondominio, 3);
            Assert.Equals(actual.Nome, "Olimpo");
            Assert.Equals(actual.QuantidadeAndares, 12);
            Assert.Equals(actual.QuantidadeMoradias, 48);
            Assert.IsInstanceOfType(actual, typeof(BlocoModel));
        }
        public void EditarValidoTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            BlocoModel       bloco  = target.Obter(6);

            bloco.Nome = "Rosa";
            target.Editar(bloco);
            BlocoModel actual = target.Obter(6);

            Assert.IsNotNull(actual);
            Assert.Equals(bloco.Nome, actual.Nome);
        }
        public void EditarInvalidoTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            BlocoModel       bloco  = target.Obter(6);

            bloco.Nome = null;
            try
            {
                target.Editar(bloco);
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(ServiceException));
            }
            BlocoModel actual = target.Obter(3);

            Assert.Equals(actual.Nome, bloco.Nome);
        }
        public void InserirValidoTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            BlocoModel       bloco  = new BlocoModel();

            bloco.IdCondominio       = 3;
            bloco.Nome               = "Templo de Era";
            bloco.QuantidadeAndares  = 1;
            bloco.QuantidadeMoradias = 8;
            int idBloco = target.Inserir(bloco);

            Assert.IsTrue(idBloco > 0);
            BlocoModel blocoInserido = target.Obter(idBloco);

            Assert.IsNotNull(blocoInserido);
            Assert.Equals(bloco.IdCondominio, blocoInserido.IdCondominio);
            Assert.Equals(bloco.Nome, blocoInserido.Nome);
            Assert.Equals(bloco.QuantidadeAndares, blocoInserido.QuantidadeAndares);
            Assert.Equals(bloco.QuantidadeMoradias, blocoInserido.QuantidadeMoradias);
        }
        public void InserirInvalidoTest()
        {
            GerenciadorBloco target = new GerenciadorBloco();
            BlocoModel       bloco  = new BlocoModel();

            bloco.IdCondominio       = 3;
            bloco.Nome               = null;
            bloco.QuantidadeAndares  = 1;
            bloco.QuantidadeMoradias = 8;
            int actual = 0;

            try
            {
                actual = target.Inserir(bloco);
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(ServiceException));
            }
            BlocoModel blocoInserido = target.Obter(actual);

            Assert.IsNull(blocoInserido);
        }
 public BlocoController()
 {
     gBloco      = new GerenciadorBloco();
     gCondominio = new GerenciadorCondominio();
 }
        public void GerenciadorBlocoConstructorTest1()
        {
            GerenciadorBloco target = new GerenciadorBloco();

            Assert.Inconclusive("TODO: Implement code to verify target");
        }