Compartir a través de

Glosario de atributos

  • Artículo

Atributos por espacio de nombres

PexAssumeNotNull

Este atributo declara que el valor controlado no puede ser null. Puede adjuntarse a:

  • un parámetro de un método de prueba parametrizado

    // assume foo is not null
[PexMethod]
public void SomeTest([PexAssumeNotNull]IFoo foo, ...) {}

  • un campo

    public class Foo {
   // this field should not be null
   [PexAssumeNotNull]
   public object Bar;
}

  • un tipo

    // never consider null for Foo types
[PexAssumeNotNull]
public class Foo {}

También puede adjuntarse a un ensamblado de prueba, a un accesorio de prueba o a un método de prueba; en este caso, el primer argumento debe indicar en qué campo o tipo se aplican las hipótesis. Cuando el atributo se aplica a un tipo, se aplica a todos los campos con este tipo formal.

PexClass

Este atributo marca una clase que contiene exploraciones. Es el equivalente del elemento TestClassAttribute de MSTest (o del elemento TestFixtureAttribute de NUnit). Este atributo es opcional.

Las clases marcadas con PexClass deben ser construibles de manera predeterminada:

  • tipo exportado públicamente
  • constructor predeterminado
  • no abstracto

Si la clase no cumple esos requisitos, se notifica un error y se produce un error en la exploración.

También es muy recomendable hacer que esas clases sean parciales, de manera que IntelliTest pueda generar nuevas pruebas que formen parte de la clase, pero en un archivo independiente. Este enfoque soluciona muchos problemas debido a la visibilidad y es una técnica típica en C#.

Conjunto adicional y categorías:

[TestClass] // MSTest test fixture attribute
[PexClass(Suite = "checkin")] // fixture attribute
public partial class MyTests { ... }

Especificar el tipo en la prueba:

[PexClass(typeof(Foo))] // this is a test for Foo
public partial class FooTest { ... }

La clase puede contener métodos anotados con PexMethod. IntelliTest también entiende los métodos de configuración y anulación.

PexGenericArguments

Este atributo proporciona una tupla de tipo para crear instancias de una prueba unitaria parametrizada genérica.

PexMethod

Este atributo marca un método como una prueba unitaria parametrizada. El método debe residir dentro de una clase marcada con el atributo PexClass.

IntelliTest generará pruebas sin parámetros tradicionales, que llaman a la prueba unitaria parametrizada con diferentes parámetros.

La prueba unitaria parametrizada:

  • debe ser un método de instancia
  • debe ser visible para la clase de prueba en la que se colocan las pruebas generadas según la cascada de configuración
  • puede tomar cualquier número de parámetros
  • puede ser genérica

Ejemplo

[PexClass]
public partial class MyTests {
     [PexMethod]
     public void MyTest(int i)
     { ... }
}

PexExplorationAttributeBase

Más información

PexAssemblySettings

Este atributo puede establecerse en el nivel de ensamblado para invalidar los valores de configuración predeterminados de todas las exploraciones.

using Microsoft.Pex.Framework;
// overriding the test framework selection
[assembly: PexAssemblySettings(TestFramework = "MSTestv2")]

PexAssemblyUnderTest

Este atributo especifica un ensamblado que se está probando mediante el proyecto de prueba actual.

[assembly: PexAssemblyUnderTest("MyAssembly")]

PexInstrumentAssemblyAttribute

Este atributo se usa para especificar un ensamblado que se va a instrumentar.

Ejemplo

using Microsoft.Pex.Framework;

// the assembly containing ATypeFromTheAssemblyToInstrument should be instrumented
[assembly: PexInstrumentAssembly(typeof(ATypeFromTheAssemblyToInstrument))]

// the assembly name can be used as well
[assembly: PexInstrumentAssembly("MyAssemblyName")]

PexUseType

Este atributo le indica a IntelliTest que puede usar un tipo particular para crear instancias de interfaces o tipos base (abstractos).

Ejemplo

[PexMethod]
[PexUseType(typeof(A))]
[PexUseType(typeof(B))]
public void MyTest(object testParameter)
{
     ... // IntelliTest will consider types A and B to instantiate 'testParameter'
}

PexAllowedException

Si este atributo está adjunto a PexMethod (o a PexClass, cambia la lógica de IntelliTest predeterminada que indica cuando se produce un error en las pruebas. La prueba no se considerará incorrecta, aunque genere la excepción especificada.

Ejemplo

La prueba siguiente especifica que el constructor de Stack puede generar ArgumentOutOfRangeException:

class Stack {
  int[] _elements;
  int _count;
  public Stack(int capacity) {
    if (capacity<0) throw new ArgumentOutOfRangeException();
    _elements = new int[capacity];
    _count = 0;
  }
  ...
}

El filtro se adjunta a un accesorio como se indica a continuación (también puede definirse en el nivel de prueba o ensamblado):

[PexMethod]
[PexAllowedException(typeof(ArgumentOutOfRangeException))]
class CtorTest(int capacity) {
  Stack s = new Stack(capacity); // may throw ArgumentOutOfRangeException
}

PexAllowedExceptionFromAssembly

Más información

PexAllowedExceptionFromType

Más información

PexAllowedExceptionFromTypeUnderTest

Más información

¿Tiene comentarios?

Publique sus ideas y solicitudes de características en Comunidad de desarrolladores.