Classe AssemblyInitializeAttribute

Artigo
08/25/2010

Identifica um método que contém código para ser utilizada antes que todos os testes no conjunto de módulos (assembly) foram executados e alocar recursos obtidos pelo assembly.Esta classe não pode ser herdada.

Namespace: Microsoft.VisualStudio.TestTools.UnitTesting
Assembly: Microsoft.VisualStudio.QualityTools.UnitTestFramework (em Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll)

Sintaxe

<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

Comentários

O método marcado com esse atributo será executado antes dos métodos marcados com o ClassInitializeAttribute, TestInitializeAttribute, e TestMethodAttribute atributos. Apenas um método em um assembly pode ser decorado com esse atributo.

Observação importante:
Esse atributo não deve ser usado em testes de unidade ASP.NET, ou seja, qualquer teste com [HostType("ASP.NET")] atributo. Devido à natureza sem monitoração de estado do IIS e ASP.NET, um método decorado com esse atributo pode ser chamado mais de uma vez por tempo de execução de teste.

Esse atributo pode ser especificado em um método.Apenas uma instância desse atributo pode ser aplicada a um método.

Observação:
O mecanismo de teste executa um método que é marcado com o atributo AssemblyInitialize somente se esse método for um membro de uma classe marcada com o atributo TestClass.

Para obter mais informações sobre como usar atributos, consulte Estendendo metadados usando atributos.

Exemplos

Os exemplos a seguir demonstram os atributos de limpeza que são usados para indicar quais métodos devem ser executados pelo mecanismo de teste em períodos diferentes de teste e a inicialização.

Exemplos de código primeiro contêm uma classe e método de teste.Para executar esse exemplo, criar um projeto de biblioteca de classes e substitua o código com o exemplo a seguir.

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

O exemplo a seguir contém código para testar o DivideMethod() encontrado em exemplos de código anteriores. Criar um projeto de teste e coloque o código a seguir em um documento de classe de teste.Adicione as referências apropriadas para o projeto.Esse código contém atributos que controlam a ordem de execução de inicialização e limpeza para o método, classe e assembly.

Em particular, observe o atributo AssemblyInitialize no método 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

Hierarquia de herança

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

Acesso thread-safe

Quaisquer membros static (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.