Avertissements et erreursWarnings and errors

Avertissements et erreurs par catégorieWarnings and errors by category

MaxBranches dépasséMaxBranches exceeded

IntelliTest limite la longueur du chemin d’exécution qu’il explore pendant la génération des entrées.IntelliTest limits the length of any execution path that it explores during input generation. Cette fonctionnalité évite à IntelliTest de ne plus répondre quand le programme entre dans une boucle infinie.This feature prevents IntelliTest from becoming unresponsive when the program goes into an infinite loop.

Chaque branche conditionnelle et inconditionnelle du code exécuté et surveillé est comptabilisée pour cette limite, y compris les branches qui ne dépendent pas des entrées du test unitaire paramétrable.Every conditional and unconditional branch of the executed and monitored code is counted towards this limit, including branches that do not depend on the inputs of the parameterized unit test.

Par exemple, le code suivant consomme des branches dans la limite de 100 :For example, the following code consumes branches in the order of 100:

for (int i=0; i<100; i++) { }

Vous pouvez modifier l’option MaxBranches d’un attribut dérivé de PexSettingsAttributeBase, comme PexClass ou PexMethod.You can edit the MaxBranches option of an attribute derived from PexSettingsAttributeBase, such as PexClass or PexMethod. L’exemple suivant supprime cette limite :The following example effectively removes this bound:

[PexMethod(MaxBranches=int.MaxValue)]
public void MyTest(...) {
    // ....
}

Vous pouvez également définir l’option TestExcludePathBoundsExceeded pour indiquer à IntelliTest comment traiter ces problèmes d’une façon générale.You can also set the TestExcludePathBoundsExceeded option to inform IntelliTest how generally to deal with these issues.

Dans le code de test, vous pouvez utiliser PexSymbolicValue pour ignorer les contraintes générées par la condition de boucle :In the test code, you can use PexSymbolicValue to ignore constraints generated by the loop condition:

for (int i=0; 
    PexSymbolicValue.Ignore(i<100); // IntelliTest will 'forget' about this path condition
    i++) 
{ }

MaxConstraintSolverTime dépasséMaxConstraintSolverTime exceeded

IntelliTest utilise un solveur de contrainte pour calculer les nouvelles entrées de test.IntelliTest uses a constraint solver to compute new test inputs. La résolution de contrainte peut être un processus très long : IntelliTest vous permet donc de configurer des limites, en particulier MaxConstraintSolverTime.Constraint solving can be a very time consuming process, so IntelliTest allows you to configure bounds - in particular, MaxConstraintSolverTime.

Pour de nombreuses applications, augmenter considérablement le délai d’expiration n’entraîne pas une meilleure couverture.For many applications, significantly increasing the timeout will not result in better coverage. La raison en est que la plupart des dépassements du délai d’expiration sont dus à des systèmes de contraintes qui n’ont pas de solution.The reason for this is that most timeouts are caused by constraint systems that have no solutions. IntelliTest peut cependant ne pas être en mesure de déterminer qu’il est incohérent sans essayer toutes les solutions possibles, ce qui aboutit à un dépassement du délai d’expiration.However, IntelliTest might not be able to determine that it is inconsistent without trying all possible solutions, which will result in a timeout.

MaxConditions dépasséMaxConditions exceeded

IntelliTest limite la longueur du chemin d’exécution qu’il explore pendant la génération des entrées.IntelliTest limits the length of any execution path that it explores during input generation. Cette fonctionnalité évite à IntelliTest de ne plus répondre quand le programme entre dans une boucle infinie.This feature prevents IntelliTest from becoming unresponsive when the program enters an infinite loop.

Chaque branche conditionnelle qui dépend des entrées du test unitaire paramétrable est comptabilisée pour cette limite.Each conditional branch that depends on the inputs of the parameterized unit test is counted towards this limit.

Par exemple, chaque chemin dans le code suivant consomme n+1 conditions :For example, each path in the following code consumes n+1 conditions:

[PexMethod]
void ParameterizedTest(int n) {
    // conditions are "0<n", "1<n", ..., "!(n<n)"
    for (int i=0; i<n; i++)
    { ... }

    // irrelevant for MaxConditions, since conditions do not depend on input
    for (int i=0; i<100; i++) 
    { ... }
}

Vous pouvez modifier l’option MaxConditions d’un attribut dérivé de PexSettingsAttributeBase, comme PexClass ou PexMethod.You can edit the MaxConditions option of an attribute derived from PexSettingsAttributeBase, such as PexClass or PexMethod. Exemple :For example:

[PexMethod(MaxConditions=10000)]
void ParameterizedTest(int n) {
    // ...
}

Vous pouvez également définir l’option TestExcludePathBoundsExceeded pour indiquer à IntelliTest comment traiter ces problèmes d’une façon générale.You can also set the TestExcludePathBoundsExceeded option to inform IntelliTest how to generally deal with these issues.

Vous pouvez utiliser PexSymbolicValue pour ignorer les contraintes générées par la condition de boucle :You can use PexSymbolicValue to ignore constraints generated by the loop condition:

[PexMethod]
void ParameterizedTest(int n) {
    int nshadow = PexSymbolicValue.Ignore(n); // IntelliTest looses track of 'n'

    // irrevelant for MaxConditions, since nshadow is not related to input
    for (int i=0; i<nshadow; i++)  
    {...}
}

MaxCalls dépasséMaxCalls exceeded

IntelliTest limite la longueur du chemin d’exécution qu’il explore pendant la génération des entrées.IntelliTest limits the length of any execution path that it explores during input generation. Cette fonctionnalité évite à IntelliTest de ne plus répondre quand le programme entre dans une boucle infinie.This feature prevents IntelliTest from becoming unresponsive when the program goes enters an infinite loop.

Chaque appel (direct, indirect, virtuel ou de saut) du code exécuté et surveillé est comptabilisé pour cette limite.Each call (direct, indirect, virtual, or jump) of the executed and monitored code is counted towards this limit.

Vous pouvez modifier l’option MaxCalls d’un attribut dérivé de PexSettingsAttributeBase, comme PexClass ou PexMethod.You can edit the MaxCalls option of an attribute derived from PexSettingsAttributeBase, such as PexClass or PexMethod. L’exemple suivant supprime cette limite :The following example effectively removes this bound:

[PexMethod(MaxCalls=int.MaxValue)]
public void MyTest(...) {
    // ....
}

Vous pouvez également définir l’option TestExcludePathBoundsExceeded pour indiquer à IntelliTest comment traiter ces problèmes d’une façon générale.You can also set the TestExcludePathBoundsExceeded option to inform IntelliTest how to generally deal with these issues.

MaxStack dépasséMaxStack exceeded

IntelliTest limite la longueur de la pile des appels des chemins d’exécution qu’il explore pendant la génération des entrées.IntelliTest limits the size of the call stack of any execution path that it explores during input generation. Cette fonctionnalité évite à IntelliTest de se terminer quand un dépassement de capacité de la pile se produit.This feature prevents IntelliTest from terminating when a stack overflow occurs.

Vous pouvez modifier l’option MaxStack d’un attribut dérivé de PexSettingsAttributeBase, comme PexClass ou PexMethod.You can edit the MaxStack option of an attribute derived from PexSettingsAttributeBase, such as PexClass or PexMethod. L’exemple suivant supprime cette limite (ceci n’est pas recommandé) :The following example effectively removes this bound (not recommended):

[PexMethod(MaxStack=int.MaxValue)]
public void MyTest(...) {
    // ....
}

Vous pouvez également définir l’option TestExcludePathBoundsExceeded pour indiquer à IntelliTest comment traiter ces problèmes d’une façon générale.You can also set the TestExcludePathBoundsExceeded option to inform IntelliTest how to generally deal with these issues.

MaxRuns dépasséMaxRuns exceeded

IntelliTest limite le nombre de chemins d’exécution qu’il explore pendant la génération des entrées.IntelliTest limits the number of execution paths that it explores during input generation. Cette fonctionnalité garantit qu’IntelliTest se termine quand le programme a des boucles ou une récursivité.This feature ensures that IntelliTest terminates when the program has loops or recursion.

Il est possible qu’IntelliTest ne produise pas un nouveau cas de test chaque fois qu’il exécute le test paramétrable avec des entrées particulières.It may not be the case that, every time IntelliTest runs the parameterized test with particular inputs, it emits a new test case. Pour plus d’informations, consultez TestEmissionFilter.See TestEmissionFilter for more information.

Vous pouvez modifier l’option MaxRuns d’un attribut dérivé de PexSettingsAttributeBase, comme PexClass ou PexMethod.You can edit the MaxRuns option of an attribute derived from PexSettingsAttributeBase,such as PexClass or PexMethod. L’exemple suivant supprime cette limite (ceci n’est pas recommandé) :The following example effectively removes this bound (not recommended):

[PexMethod(MaxRuns=2000)]
public void MyTest(...) {
    // ....
}

MaxRunsWithoutNewTests dépasséMaxRunsWithoutNewTests exceeded

IntelliTest limite le nombre de chemins d’exécution qu’il explore pendant la génération des entrées.IntelliTest limits the number of execution paths that it explores during input generation. Cette fonctionnalité garantit qu’IntelliTest se termine quand le programme a des boucles ou une récursivité.This feature ensures that IntelliTest terminates when the program has loops or recursion.

Il est possible qu’IntelliTest ne produise pas un nouveau cas de test chaque fois qu’il exécute le test paramétrable avec des entrées particulières.It may not be the case that, every time IntelliTest runs the parameterized test with particular inputs, it emits a new test case. Pour plus d’informations, consultez TestEmissionFilter.See TestEmissionFilter for more information.

Alors qu’IntelliTest trouve souvent initialement de nombreuses entrées de test intéressantes, il est possible qu’après un certain temps, il ne produise plus de tests.While IntelliTest often finds many interesting test inputs initially, it might not - after a while - emit any more tests. Cette option détermine la durée pendant laquelle IntelliTest peut essayer de trouver une autre entrée de test pertinente.This option governs how long IntelliTest may keep trying to find another relevant test input.

Vous pouvez modifier l’option MaxRunsWithoutNewTests d’un attribut dérivé de PexSettingsAttributeBase, comme PexClass ou PexMethod.You can edit the MaxRunsWithoutNewTests option of an attribute derived from PexSettingsAttributeBase, such as PexClass or PexMethod. L’exemple suivant supprime cette limite (ceci n’est pas recommandé) :The following example effectively removes this bound (not recommended):

[PexMethod(MaxRunsWithoutNewTests=2000)]
public void MyTest(...) {
    // ....
}

Impossible de concrétiser la solutionCannot concretize solution

Cette erreur est souvent la conséquence d’une erreur antérieure.This error is often the consequence of an earlier error. IntelliTest utilise un solveur de contrainte pour déterminer les nouvelles entrées de test.IntelliTest uses a constraint solver to determine new test inputs. Parfois, les entrées de test proposées par le solveur de contrainte ne sont pas valides.Sometimes, test inputs proposed by the constraint solver are invalid. Ceci peut se produire quand :This can happen when:

  • Certaines contraintes ne sont pas connues.certain constraints are not known
  • Si des valeurs sont créées d’une façon définie par l’utilisateur, entraînant des erreurs dans le code utilisateur.if values are created in a user-defined way, causing errors to occur in user code
  • Certains des types impliqués ont une logique d’initialisation non contrôlée par IntelliTest (par exemple des classes COM)some of the types involved have initialization logic not controlled by IntelliTest (for example, COM classes)

Besoin d’aide pour construire l’objetNeed help to construct object

IntelliTest génère des entrées de test et certaines entrées peuvent être des objets avec des champs.IntelliTest generates test inputs, and some of the inputs may be objects with fields. Ici, IntelliTest tente de générer une instance d’une classe qui a un champ privé, et il part du principe qu’un comportement intéressant du programme se produit quand ce champ privé a une valeur particulière.Here, IntelliTest tries to generate an instance of a class that has a private field, and it assumes that an interesting program behavior will occur when this private field has a particular value.

Cependant, si cela est possible avec la réflexion, IntelliTest ne fabrique pas d’objets avec des valeurs de champ arbitraires.However, while this is possible with Reflection, IntelliTest does not manufacture objects with arbitrary field values. Au lieu de cela, dans ces situations, il s’appuie sur les indications données par l’utilisateur sur la façon d’utiliser les méthodes publiques d’une classe pour créer un objet et pour le placer dans un état où son champ privé a la valeur souhaitée.Instead, in these cases, it relies on the user to provide hints about how to use the public methods of a class to create an object, and bring it into a state where its private field has the desired value.

Pour découvrir comment vous pouvez aider IntelliTest à construire des objets intéressants, consultez Instanciation de classes existantes.Read Instantiating existing classes to learn how you can help IntelliTest construct interesting objects.

Besoin d’aide pour rechercher des typesNeed help to find types

IntelliTest génère des entrées de test pour tous les types .NET.IntelliTest generates test inputs for any .NET type. Ici, IntelliTest tente de créer une instance qui dérive d’une classe abstraite ou qui implémente une interface abstraite, et il n’a connaissance d’aucun type satisfaisant les contraintes.Here, IntelliTest tries to create an instance that derives from an abstract class or implements an abstract interface, and IntelliTest does not know of any type that fulfills the constraints.

Vous pouvez aider IntelliTest en pointant vers un ou plusieurs types qui correspondent aux contraintes.You can help IntelliTest by pointing to one or more types that match the constraints. Un des attributs suivants peut généralement aider :Usually, one of the following attributes will help:

  • PexUseTypeAttribute, qui pointe vers un type particulier.PexUseTypeAttribute, which points to a particular type.

    Par exemple, si IntelliTest indique qu’il « ne connaît aucun type pouvant être assigné à System.Collections.IDictionary», vous pouvez l’aider en attachant le PexUseTypeAttribute suivant au test (ou à la classe d’attachement) :For example, if IntelliTest reports that it "does not know of any types assignable to System.Collections.IDictionary", you can help it by attaching the following PexUseTypeAttribute to the test (or to the fixture class):

    [PexMethod]
    [PexUseType(typeof(System.Collections.Hashtable))]
    public void MyTest(IDictionary[] dictionaries) { ... }
    
  • Un attribut de niveau assemblyAn assembly-level attribute

    [assembly: PexUseType(typeof(System.Collections.Hashtable))]
    

Type utilisable devinéUsable type guessed

IntelliTest génère des entrées de test pour tous les types .NET.IntelliTest generates test inputs for any .NET types. Quand un type est abstrait ou est une interface, IntelliTest doit choisir une implémentation particulière de ce type.When a type is abstract or an interface, IntelliTest must choose a particular implementation of that type. Pour faire ce choix, il a besoin de savoir quels types existent.To make that choice, it needs to know which types exist.

Quand cet avertissement est affiché, il indique qu’IntelliTest a recherché dans certains des assemblys référencés et a trouvé un type d’implémentation, mais qu’il n’est pas certain de devoir utiliser ce type ou qu’il existe des types plus appropriés disponibles ailleurs.When this warning is shown, it indiicates that IntelliTest looked at some of referenced assemblies and found an implementation type, but it is not sure if it should use that type, or if there are more appropriate types available elsewhere. IntelliTest a simplement choisi un type qui semblait prometteur.IntelliTest simply chose a type that looked promising.

Pour éviter cet avertissement, vous pouvez accepter le choix de type d’IntelliTest ou bien l’aider à utiliser d’autres types en ajoutant un PexUseType correspondant.In order to avoid this warning, you can either accept IntelliTest's type choice, or assist IntelliTest in using other types by adding a corresponding PexUseType.

Erreur inattendue pendant l’explorationUnexpected failure during exploration

Une exception inattendue a été interceptée lors de l’exploration d’un test.An unexpected exception was caught while exploring a test.

Merci de signaler ceci comme bogue.Please report this as a bug.

TargetInvocationExceptionTargetInvocationException

Une exception s’est produite dans le code utilisateur.An exception occurred in user code. Inspectez la trace de la pile et supprimez le bogue dans votre code.Inspect the stack trace, and remove the bug in your code.

Méthode non instrumentée appeléeUninstrumented method called

IntelliTest génère des entrées de test en surveillant l’exécution du programme.IntelliTest generates test inputs by monitoring program execution. Il est essentiel que le code concerné soit correctement instrumenté pour qu’IntelliTest puisse surveiller son comportement.It is essential that the relevant code is properly instrumented so that IntelliTest can monitor its behavior.

Cet avertissement apparaît quand le code instrumenté appelle des méthodes dans un autre assembly non instrumenté.This warning appears when the instrumented code calls methods in another, uninstrumented assembly. Si vous voulez qu’IntelliTest explore l’interaction entre les deux, vous devez aussi instrumenter l’autre assembly (ou des parties de celui-ci).If you want IntelliTest to explore the interaction of both, you must also instrument the other assembly (or parts of it).

Méthode externe appeléeExternal method called

IntelliTest génère des entrées de test en surveillant l’exécution d’applications .NET.IntelliTest generates test inputs by monitoring execution of .NET applications. IntelliTest ne peut pas générer des entrées de test significatives pour du code qui n’est pas écrit dans un langage .NET.IntelliTest cannot generate meaningful test inputs for code that is not written in a .NET language.

Cet avertissement apparaît quand le code instrumenté appelle une méthode native non managée qu’IntelliTest ne peut pas analyser.This warning appears when the instrumented code calls an unmanaged, native method that IntelliTest cannot analyze. Si vous voulez qu’IntelliTest explore l’interaction entre les deux, vous devez simuler la méthode non managée.If you want IntelliTest to explore the interaction of both, you must mock the unmanaged method.

Méthode non instrumentable appeléeUninstrumentable method called

IntelliTest génère des entrées de test en surveillant l’exécution d’applications .NET.IntelliTest generates test inputs by monitoring execution of .NET applications. Il existe cependant certaines méthodes que, pour des raisons techniques, IntelliTest ne peut pas surveiller.However, there are some methods that, for technical reasons, IntelliTest cannot monitor . Par exemple, IntelliTest ne peut pas surveiller un constructeur statique.For example, IntelliTest cannot monitor a static constructor.

Cet avertissement apparaît quand le code instrumenté appelle une méthode qu’IntelliTest ne peut pas surveiller.This warning appears when the instrumented code calls a method that IntelliTest cannot monitor.

Problème de testabilitéTestability issue

IntelliTest génère des entrées de test en surveillant l’exécution du programme.IntelliTest generates test inputs by monitoring the program execution. Il peut générer des entrées de test appropriées seulement quand le programme est déterministe et quand le comportement approprié est contrôlé par les entrées de test.It can only generate relevant test inputs when the program is deterministic, and when the relevant behavior is controlled by the test inputs.

Cet avertissement apparaît parce que, pendant l’exécution de votre cas de test, une méthode qui a été appelée se comporte de façon non déterministe ou interagit avec l’environnement.This warning appears because, during execution of your test case, a method was called that either behaves non-deterministically, or interacts with the environment. System.Random et System.IO.File sont des exemples de méthodes.Examples are methods of System.Random and System.IO.File. Si vous voulez qu’IntelliTest crée des entrées de test significatives, vous devez simuler les méthodes signalées par IntelliTest comme posant des problèmes de testabilité.If you want IntelliTest to create meaningful test inputs, you must mock the methods that IntelliTest flags as testability issues.

LimitationLimitation

IntelliTest génère les entrées de test en utilisant un solveur de contrainte.IntelliTest generates test inputs by using a constraint solver. Certaines opérations sont cependant au-delà de l’étendue du solveur de contrainte.However, there are some operations that are beyond the scope of the constraint solver. Ceci inclut actuellement :This currently includes:

  • La plupart des opérations à virgule flottante (seules certaines opérations arithmétiques linéaires sont prises en charge sur les nombres à virgule flottante).most floating point operations (only some linear arithmetic is supported on floating point numbers)
  • Les conversions entre les nombres à virgule flottante et les entiers.conversions between floating point numbers and integers
  • Toutes les opérations sur le type System.Decimal.all operations on the System.Decimal type

Cet avertissement apparaît quand le code exécuté effectue une opération ou appelle une méthode qu’IntelliTest ne peut pas interpréter.This warning appears when the executed code performs an operation or calls a method that IntelliTest cannot interpret.

Non-correspondance observée au niveau des appelsObserved call mismatch

IntelliTest génère des entrées de test en surveillant l’exécution du programme.IntelliTest generates test inputs by monitoring program execution. IntelliTest peut cependant ne pas être en mesure de surveiller toutes les instructions.However, IntelliTest might not be able to monitor all instructions. Par exemple, il ne peut pas surveiller du code natif ni du code qui n’est pas instrumenté.For example, it cannot monitor native code, and it cannot monitor code that is not instrumented.

Quand IntelliTest surveille le code, il ne peut pas générer des entrées de test appropriées pour ce code.When IntelliTest cannot monitor code, it cannot generate test inputs that are relevant to that code. Souvent, IntelliTest ignore qu’il ne peut pas surveiller une méthode jusqu’au retour d’un appel à cette méthode.Often, IntelliTest is not aware of the fact that it cannot monitor a method until a call to that method returns. Cependant, la cause de cet avertissement est :However, the cause of this warning is:

  • IntelliTest a surveillé du code, qui a lancé un appel à une méthode non instrumentée.IntelliTest monitored some code, which initiated a call to an uninstrumented method
  • La méthode non instrumentée a appelé une méthode qui est instrumentée.The uninstrumented method called a method that is instrumented
  • IntelliTest surveille la méthode instrumentée qui a été appelée.IntelliTest monitors the instrumented method that was called

IntelliTest ne sait pas ce qu’a fait la méthode intermédiaire non instrumentée et il risque de ne pas pouvoir générer des entrées de test qui sont pertinentes pour l’appel instrumenté imbriqué.IntelliTest does not know what the uninstrumented intermediate method did, so it might not be able to generate test inputs that are relevant to the nested instrumented call.

Valeur stockée dans un champ statiqueValue stored in static field

IntelliTest peut déterminer systématiquement les entrées de test pertinentes seulement quand le test unitaire est déterministe ; en d’autres termes, il se comporte toujours de la même façon pour les mêmes entrées de test.IntelliTest can systematically determine relevant test inputs only when the unit test is deterministic; in other words, it always behaves the same way for the same test inputs. En particulier, cela signifie que le test doit laisser le système dans un état qui permet de réexécuter ce test.In particular, this means that the test should leave the system in a state that allows to re-execute that test. Dans l’idéal, le test unitaire ne doit changer aucun état global, mais toutes les interactions avec les éléments globaux doivent être simulées.Ideally, the unit test should not change any global state, but all interactions with globals should be mocked.

Cet avertissement indique qu’un champ statique a été modifié : ceci risque de faire que le test se comporte de façon non déterministe.This warning indicates that a static field was changed; this might make the test behave non-deterministically.

Dans certains cas, la modification d’un champ statique est acceptable :In some situations, changing a static field is acceptable:

  • Quand les entrées de test font que le code de configuration ou de nettoyage annule la modification.when the test inputs causes setup or cleanup code to undo the change
  • Quand le champ est initialisé une seule fois et que sa valeur ne change pas par la suitewhen the field is initiated only once, and the value does not change afterwards

Vous avez des commentaires ?Got feedback?

Postez vos idées et demandes de fonctionnalités sur UserVoice.Post your ideas and feature requests on UserVoice.