Framework verifiëren

Om het schrijven van tests eenvoudiger te maken, biedt TAEF het framework 'Verifiëren' dat gebruikmaakt van de WexLogger om gedetailleerde logboeken met een minimale hoeveelheid code te rapporteren. Het Verificatieframework helpt tests om gestructureerde logboekuitvoer te bieden. Het voert een geslaagd logboek uit als een bepaalde verificatie is geslaagd en geeft gedetailleerde informatie weer als een verificatie mislukt.

Verifiëren vanuit C++ gebruiken

De Verificatie-API wordt in C++ weergegeven als een set macro's die zijn gedefinieerd in het headerbestand Verify.h (Opmerking: U hoeft Verify.h niet expliciet verify.h op te nemen, u moet 'WexTestClass.h' opnemen die alles bevat wat u nodig hebt voor het markeren van C++-tests en het werken met de Verify and WexLogger-API's).

De volgende controlemacro's zijn beschikbaar voor systeemeigen C++-tests:

Gebruik op basis van uitzonderingen controleren

Als uw broncode is gecompileerd met C++-uitzonderingen ingeschakeld (door de schakeloptie '/EHsc' of de macro 'USE_NATIVE_EH=1' in een bronbestand op te geven), worden de macro's standaard ingesteld op het vastleggen van een fout bij een fout, gevolgd door het genereren van een systeemeigen C++-uitzondering. De uitzondering die is opgetreden, is een WEX::TestExecution::VerifyFailureException. U hoeft deze uitzondering niet op te vangen. Het TAEF-framework zal dit voor u opvangen en doorgaan met de volgende testcase.

Als u desgewenst een reeks verificaties in een rij wilt uitvoeren in plaats van de test af te breken bij de eerste verificatiefout, kunt u de klasse DisableVerifyExceptions gebruiken. De levensduur van het object bepaalt de hoeveelheid tijd die uitzonderingen zijn uitgeschakeld.

if (NULL != m_key)
{
    DisableVerifyExceptions disable;
    VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName));
    VERIFY_WIN32_SUCCEEDED(::RegCloseKey(m_key));
}

In het bovenstaande voorbeeld worden uitzonderingen alleen uitgeschakeld binnen het blok if (NULL != m_key), en als de eerste controle-aanroep mislukt, wordt de tweede verificatie-aanroep nog steeds uitgevoerd.

De klasse DisableVerifyExceptions heeft ref-counting en werkt ook per thread.

Gebruik zonder uitzonderingen verifiëren

Als uw broncode niet is gecompileerd met C++-uitzonderingen ingeschakeld, zullen de Verify-macro's geen systeemeigen C++-uitzondering genereren wanneer verificaties mislukken. Als uw broncode is gecompileerd met C++-uitzonderingen ingeschakeld, maar u de Verificatieuitzonderingen wilt uitschakelen, definieert u eenvoudigweg #define NO_VERIFY_EXCEPTIONS voordat u 'WexTestClass.h' opneemt.

In dit model moet u een reeks geneste if-instructies uitvoeren om de stroom van uw testcase te beheren in plaats van te vertrouwen op C++-uitzonderingen.

if (VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName)))
{
    ...
}

Uitvoerinstellingen controleren

Als u de uitvoer wilt aanpassen die wordt geproduceerd door de Verify-API's, kunt u de klasse SetVerifyOutput gebruiken. De levensduur van het object bepaalt hoe lang de uitvoerinstellingen worden ingesteld. De klasse SetVerifyOutput is reference-geteld en functioneert per thread.

if (NULL != m_key)
{
    SetVerifyOutput verifySettings(VerifyOutputSettings::LogOnlyFailures);
    VERIFY_IS_TRUE(true, L"Should NOT log a comment");
    VERIFY_IS_TRUE(false, L"Should log an error");
}
VERIFY_IS_TRUE(true, L"Should log a comment");

In het bovenstaande voorbeeld hebben de opgegeven instellingen alleen betrekking op aanroepen die worden gedaan in het blok if (NULL != m_key), en alleen de verificatie-aanroep die mislukt, wordt vastgelegd. De derde verificatie-aanroep wordt echter geregistreerd, ook al lukt het wel. Dit komt doordat de klasse SetVerifyOutput buiten het bereik is gegaan.

Er zijn de volgende opties voor het instellen van de controle-uitvoer:

VerifyOutputSettings::LogOnlyFailures
Alleen mislukte verificatie van aanroepen worden geregistreerd; alle geslaagde oproepen worden genegeerd.

VerifyOutputSettings::LogFailuresAsBlocked
Registreer alle fouten zoals geblokkeerd in plaats van een fout te registreren.

VerifyOutputSettings::LogFailuresAsWarnings
Registreer alle fouten als waarschuwingen in plaats van een fout te registreren.

VerifyOutputSettings::LogValuesOnSuccess
Registreer de waarden van parameters die zijn doorgegeven, zelfs wanneer de aanroep Verifiëren is geslaagd.

Controleer of de uitvoerinstellingen kunnen worden gecombineerd om meerdere instellingen te activeren.

SetVerifyOutput verifySettings(VerifyOutputSettings::LogOnlyFailures | VerifyOutputSettings::LogFailuresAsBlocked);

Uitvoer van waarde opgeven voor aangepaste typen

Het C++ Verify-framework biedt de mogelijkheid om gedetailleerde uitvoer te genereren voor elk aangepast type. Hiervoor moet men een specialisatie van de WEX::TestExecution::VerifyOutputTraits-klassesjabloon implementeren.

De WEX::TestExecution::VerifyOutputTraits klassesjabloonspecialisatie moet bestaan in de WEX::TestExecution-naamruimte . Er wordt ook een openbare statische methode met de naam ToString geboden, die een verwijzing naar uw klasse neemt en een WEX::Common::NoThrowString retourneert die een tekenreeksweergave van de waarde bevat.

    class MyClass
    {
    public:
        MyClass(int value)
            : m_myValue(value)
        {
        }

        int GetValue()
        {
            return m_myValue;
        }

    private:
        int m_myValue;
    }

    namespace WEX { namespace TestExecution
    {
        template <>
        class VerifyOutputTraits<MyClass>
        {
        public:
            static WEX::Common::NoThrowString ToString(const MyClass& myClass)
            {
                return WEX::Common::NoThrowString().Format(L"%d", myClass.GetValue());
            }
        };
    }}

Vergelijkingen voor aangepaste typen verleent

Het C++ Verify-framework biedt de mogelijkheid om comparators te definiëren voor aangepaste typen die geen bijbehorende operatoroverbelastingen implementeren (operator=, operator<, enzovoort). Hiervoor moet u een specialisatie van de WEX::TestExecution::VerifyCompareTraits-klassesjabloon implementeren.

De WEX::TestExecution::VerifyCompareTraits klassesjabloonspecialisatie moet bestaan in de WEX::TestExecution-naamruimte . Het wordt ook verwacht dat het een openbare statische methoden met de naam AreEqual, AreSame, IsLessThan, IsGreaterThan en IsNull biedt.

    class MyClass
    {
    public:
        MyClass(int value)
            : m_myValue(value)
        {
        }

        int GetValue()
        {
            return m_myValue;
        }

    private:
        int m_myValue;
    }

    namespace WEX { namespace TestExecution
    {
        template <>
        class VerifyCompareTraits<MyClass, MyClass>
        {
        public:
            static bool AreEqual(const MyClass& expected, const MyClass& actual)
            {
                return expected.GetValue() == actual.GetValue();
            }

            static bool AreSame(const MyClass& expected, const MyClass& actual)
            {
                return &expected == &actual;
            }

            static bool IsLessThan(const MyClass& expectedLess, const MyClass& expectedGreater)
            {
                return (expectedLess.GetValue() < expectedGreater.GetValue());
            }

            static bool IsGreaterThan(const MyClass& expectedGreater, const MyClass& expectedLess)
            {
                return (expectedGreater.GetValue() > expectedLess.GetValue());
            }

            static bool IsNull(const MyClass& object)
            {
                return object.GetValue() == 0;
            }
        };
    }}

Verifiëren vanuit C gebruiken#

Het gebruik van C# controleren is vergelijkbaar met die van C++. Het wordt echter geleverd via de WEX. TestExecution.Verify-klasse , die zich in Te.Managed.dllbevindt.

De volgende verificatiemethoden zijn beschikbaar voor C#-tests:

Gebruik op basis van uitzonderingen controleren

Wanneer verificatiefouten optreden in C#-testcases, wordt er een fout naar de logger geschreven en wordt een WEX.TestExecution.VerifyFailureException gegooid. Net als in het systeemeigen C++-model hoeft u zich geen zorgen te maken over het vangen van deze uitzonderingen. Het TAEF-framework vangt het voor u op en gaat verder naar de volgende testcase.

Als u desgewenst een reeks verificaties in een rij wilt uitvoeren in plaats van de test af te breken bij de eerste verificatiefout, kunt u de klasse DisableVerifyExceptions gebruiken. De levensduur van het object bepaalt de hoeveelheid tijd die uitzonderingen zijn uitgeschakeld. De klasse DisableVerifyExceptions is met referentietelling en werkt op basis van per thread.

using (new DisableVerifyExceptions())
{
    Verify.AreSame(item1, item2);
    Verify.AreEqual(item1, item2);
}

Als in het bovenstaande voorbeeld de eerste verificatie-aanroep mislukt, wordt de tweede verificatie-aanroep nog steeds uitgevoerd.

U kunt ook hetzelfde resultaat bereiken door Verify.DisableVerifyExceptions = true in te stellen voordat de bewerkingen Verifiëren worden uitgevoerd, zoals in het onderstaande voorbeeld.

Verify.DisableVerifyExceptions = true;
try
{
    Verify.AreSame(item1, item2);
    Verify.AreEqual(item1, item2);
}
finally
{
    Verify.DisableVerifyExceptions = false;
}

Houd er rekening mee dat hoewel deze optie beschikbaar is, het declareren van DisableVerifyExeptions als een object in een gebruiksblok nog steeds de aanbevolen optie is.

Als u wilt stoppen in het foutopsporingsprogramma wanneer er een verificatiefout optreedt, opent u het dialoogvenster Uitzonderingen (Ctrl+Alt+E), klikt u op Toevoegen, kiest u 'Common Language Runtime Exceptions' in de vervolgkeuzelijst en plaatst u 'WEX.TestExecution.VerifyFailureException' in het veld Naam.

Uitvoerinstellingen controleren

Als u de uitvoer wilt aanpassen die wordt geproduceerd door de Verify-API's, kunt u de klasse SetVerifyOutput gebruiken. De levensduur van het object bepaalt de tijdsduur waarvoor de uitvoerinstellingen zijn ingesteld. De SetVerifyOutput-klasse is referentiegeteld en werkt op basis van individuele threads.

using (new SetVerifyOutput(VerifyOutputSettings.LogOnlyFailures))
{
    Log.Comment("Only the following error should be logged:");
    Verify.IsTrue(true, "Should NOT log a comment");
    Verify.IsTrue(false, "Should log an error");
}
Verify.IsTrue(true, "Should log a comment");

In het bovenstaande voorbeeld moet alleen de tweede verificatieoproep worden geregistreerd, omdat dit de enige aanroep is die mislukt binnen het gebruiksblok. De derde verificatie-aanroep wordt echter geregistreerd, ook al lukt het wel. Dit komt doordat de klasse SetVerifyOutput buiten het bereik is gegaan.

U kunt ook hetzelfde resultaat bereiken door Verify.OutputSettings = VerifyOutputSettings.LogOnlyFailures in te stellen voordat de bewerkingen Verifiëren worden uitgevoerd, zoals in het onderstaande voorbeeld.

Verify.OutputSettings = VerifyOutputSettings.LogFailuresAsWarnings
try
{
    Verify.AreSame(item1, item2);
    Verify.AreEqual(item1, item2);
}
finally
{
    Verify.OutputSettings = VerifyOutputSettings.None;
}

Hoewel deze optie beschikbaar is, is het nog steeds de aanbevolen optie om SetVerifyOutput als een object in een using-blok te declareren.

Er zijn de volgende opties voor het instellen van de controle-uitvoer:

VerifyOutputSettings.Log alleen fouten
Alleen mislukte verificatie van aanroepen worden geregistreerd; alle geslaagde oproepen worden genegeerd.

VerifieerUitvoerInstellingen.LogFoutenAlsGeblokkeerd
Registreer alle fouten zoals geblokkeerd in plaats van een fout te registreren.

VerifyOutputSettings.LogFailuresAsWarnings
Registreer alle fouten als waarschuwingen in plaats van een fout te registreren.

Controleer of de uitvoerinstellingen samen or'd zijn om meerdere instellingen in te schakelen:

using (new SetVerifyOutput(VerifyOutputSettings.LogFailuresAsBlocked | VerifyOutputSettings.LogOnlyFailures))
{
...
}

Verifiëren vanuit script gebruiken

De Verify-API wordt ook weergegeven voor scripttalen, volgens dezelfde gebruikspatronen als C++ en C#.

Installatie

Wanneer u de scriptbare verificatie-API's gebruikt vanuit een TAEF-testmethode, is er geen installatie nodig. De vereiste API's worden geregistreerd met 'Registratie gratis COM'. Als u de scriptbare API van buiten een TAEF-testmethode (buiten TAEF of in een onderliggend proces) wilt gebruiken, registreert u het binaire bestand Te.Common.dll met behulp van regsvr32 vanaf een verhoogde opdrachtprompt; bijvoorbeeld:

regsvr32 Te.Common.dll

Wanneer u TAEF implementeert met behulp van een implementatiebestand voor labuitvoering, wordt Te.Common.dll automatisch geregistreerd.

Gebruik

De scriptbare Verify-API's worden weergegeven via de TE. Common.Verify' COM-klasse - instantieer deze klasse en roep methoden erop aan- de klasse Verify werkt automatisch met WEXLogger om pass- en mislukte verificaties naar het logboek te schrijven.

1   <?xml version="1.0" ?>
2   <?component error="false" debug="false"?>
3   <package>
4     <component id="Example">
5       <object id="Log" progid="Wex.Logger.Log" />
6       <object id="Verify" progid="Te.Common.Verify" />
7       <reference guid="e65ef678-a232-42a7-8a36-63108d719f31" version="1.0"/>
8       <reference guid="f8bb9db9-e54e-4555-b3e5-e3ddf2fef401" version="1.0"/>
9
10      <public>
11        <method name="HelloWorld"/>
12      </public>
13
14      <script language="JScript">
15          function HelloWorld() {
16              Verify.IsTrue(true);
17              Verify.IsFalse(false);
18          }
19      </script>
20    </component>
21  </package>

In dit voorbeeld wordt een TAEF-scripttestklasse gedefinieerd met één 'HelloWorld'-methode. Regel 6 gebruikt het element Object om de variabele Verifiëren in het globale bereik te definiëren. In regel 8 wordt het verwijzingselement gebruikt om alle constanten uit de opgegeven typebibliotheek (in dit geval Te.Common.dlltypebibliotheek) op te nemen in het globale bereik van het script; in dit geval worden de constanten VerifySettings toegevoegd. Regel 16 en 17 laten gewoon het gebruik van de Verify-API's zien. Wanneer het voorbeeld wordt uitgevoerd, wordt de volgende uitvoer gegenereerd:

Test Authoring and Execution Framework v2.7 Build 6.2.7922.0 (fbl_esc_end_dev(mschofie).110202-1000) For x86

StartGroup: Example::HelloWorld
Verify: IsTrue
Verify: IsFalse
EndGroup: Example::HelloWorld [Passed]

Summary: Total=1, Passed=1, Failed=0, Blocked=0, Not Run=0, Skipped=0

Scriptable Verify-API

De methoden voor validatie op de scriptbare Verify-API zijn als volgt:

Er zijn twee methoden in de klasse Verify voor het beheren van de instellingen:

De waarde van de instellingen die is doorgegeven aan de methoden Verify.EnableSettings of Verify.DisableSettings, kan een van de volgende waarden zijn:

VerifySettings_LogOnlyFailures = 0x01
Alleen fouten worden vastgelegd. Er is geen uitvoer voor geslaagde verificatie-aanroepen.

VerifySettings_LogFailuresAsBlocked = 0x02
Fouten worden geregistreerd als 'Geblokkeerd', in plaats van de standaardfout.

VerifySettings_LogFailuresAsWarnings = 0x04
Fouten worden geregistreerd als waarschuwing in plaats van de standaardfout.

VerifySettings_LogValuesOnSuccess = 0x08
De waarden van parameters die moeten worden geverifieerd, worden geschreven als onderdeel van het logboekbericht Verifiëren. Dit is standaard ingeschakeld.

VerifySettings_CoerceTypes = 0x1000
De waarden die aan de verificatiemethoden worden doorgegeven, worden omgezet volgens de JScript-coercie-regels. Dit is standaard ingeschakeld.

VerifySettings_DisableExceptions = 0x2000
Er worden geen uitzonderingen gegenereerd wanneer een validatie mislukt.

Instellingen controleren

De Verificatie-API biedt instellingen voor het configureren van het gedrag. De methoden EnableSettings en DisableSettings kunnen worden gebruikt om specifieke instellingen in of uit te schakelen die door de klasse Verify worden onderhouden. De methoden gebruiken een of meer instellingen om in of uit te schakelen.

    Verify.EnableSettings(VerifySettings_LogOnlyFailures);

Als u meerdere instellingen in één gesprek wilt in- of uitschakelen, kunt u meerdere 'VerifySettings'-vlaggen opnemen:

    Verify.EnableSettings(VerifySettings_LogOnlyFailures | VerifySettings_DisableExceptions);

Met de methoden EnableSettings en DisableSettings wordt een object geretourneerd dat kan worden gebruikt om de oorspronkelijke instellingen te herstellen, zodat instellingen voor een bepaald bereik kunnen worden ingeschakeld of uitgeschakeld;

1    var guard = Verify.EnableSettings(VerifySettings_LogOnlyFailures);
2    try
3    {
4        Verify.AreEqual(10, 0xa);
5    }
6    finally
7    {
8        guard.Restore();
9    }

In dit voorbeeld wordt de methode Verify.EnableSettings doorgegeven VerifySettings_LogOnlyFailures, die wordt opgenomen in de instellingen die al aanwezig zijn op het object Verify. Er wordt een Verify-aanroep uitgevoerd binnen een 'try-finally'-blok, zodat tijdens het 'finally'-blok het object 'guard' kan worden gebruikt om de oorspronkelijke instellingen te herstellen.

Gebruik op basis van uitzonderingen controleren

De verificatiemethoden genereren standaard een uitzondering wanneer een verificatie mislukt. Wanneer een uitzondering wordt gegenereerd onder TAEF en uit de testmethode wordt geworpen, zal de test mislukken. Voorbeeld:

1    var guard = Verify.EnableSettings(VerifySettings_CoerceTypes);
2    try
3    {
4        Verify.AreEqual(1, "1");
5        Verify.AreEqual("1", 1);
6    }
7    finally
8    {
9        guard.Restore();
10   }

In dit voorbeeld wordt de tweede verificatieaanroep nooit uitgevoerd, omdat de eerste een uitzondering genereert en de test mislukt. De instellingenondersteuning voor de Verificatie-API kan worden gebruikt om dit gedrag te wijzigen, zodat mislukte verificaties niet worden uitgevoerd, waardoor volgende Verificatieaanroepen kunnen worden uitgevoerd. Dit is met name handig om een set parameters te verifiëren en ervoor te zorgen dat alle verificaties worden weggeschreven.

1    var guard = Verify.EnableSettings(VerifySettings_CoerceTypes | VerifySettings_DisableExceptions);
2    try
3    {
4        Verify.AreEqual(1, "1");
5        Verify.AreEqual("1", 1);
6    }
7    finally
8    {
9        guard.Restore();
10   }

Omdat uitzonderingen zijn uitgeschakeld, worden beide verificaties naar het logboek geschreven.

De Scriptable Verify-API buiten TAEF gebruiken

De scriptbare Verify-API kan buiten TAEF worden gebruikt. Zorg ervoor dat de Te.Common.dll is geregistreerd, zoals beschreven in de sectie Installatie, en maak eenvoudig de "TE.Common.Verify" klasse aan.

var VerifySettings_DisableExceptions = 0x2000;

var Verify = new ActiveXObject("TE.Common.Verify");
var Log = new ActiveXObject("WEX.Logger.Log");

Verify.EnableSettings(VerifySettings_DisableExceptions);

Log.StartGroup("Group A");
Verify.AreEqual(1, 2);
Log.EndGroup("Group A");

Log.StartGroup("Group B");
Verify.AreEqual(2, 2);
Log.EndGroup("Group B");

Met de voorgaande code wordt de volgende console-uitvoer gegenereerd wanneer deze wordt uitgevoerd via cscript:

StartGroup: Group A
Error: Verify: AreEqual - Values (1, 2)
EndGroup: Group A [Failed]

StartGroup: Group B
Verify: AreEqual - Values (2, 2)
EndGroup: Group B [Passed]

Non-passing Tests:

    Group A [Failed]

Summary: Total=2, Passed=1, Failed=1, Blocked=0, Not Run=0, Skipped=0

De 'WEX. Logger.Log' API kan worden gebruikt om de WEX Logger zo nodig te configureren (bijvoorbeeld als een onderliggend proces) en de scriptbare Verify-API maakt gebruik van die configuratie.