AssemblyCleanupAttribute (Clase)

Artículo
08/23/2008

Actualización: noviembre 2007

Identifica un método que contiene un código que se utilizará después de la ejecución de todas las pruebas del ensamblado y para liberar los recursos obtenidos por el ensamblado. Esta clase no puede heredarse.

Espacio de nombres: Microsoft.VisualStudio.TestTools.UnitTesting
Ensamblado: Microsoft.VisualStudio.SmartDevice.UnitTestFramework (en Microsoft.VisualStudio.SmartDevice.UnitTestFramework.dll)

Sintaxis

<AttributeUsageAttribute(AttributeTargets.Method, AllowMultiple := False)> _
Public NotInheritable Class AssemblyCleanupAttribute _
    Inherits Attribute

Dim instance As AssemblyCleanupAttribute

[AttributeUsageAttribute(AttributeTargets.Method, AllowMultiple = false)]
public sealed class AssemblyCleanupAttribute : Attribute

[AttributeUsageAttribute(AttributeTargets::Method, AllowMultiple = false)]
public ref class AssemblyCleanupAttribute sealed : public Attribute

public final class AssemblyCleanupAttribute extends Attribute

Comentarios

El método marcado con este atributo se ejecutará después de los métodos marcados con los atributos TestCleanupAttribute y ClassCleanupAttribute. No se ejecuta si se inicia una excepción no controlada. Un método que tiene un atributo AssemblyCleanupAttribute se ejecuta si no está en la misma clase que el método de prueba. Sólo un método de un ensamblado puede ser representativo en este atributo.

Nota importante:
Este atributo no debe utilizarse en pruebas unitarias de ASP.NET; es decir, cualquier prueba con el atributo [HostType("ASP.NET")]. Debido a la naturaleza independiente de IIS y ASP.NET, se llamará a un método representativo en este atributo más de una vez por cada prueba realizada.

Este atributo puede especificarse en un método. Sólo se puede aplicar a un método una instancia de este atributo.

Para obtener más información sobre cómo utilizar los atributos, vea Extender metadatos mediante atributos.

Ejemplos

En los ejemplos siguientes se muestran los atributos de inicialización y limpieza utilizados para indicar qué métodos debe ejecutar el motor de prueba en los distintos períodos de la prueba.

Los primeros ejemplos de código contienen una clase y un método para probar. Para ejecutar este ejemplo, cree un proyecto de biblioteca de clases y reemplace el código con el ejemplo siguiente.

using System;

namespace SampleClassLib
{
    public class DivideClass
    {
        public static int DivideMethod(int denominator)
        {
            return (2 / denominator);
        }
    }
}

Imports System

Namespace SampleClassLib
    Public Class DivideClass
        Shared Function DivideMethod(ByVal denominator As Integer) As Integer
            Return 2 \ denominator
        End Function
    End Class
End Namespace

El ejemplo siguiente contiene código para probar el DivideMethod() de los ejemplos de código anteriores. Cree un proyecto de prueba y coloque el código siguiente en un documento de clase de prueba. Agregue las referencias adecuadas al proyecto. Este código contienen atributos que controlan el orden de ejecución de la inicialización y la limpieza para el método, la clase y el ensamblado.

En concreto, tenga en cuenta el atributo AssemblyCleanup del método AssemblyCleanup().

using Microsoft.VisualStudio.TestTools.UnitTesting;
using SampleClassLib;
using System;
using System.Windows.Forms;

namespace TestNamespace
{
    [TestClass()]
    public sealed class DivideClassTest
    {
        [AssemblyInitialize()]
        public static void AssemblyInit(TestContext context)
        {
            MessageBox.Show("AssemblyInit " + context.TestName);
        }

        [ClassInitialize()]
        public static void ClassInit(TestContext context)
        {
            MessageBox.Show("ClassInit " + context.TestName);
        }

        [TestInitialize()]
        public void Initialize()
        {
            MessageBox.Show("TestMethodInit");
        }

        [TestCleanup()]
        public void Cleanup()
        {
            MessageBox.Show("TestMethodCleanup");
        }

        [ClassCleanup()]
        public static void ClassCleanup()
        {
            MessageBox.Show("ClassCleanup");
        }

        [AssemblyCleanup()]
        public static void AssemblyCleanup()
        {
            MessageBox.Show("AssemblyCleanup");
        }

        [TestMethod()]
        [ExpectedException(typeof(System.DivideByZeroException))]
        public void DivideMethodTest()
        {
            DivideClass.DivideMethod(0);
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports SampleClassLib2.SampleClassLib
Imports System
Imports System.IO
Imports System.Windows.Forms

Namespace TestNamespace
    <TestClass()> _
    Public NotInheritable Class DivideClassTest
        <AssemblyInitialize()> _
        Public Shared Sub AssemblyInit(ByVal context As TestContext)
            MsgBox("AssemblyInit " + context.TestName)
        End Sub 'AssemblyInit

        <ClassInitialize()> _
        Public Shared Sub ClassInit(ByVal context As TestContext)
            MsgBox("ClassInit " + context.TestName)
        End Sub 'ClassInit

        <TestInitialize()> _
        Public Sub Initialize()
            MsgBox("TestMethodInit")
        End Sub 

        <TestCleanup()> _
        Public Sub Cleanup()
            MsgBox("TestMethodCleanup")
        End Sub 

        <ClassCleanup()> _
        Public Shared Sub ClassCleanup()
            MsgBox("ClassCleanup")
        End Sub 

        <AssemblyCleanup()> _
        Public Shared Sub AssemblyCleanup()
            MsgBox("AssemblyCleanup")
        End Sub

        <TestMethod()> _
        <ExpectedException(GetType(System.DivideByZeroException))> _
        Public Sub DivideMethodTest()
            DivideClass.DivideMethod(0)
        End Sub
    End Class
End Namespace

Jerarquía de herencia

System.Object
System.Attribute
Microsoft.VisualStudio.TestTools.UnitTesting.AssemblyCleanupAttribute

Seguridad para subprocesos

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.