Classe ClassInitializeAttribute

Artigo
08/25/2010

Identifica um método que contém código que deve ser utilizado antes que qualquer um dos testes na classe de teste foram executados e alocar os recursos a serem usados por classe de teste.Esta classe não pode ser herdada.

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

Sintaxe

<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

Comentários

Quando executado em um teste de carga, o método marcado com esse atributo serão executados uma vez, e qualquer operação de inicialização realiza serão aplicadas ao teste de inteiro.Se você precisar realizar operações de inicialização uma vez para cada usuário virtual iteração no teste, use o TestInitializeAttribute.

A ordem que serão executados métodos é:

Métodos marcados com o AssemblyInitializeAttribute.
Métodos marcados com o ClassInitializeAttribute.
Métodos marcados com o TestInitializeAttribute.
Métodos marcados com o TestMethodAttribute.

Apenas um método em uma classe 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.

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

Exemplos

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

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 ClassInitialize no método 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

Hierarquia de herança

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

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.