public void throws_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            object[] lista = new object[0];
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
            TestDelegate test = new TestDelegate(FazerNada);

            Assert.Throws(expression, test);
        }
        public void throw_exception_com_generics_utilizando_delegate_com_mensagem_e_array_de_parametros()
        {
            string errorMessage = "message";
            string throwingMessage = string.Empty;
            try
            {
                IAssert assert = new FakeAssert();
                ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

                TestDelegate test = new TestDelegate(FazerNada);
                assert.Throws<Exception>(test, errorMessage, true, true, true, true, true);
            }
            catch (Exception ex)
            {
                throwingMessage = ex.Message;
            }

            Assert.AreEqual(throwingMessage, errorMessage);
        }
        public void that_object_ref__e_expression_e_array_de_object_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            object[] lista = new object[0];
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

            Assert.That(ref Assert, expression);
        }
        public void that_test_delegate_e_expression_e_array_de_object_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            object[] lista = new object[0];
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
            TestDelegate del = new TestDelegate(FazerNada);

            Assert.That(del, expression);
        }
        public void that_object_e_expression_mensagem_e_aray_de_object_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            object[] lista = new object[0];
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

            Assert.That(Assert, expression, "mensagem", lista);
        }
        public void that_object_ref_e_expression_mensagem_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

            Assert.That(ref Assert, expression, "mensagem");
        }
        public void that_e_true_com_actual_value_delegate_e_resolve_constraint_e_mensagem_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            object[] lista = new object[0];
            ActualValueDelegate del = new ActualValueDelegate(dele);
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

            Assert.That(del, expression, "mensagem");
        }
        public void that_generico_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

            Assert.That<IAssert>(ref Assert, expression);
        }
        public void throws_e_mensagem_e_array_de_object_nao_deve_retornar_execao()
        {
            IAssert Assert = new RealAssert();
            object[] lista = new object[0];
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
            TestDelegate test = new TestDelegate(FazerNada);

            Assert.Throws(expression, test, "mensagem", lista);
        }
        public void that_del_e_expression_mensagem_e_array_de_object_nao_deve_retornar_execao()
        {
            IAssert Assert = new FakeAssert();
            object[] lista = new object[0];
            ActualValueDelegate del = new ActualValueDelegate(dele);
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

            Assert.That(del, expression, "", lista);
        }
        public void throws_com_delegate_mensagem_e_array_de_parametros_nao_deve_retornar_execao()
        {
            IAssert Assert = new RealAssert();
            object[] lista = new object[0];
            ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
            TestDelegate test = new TestDelegate(FazerNada);

            Assert.Throws<Exception>(test, string.Empty, true, true, true, true);
        }
        public void that_test_delegate_e_expression_e_array_de_object_deve_retornar_excecao_de_expressao()
        {
            string message = string.Empty;

            try
            {
                IAssert assert = new RealAssert();
                object[] lista = new object[0];
                ResolvableConstraintExpression expression = new ResolvableConstraintExpression();
                TestDelegate del = new TestDelegate(FazerNada);

                assert.That(del, expression);
            }
            catch (Exception ex)
            {
                message = ex.Message;
            }

            Assert.AreEqual(message, "A partial expression may not be resolved");
        }
        public void that_object_ref_e_expression_mensagem_e_aray_de_object_deve_retornar_excecao_de_expressao()
        {
            string message = string.Empty;

            try
            {
                IAssert assert = new RealAssert();
                object[] lista = new object[0];
                ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

                assert.That(ref assert, expression, "mensagem", lista);
            }
            catch (Exception ex)
            {
                message = ex.Message;
            }

            Assert.AreEqual(message, "A partial expression may not be resolved");
        }
        public void that_generico__deve_retornar_excecao_de_expressao()
        {
            string message = string.Empty;

            try
            {
                IAssert assert = new RealAssert();
                ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

                assert.That<IAssert>(ref assert, expression);
            }
            catch (Exception ex)
            {
                message = ex.Message;
            }

            Assert.AreEqual(message, "A partial expression may not be resolved");
        }
        public void that_e_true_com_actual_value_delegate_e_array_de_object_e_mensagem_deve_retornar_excecao_de_expressao()
        {
            string message = string.Empty;

            try
            {
                IAssert assert = new RealAssert();
                object[] lista = new object[0];
                ActualValueDelegate del = new ActualValueDelegate(SuportDelegate);
                ResolvableConstraintExpression expression = new ResolvableConstraintExpression();

                assert.That(del, expression, "jhghjg");
            }
            catch (Exception ex)
            {
                message = ex.Message;
            }

            Assert.AreEqual(message, "A partial expression may not be resolved");
        }