ClassCleanupAttribute, classe

Article
08/23/2008

Mise à jour : novembre 2007

Identifie une méthode qui contient le code à utiliser une fois tous les tests dans la classe de test exécutés pour libérer les ressources obtenues par la classe de test. Cette classe ne peut pas être héritée.

Espace de noms : Microsoft.VisualStudio.TestTools.UnitTesting
Assembly : Microsoft.VisualStudio.SmartDevice.UnitTestFramework (dans Microsoft.VisualStudio.SmartDevice.UnitTestFramework.dll)

Syntaxe

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

Dim instance As ClassCleanupAttribute

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

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

public final class ClassCleanupAttribute extends Attribute

Notes

La méthode marquée avec cet attribut sera exécutée après les méthodes qui sont marquées avec TestCleanupAttribute et avant celles marquées avec AssemblyCleanupAttribute. Une seule méthode peut être décorée avec cet attribut dans une classe.

Remarque importante :
Cet attribut ne doit pas être utilisé sur des tests unitaires ASP.NET, à savoir tout test avec l'attribut [HostType("ASP.NET")]. En raison de la nature sans état de IIS et de ASP.NET, une méthode décorée avec cet attribut peut être appelée plusieurs fois par série de tests.

Cet attribut peut être spécifié sur une méthode. Une seule instance de cet attribut peut être appliquée à une méthode.

Pour plus d'informations sur l'utilisation d'attributs, consultez Extension des métadonnées à l'aide des attributs.

Exemples

Les exemples suivants illustrent les attributs d'initialisation et de nettoyage utilisés pour indiquer quelles méthodes doivent être exécutées par le moteur de test à différents stades du test.

Les premiers exemples de code contiennent une classe et une méthode à tester. Pour exécuter cet exemple, créez un projet de bibliothèque de classes et remplacez le code par l'exemple suivant.

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

L'exemple suivant contient le code pour tester DivideMethod() mentionnée dans les exemples de code précédents. Créez un projet de test et mettez le code suivant dans un document de classe de test. Ajoutez les références appropriées au projet. Ce code contient des attributs qui contrôlent l'ordre d'exécution d'initialisation et de nettoyage de la méthode, de la classe et de l'assembly.

Notez en particulier l'attribut ClassCleanup sur la méthode ClassCleanup().

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

Hiérarchie d'héritage

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

Sécurité des threads

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.