Couverture partielle d'une instruction de retour en C++/CLI

Question

J'ai le code C++/CLI et j'utilise la couverture de Code Suite Team Suite de Visual Studio 2008.

L'en-tête de code:

// Library.h 

#pragma once 

#include <string> 

using namespace System; 

namespace Library 
{ 
    public ref class MyClass 
    { 
    public: 
    static void MyFoo(); 
    static std::string Foo(); 
    }; 
} 

La mise en œuvre du code:

#include "Library.h" 

using namespace Library; 
using namespace System; 

void MyClass::MyFoo() 
{ 
Foo(); 
} 

std::string MyClass::Foo() 
{ 
return std::string(); 
} 

J'ai un C# test unitaire, qui appelle MyClass.MyFoo():

[TestMethod] 
public void TestMethod1() 
{ 
    Library.MyClass.MyFoo(); 
} 

Pour une raison quelconque, je ne pas obtenir une couverture de code complet pour MyClass. La méthode Foo() a 3 blocs non couverts et 5 blocs couverts. Les crochets de fermeture (}) sont marqués en orange - partiellement recouverts. Je ne sais pas pourquoi il est partiellement couvert au lieu d'être entièrement couvert, et c'est ma question.

MyClass Code Coverage Print Screen http://img217.imageshack.us/img217/7664/myclasscoverage.png

MISE À JOUR

Un autre exemple:

tête:

// Library.h 

#pragma once 

using namespace System; 

namespace Library 
{ 
    struct MyStruct 
    { 
     int _number; 
    }; 

    public ref class MyClass 
    { 
    public: 
     static void MyFoo(); 
     static MyStruct* Foo(); 
    }; 
} 

Mise en œuvre:

#include "Library.h" 

using namespace Library; 
using namespace System; 

void MyClass::MyFoo() 
{ 
    delete Foo(); 
} 

MyStruct* MyClass::Foo() 
{ 
    return new MyStruct(); 
} 

Je reçois toujours la même couverture manquante dans l'instruction return de Foo.

Answer 1

Vous ne couvrez pas le cas où la fonction sort par exception au lieu de normalement. Bien sûr, si vous ne pouvez même pas construire un std::string de longueur nulle alors votre programme est probablement allé trop loin pour la récupération, mais déterminer que cela dépasse la portée de l'analyse de couverture de code. EDIT: Afin d'améliorer la couverture, vous pouvez simuler un operator new global qui échoue basé sur un drapeau global (ou plus flexible, échoue sur la Nième allocation) que vous pouvez définir dans votre cas de test.

par exemple.

int allocation_failure = 0; 
void* operator new(size_t requestedbytes) 
{ 
    if (allocation_failure) { 
     if (!--allocation_failure) { 
      throw std::bad_alloc(); 
     } 
    } 
    void* retval = malloc(requestedBytes); 
    if (!retval) { 
     throw std::bad_alloc(); 
    } 
    return retval; 
} 

void operator delete(void* p) 
{ 
    if (p) free(p); 
} 

Ou vous pourriez ne pas conditionnellement les allocations d'une certaine taille, ou l'allocation Nième d'une taille particulière, etc., d'exercer tous les chemins possibles à travers votre code.

Answer 2

[La divulgation complète: Je suis sur l'équipe qui aide à créer les outils de couverture de code VS]

Essayez la collecte couverture de code contre une accumulation de libération au lieu d'une version de débogage.

Le compilateur peut émettre IL qui est réellement inaccessible après que certaines optimisations/transformations ont été appliquées. Le moyen le plus simple de voir si c'est le cas est de regarder l'IL avec ildasm ou Reflector. Voir here pour un exemple.