ClassInitializeAttribute, classe

Article
08/23/2008

Mise à jour : novembre 2007

Identifie une méthode qui contient le code à utiliser avant l'exécution d'un des tests dans la classe de test pour allouer les ressources à utiliser 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 ClassInitializeAttribute _
    Inherits Attribute

Dim instance As ClassInitializeAttribute

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

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

public final class ClassInitializeAttribute extends Attribute

Notes

Lors de son exécution dans un test de charge, la méthode marquée avec cet attribut s'exécutera une fois, et les opérations d'initialisation qu'elle exécute s'appliqueront au test entier. Si vous devez effectuer des opérations d'initialisation une fois pour chaque itération d'utilisateur virtuelle présente dans le test, utilisez TestInitializeAttribute.

L'ordre d'exécution des méthodes sera :

Les méthodes marquées avec AssemblyInitializeAttribute.
Les méthodes marquées avec ClassInitializeAttribute.
Les méthodes marquées avec TestInitializeAttribute.
Les méthodes marquées avec TestMethodAttribute.

Une seule méthode d'une classe peut être décorée avec cet attribut.

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 ClassInitialize sur la méthode ClassInit().

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.ClassInitializeAttribute

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.