AssemblyInitializeAttribute, classe

Article
08/23/2008

Mise à jour : novembre 2007

Identifie une méthode qui contient le code à utiliser avant l'exécution de tous les tests dans l'assembly pour libérer les ressources obtenues par l'assembly. Cette classe ne peut pas être héritée.

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

Syntaxe

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

Dim instance As AssemblyInitializeAttribute

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

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

public final class AssemblyInitializeAttribute extends Attribute

Notes

La méthode marquée avec cet attribut sera exécutée avant les méthodes marquées avec les attributs ClassInitializeAttribute, TestInitializeAttribute et TestMethodAttribute. Une seule méthode peut être décorée avec cet attribut dans un assembly.

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.

Remarque :
Le moteur de test exécute une méthode marquée uniquement avec l'attribut AssemblyInitialize si cette méthode est un membre d'une classe marquée avec l'attribut TestClass.

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 qui sont 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 AssemblyInitialize sur la méthode AssemblyInit().

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

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.