Testgeneratie

Bij traditionele eenheidstests bestaat een test uit verschillende dingen:

  • Een reeks methode-aanroepen
  • De argumenten waarmee de methoden worden aangeroepen; de argumenten de testinvoer zijn
  • Validatie van het beoogde gedrag van de geteste toepassing door een set asserties op te geven

Hieronder volgt een voorbeeld van een teststructuur:

[Test]
void MyTest() {
    // data
    ArrayList a = new ArrayList();

    // method sequence
    a.Add(5);

    // assertions
    Assert.IsTrue(a.Count==1);
    Assert.AreEqual(a[0], 5);
}

IntelliTest kan vaak automatisch relevante argumentwaarden bepalen voor meer algemene parametertests, die de reeks methode-aanroepen en asserties bieden.

Testgeneratoren

IntelliTest genereert testcases door een reeks methoden van de implementatie te selecteren die moeten worden uitgevoerd en vervolgens invoer voor de methoden te genereren tijdens het controleren van asserties over de afgeleide gegevens.

Een geparameteriseerde eenheidstest geeft rechtstreeks een reeks methode-aanroepen in de hoofdtekst weer.

Wanneer IntelliTest objecten moet maken, worden aanroepen naar constructors en factory-methoden automatisch toegevoegd aan de reeks, indien nodig.

Testen van geparameteriseerde eenheden

Parameterized Unit Tests (PUT's) zijn tests die parameters aannemen. In tegenstelling tot traditionele eenheidstests, die meestal gesloten methoden zijn, accepteren Parameterized Unit Tests (PUTs) elke mogelijke set van parameters. Is het zo eenvoudig? Ja, van daaruit probeert IntelliTest de (minimale) set invoer te genereren die de code die bereikbaar is vanaf de test volledig bedekt .

PUT's worden gedefinieerd met behulp van het aangepaste kenmerk PexMethod op een vergelijkbare manier als MSTest (of NUnit, xUnit). PUT's zijn instantiemethoden die logisch zijn gegroepeerd in klassen die zijn getagd met PexClass. In het volgende voorbeeld ziet u een eenvoudige PUT die is opgeslagen in de klasse MyPexTest :

[PexMethod]
void ReplaceFirstChar(string target, char c) {

    string result = StringHelper.ReplaceFirstChar(target, c);

    Assert.AreEqual(result[0], c);
}

waarbij ReplaceFirstChar een methode is die het eerste teken van een tekenreeks vervangt:

class StringHelper {
    static string ReplaceFirstChar(string target, char c) {
        if (target == null) throw new ArgumentNullException();
        if (target.Length == 0) throw new ArgumentOutOfRangeException();
        return c + target.Substring(1);
    }
}

Met deze test kan IntelliTest automatisch invoer genereren voor een PUT die betrekking heeft op veel uitvoeringspaden van de geteste code. Elke invoer die betrekking heeft op een ander uitvoeringspad, wordt 'geserialiseerd' als eenheidstest:

[TestMethod, ExpectedException(typeof(ArgumentNullException))]
void ReplaceFirstChar0() {
    this.ReplaceFirstChar(null, 0);
}
...
[TestMethod]
void ReplaceFirstChar10() {
    this.ReplaceFirstChar("a", 'c');
}

Algemene geparameteriseerde eenheidstests

Geparameteriseerde eenheidstests kunnen algemene methoden zijn. In dit geval moet de gebruiker de typen opgeven die worden gebruikt om de methode te instantiëren met behulp van PexGenericArguments.

[PexClass]
public partial class ListTest {
    [PexMethod]
    [PexGenericArguments(typeof(int))]
    [PexGenericArguments(typeof(object))]
    public void AddItem<T>(List<T> list, T value)
    { ... }
}

Uitzonderingen toestaan

IntelliTest biedt talloze validatiekenmerken om uitzonderingen te classificeren in verwachte uitzonderingen en onverwachte uitzonderingen.

Verwachte uitzonderingen genereren negatieve testcases met de juiste aantekening, zoals ExpectedException(typeof(xxx)), terwijl onverwachte uitzonderingen mislukte testcases genereren.

[PexMethod, PexAllowedException(typeof(ArgumentNullException))]
void SomeTest() {...}

De validaties zijn:

Interne typen testen

IntelliTest kan interne typen testen, zolang deze kunnen worden weergegeven. Zodat IntelliTest de typen kan zien, wordt het volgende attribuut toegevoegd aan uw product- of testproject door de Visual Studio IntelliTest-wizards:

[assembly: InternalsVisibleTo("Microsoft.Pex, PublicKey=002400000480000094000000060200000024000052534131000400000100010007d1fa57c4aed9f0a32e84aa0faefd0de9e8fd6aec8f87fb03766c834c99921eb23be79ad9d5dcc1dd9ad236132102900b723cf980957fc4e177108fc607774f29e8320e92ea05ece4e821c0a5efe8f1645c4c0c93c1ab99285d622caa652c1dfad63d745d6f2de5f17e5eaf0fc4963d261c8a12436518206dc093344d5ad293")]

Veronderstellingen en beweringen

Gebruikers kunnen veronderstellingen en asserties gebruiken om voorwaarden (veronderstellingen) en postconditions (asserties) over hun tests uit te drukken. Wanneer IntelliTest een set parameterwaarden genereert en de code 'verkent', kan dit een aanname van de test schenden. Als dat gebeurt, wordt er geen test voor dat pad gegenereerd, maar wordt het op de achtergrond genegeerd.

Asserties zijn een bekend concept in reguliere eenheidstestframeworks, dus IntelliTest begrijpt al de ingebouwde Assert-klassen die door elk ondersteund testframework worden geleverd. De meeste frameworks bieden echter geen Assume-klasse . In dat geval biedt IntelliTest de klasse PexAssume . Als u geen bestaand testframework wilt gebruiken, heeft IntelliTest ook de PexAssert-klasse .

[PexMethod]
public void Test1(object o) {
    // precondition: o should not be null
    PexAssume.IsNotNull(o);

    ...
}

In het bijzonder kan de aanname van niet-nullness worden gecodeerd als een aangepast kenmerk:

[PexMethod]
public void Test2([PexAssumeNotNull] object o)
// precondition: o should not be null
{
   ...
}

Voorwaarde

Een voorwaarde van een methode geeft de voorwaarden aan waaronder de methode zal slagen.

Normaal gesproken wordt de voorwaarde afgedwongen door de parameters en de objectstatus te controleren en een ArgumentException of InvalidOperationException te genereren als deze wordt geschonden.

In IntelliTest wordt een voorwaarde voor een geparameteriseerde eenheidstest uitgedrukt met PexAssume.

Postconditie

Een postcondition van een methode drukt de voorwaarden uit die tijdens en na de uitvoering van de methode moeten gelden, ervan uitgaande dat de precondities aanvankelijk geldig waren.

Meestal wordt de postcondition afgedwongen door aanroepen naar Assert-methoden .

Met IntelliTest wordt een postcondition van een geparameteriseerde eenheidstest uitgedrukt met PexAssert.

Testfouten

Wanneer mislukt een gegenereerde testcase?

  1. Als deze niet wordt beëindigd binnen de geconfigureerde padgrenzen, wordt deze beschouwd als een fout, tenzij de optie TestExcludePathBoundsExceeded is ingesteld

  2. Als de test een PexAssumeFailedException genereert, slaagt deze. Het wordt echter meestal uitgefilterd, tenzij TestEmissionFilter is ingesteld op Alle

  3. Als de test een assertie schendt; bijvoorbeeld door een uitzonderingsfout van een assertieschending van een unittestframework te genereren, mislukt deze.

Als geen van de bovenstaande beslissingen een beslissing produceert, slaagt een test alleen als en alleen als er geen uitzondering wordt gegenereerd. Beweringsschendingen worden op dezelfde manier behandeld als uitzonderingen.

Opstellen en afbouwen

Als onderdeel van de integratie met testframeworks ondersteunt IntelliTest het detecteren en uitvoeren van setup- en teardownmethoden.

Voorbeeld

using Microsoft.Pex.Framework;
using NUnit.Framework;

namespace MyTests
{
    [PexClass]
    [TestFixture]
    public partial class MyTestClass
    {
        [SetUp]
        public void Init()
        {
            // monitored
        }

        [PexMethod]
        public void MyTest(int i)
        {
        }

        [TearDown]
        public void Dispose()
        {
            // monitored
        }
    }
}

Meer lezen

Heb je feedback?

Plaats uw ideeën en functieaanvragen in de ontwikkelaarscommunity.

  • Last updated on