NUnit C# – Basic tests

Teste Unitário é um nível de teste de software em que “unidades individuais” / “componentes de um software” são testados. O objetivo é validar que cada unidade do software tenha o desempenho planejado. Uma unidade é a menor parte testável de qualquer software. Geralmente tem uma ou algumas entradas e geralmente uma única saída.

Na programação procedural, uma unidade pode ser um programa individual, função, procedimento, etc. Na programação orientada a objetos, a menor unidade é um método, que pode pertencer a uma classe base / super, classe abstrata ou derivada / classe filha. (Alguns tratam um módulo de uma aplicação como uma unidade. Isso deve ser desencorajado, pois provavelmente haverá muitas unidades individuais dentro desse módulo.) Estruturas de testes de unidades, drivers, stubs e objetos simulados / falsos são usados para auxiliar no teste de unidade.

NUnit c#

Retirado do nunit.org
– NUnit é um framework de teste de unidade para todas as linguagens .Net. É um software de código aberto e o NUnit 3 é lançado sob a licença do MIT. Versões anteriores usavam a licença NUnit. Ambas as licenças permitem o uso do NUnit em aplicativos gratuitos e comerciais e bibliotecas sem restrições.

Que tal alguns testes basicos?

Segue abaixo um exemplo básico de teste usando NUnit. O exemplo é montado para possuir um teste para cada um dos metodos que retornam os tipos mais comuns de variaveis no c#.

Classe de exemplo BasicSample

namespace SampleNUnitProgram
{
    public class BasicSample
    {
        /// <summary>
        /// Simple function that sum two integers
        /// </summary>
        /// <param name="x">int</param>
        /// <param name="y">int</param>
        /// <returns>int - the sum of the values</returns>
        public int ReturnIntSumValue(int x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// Simple function that sum a float to a int
        /// </summary>
        /// <param name="x">float</param>
        /// <param name="y">int</param>
        /// <returns>float - the sum of the values</returns>
        public float ReturnFloatSumValue(float x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// Simple function that sum a long to a int
        /// </summary>
        /// <param name="x">long</param>
        /// <param name="y">int</param>
        /// <returns>long - the sum of the values</returns>
        public long ReturnLongSumValue(long x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// Simple function that sum a double to a int
        /// </summary>
        /// <param name="x">double</param>
        /// <param name="y">int</param>
        /// <returns>double - the sum of the values</returns>
        public double ReturnDoubleSumValue(double x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// Simple function that sum a int to a int
        /// </summary>
        /// <param name="x">int</param>
        /// <param name="y">int</param>
        /// <returns>boolean - true if x igual y</returns>
        public bool ReturnBooleanCompare(int x, int y)
        {
            return x == y;
        }

        /// <summary>
        /// Simple function that sum a int to a int
        /// </summary>
        /// <param name="x">int</param>
        /// <param name="y">int</param>
        /// <returns>string - the sum of the values in string format</returns>
        public string ReturnStringSumValue(int x, int y)
        {
            return (x + y).ToString();
        }

        /// <summary>
        /// Simple function that sum a float to a int
        /// </summary>
        /// <param name="x">float</param>
        /// <param name="y">int</param>
        /// <returns>float - the sum of the values</returns>
        public char ReturnChargSumValue(int x, int y)
        {
            return (x + y).ToString()[0];
        }
    }
}

Classe de teste BasicSampleTests

using NUnit.Framework;
namespace SampleNUnitProgram.Tests
{
    [TestFixture]
    class BasicSampleTests
    {
        [Test]
        public void ShouldReturnIntSumValue()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnIntSumValue(3, 7), Is.EqualTo(10));
        }
        [Test]
        public void ShouldReturnFloatSumValue()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnFloatSumValue(10.2F, 7), Is.EqualTo(17.2F));
        }
        [Test]
        public void ShouldReturnLongSumValue()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnLongSumValue(9999999999, 7), Is.EqualTo(10000000006));
        }
        [Test]
        public void ShouldReturnDoubleSumValue()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnDoubleSumValue(10.2, 7), Is.EqualTo(17.2));
        }
        [Test]
        public void ShouldReturnBooleanCompare()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnBooleanCompare(10, 7), Is.False);
            Assert.That(basicSample.ReturnBooleanCompare(7, 7), Is.True);
        }
        [Test]
        public void ShouldReturnStringSumValue()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnStringSumValue(10, 7), Is.EqualTo("17"));
        }
        [Test]
        public void ShouldReturnChargSumValue()
        {
            var basicSample = new BasicSample();
            Assert.That(basicSample.ReturnChargSumValue(20, 7), Is.EqualTo('2'));
        }
    }
}

Os testes acima são os mais simples que eu conseguie organizar para um exemplo usando NUnit.

Qualquer dúvida ou dicas, entre em contato: leandrolt@gmail.com

Referencia:
Site: softwaretestingfundamentals.com/unit-testing/
Site: nunit.org/docs/2.6/attributes.html

Post navigation

Leave a Reply

Your email address will not be published. Required fields are marked *