NUnit.Framework.Constraints Espace de noms

AllItemsConstraint applique une autre contrainte à chaque élément d’une collection, en réussissant s’ils réussissent tous.

Représente une contrainte qui réussit si tous les membres d’une collection correspondent à une contrainte de base.

AndConstraint réussit uniquement si les deux membres réussissent.

Opérateur qui nécessite que ses deux arguments réussissent

AssignableFromConstraint est utilisé pour tester qu’un objet peut être affecté à partir d’un type donné.

AssignableToConstraint est utilisé pour tester qu’un objet peut être affecté à un type donné.

AttributeConstraint teste qu’un attribut spécifié est présent sur un type ou un autre fournisseur et que la valeur de l’attribut satisfait à une autre contrainte.

AttributeExistsConstraint teste la présence d’un attribut spécifié sur un type.

Opérateur qui teste la présence d’un attribut particulier sur un type et applique éventuellement d’autres tests à l’attribut.

BasicConstraint est la base abstraite pour les contraintes qui effectuent une comparaison simple avec une valeur constante.

BinaryConstraint est la base abstraite de toutes les contraintes qui combinent deux autres contraintes d’une manière ou d’une autre.

Classe de base abstraite pour tous les opérateurs binaires

BinarySerializableConstraint vérifie si un objet est sérialisable au format binaire.

CollectionConstraint est la classe de base abstraite pour les contraintes qui opèrent sur les collections.

CollectionContainsConstraint est utilisé pour tester si une collection contient un objet attendu en tant que membre.

CollectionEquivalentCOnstraint est utilisé pour déterminer si deux collections sont équivalentes.

CollectionItemsEqualConstraint est la classe de base abstraite pour toutes les contraintes de collection qui appliquent une notion d’égalité d’élément dans le cadre de leur opération.

Base abstraite pour les opérateurs qui indiquent comment appliquer une contrainte aux éléments d’une collection.

CollectionOrderedConstraint est utilisé pour tester si une collection est triée.

CollectionSubsetConstraint permet de déterminer si une collection est un sous-ensemble d’une autre.

La classe ComparisonAdapter centralise toutes les comparaisons de valeurs dans NUnit, en s’adaptant à l’utilisation de n’importe quel IComparer, IComparer<T> ou Comparison<T fourni>

Classe de base abstraite pour les contraintes qui comparent des valeurs pour déterminer si l’une est supérieure, égale ou inférieure à l’autre.

La classe Constraint est la base de toutes les contraintes intégrées dans NUnit. Il fournit les surcharges d’opérateur utilisées pour combiner les contraintes.

ConstraintBuilder gère les piles utilisées dans le traitement d’un ConstraintExpression. Un OperatorStack est utilisé pour contenir les opérateurs qui attendent que leurs opérandes soient réognisés. Un ConstraintStack contient les contraintes d’entrée ainsi que les résultats de chaque opérateur appliqué.

ConstraintStack est une pile de type sécurisé pour la conservation des contraintes

OperatorStack est une pile de type sécurisé pour contenir ConstraintOperators

ConstraintExpression représente une contrainte composée dans le processus de construction à partir d’une série d’éléments syntaxiques. Des éléments individuels sont ajoutés à l’expression au fur et à mesure qu’ils sont reconnus. Une fois qu’une contrainte réelle est ajoutée, l’expression retourne une contrainte résolvable.

ConstraintExpressionBase est la classe de base abstraite de la classe ConstraintExpression générée, qui représente une contrainte composée dans le processus de construction à partir d’une série d’éléments syntaxiques. REMARQUE : ConstraintExpressionBase connaît certaines de ses classes dérivées, ce qui est une violation apparente de l’encapsulation. Dans l’idéal, ces classes seraient une seule classe, mais elles doivent être séparées afin de permettre la génération de composants sous .NET 1.x et de fournir des commentaires appropriés aux utilisateurs dans les IDE prenant en compte la syntaxique.

Classe d’assistance avec des propriétés et des méthodes qui fournissent un certain nombre de contraintes utilisées dans Asserts.

La classe ConstraintOperator est utilisée en interne par un ConstraintBuilder pour représenter un opérateur qui modifie ou combine des contraintes. Les opérateurs de contrainte utilisent des valeurs de priorité de gauche et de droite pour déterminer si l’opérateur supérieur de la pile doit être réduit avant d’envoyer (push) un nouvel opérateur.

ContainsConstraint teste si une chaîne contient une sous-chaîne ou une collection contient un objet. Elle reporte la décision du test à utiliser jusqu’à ce que le type de l’argument réel soit connu. Cela permet de tester si une chaîne est contenue dans une collection ou en tant que sous-chaîne d’une autre chaîne à l’aide de la même syntaxe.

EmptyCollectionConstraint teste si une collection est vide.

EmptyConstraint vérifie si une chaîne ou une collection est vide, en reportant la décision concernant le test appliqué jusqu’à ce que le type de l’argument réel soit connu.

EmptyStringConstraint teste si une chaîne est vide.

EndsWithConstraint peut tester si une chaîne se termine par une sous-chaîne attendue.

EqualConstraint peut comparer une valeur réelle à la valeur attendue fournie dans son constructeur. Deux objets sont considérés comme égaux si les deux ont la valeur null ou si les deux ont la même valeur. NUnit a une sémantique spéciale pour certains types d’objets.

La classe EqualityAdapter gère toutes les comparaisons d’égalité qui utilisent IEqualityComparer, IEqualityComparer<T> ou ComparisonAdapter.

ExactTypeConstraint est utilisé pour tester qu’un objet est du type exact fourni dans le constructeur

FalseConstraint teste que la valeur réelle est false

Routines d’assistance pour l’utilisation des nombres à virgule flottante

Teste si une valeur est supérieure à la valeur fournie à son constructeur

Teste si une valeur est supérieure ou égale à la valeur fournie à son constructeur

InstanceOfTypeConstraint est utilisé pour tester qu’un objet est du même type fourni ou dérivé de celui-ci.

Teste si une valeur est inférieure à la valeur fournie à son constructeur

Teste si une valeur est inférieure ou égale à la valeur fournie à son constructeur

MessageWriter est la base abstraite pour les classes qui écrivent des descriptions de contraintes et des messages sous une forme ou une autre. La classe a des méthodes distinctes pour écrire différents composants d’un message, ce qui permet aux implémentations d’adapter la présentation en fonction des besoins.

Méthodes statiques utilisées dans la création de messages

NaNConstraint teste que la valeur réelle est un NaN double ou flottant

NoItemConstraint applique une autre contrainte à chaque élément d’une collection, en cas d’échec si l’un d’eux réussit.

Représente une contrainte qui réussit si aucun des membres d’une collection ne correspond à une contrainte de base.

NotConstraint annule l’effet d’une autre contrainte

Annule le test de la contrainte qu’il encapsule.

NullConstraint teste que la valeur réelle est null

NullEmptyStringConstraint vérifie si une chaîne est null ou vide.

La classe Numerics contient des opérations courantes sur des valeurs numériques.

NUnitComparer encapsule le comportement par défaut de NUnit lors de la comparaison de deux objets.

NUnitEqualityComparer encapsule la gestion par NUnit des tests d’égalité entre les objets.

OrConstraint réussit si l’un des membres réussit

Opérateur qui nécessite au moins un de ses arguments pour réussir

PathConstraint sert de base abstraite des contraintes qui opèrent sur les chemins et fournit plusieurs méthodes d’assistance.

Classe de base abstraite utilisée pour les préfixes

PrefixOperator accepte une seule contrainte et modifie son action d’une manière ou d’une autre.

PropertyConstraint extrait une propriété nommée et utilise sa valeur comme valeur réelle pour une contrainte chaînée.

PropertyExistsConstraint teste qu’une propriété nommée existe sur l’objet fourni via Match. À l’origine, PropertyConstraint fournissait cette fonctionnalité en plus d’effectuer des tests facultatifs sur la valeur de la propriété. Les deux contraintes sont désormais séparées.

Opérateur utilisé pour tester la présence d’une propriété nommée sur un objet et éventuellement appliquer d’autres tests à la valeur de cette propriété.

RegexConstraint peut tester si une chaîne correspond au modèle fourni.

ResolvableConstraintExpression est utilisé pour représenter une contrainte composée en cours de construction à un point où le dernier opérateur peut arrêter l’expression ou peut avoir des contraintes éligibles supplémentaires. Il est utilisé, par exemple, pour un élément Property ou pour un élément Exception, qui peut éventuellement être suivi de contraintes qui s’appliquent à la propriété ou à l’exception.

SameAsConstraint teste si un objet est identique à l’objet passé à son constructeur

Description récapitulative de SamePathConstraint.

SamePathOrUnderConstraint teste qu’un chemin se trouve sous un autre

Classe de base abstraite pour les opérateurs capables de réduire à une contrainte, qu’un autre élément syntaxique suive ou non.

SomeItemsConstraint applique une autre contrainte à chaque élément d’une collection, en réussissant si l’un d’eux réussit.

Représente une contrainte qui réussit si l’un des membres d’une collection correspond à une contrainte de base.

StartsWithConstraint peut tester si une chaîne commence par une sous-chaîne attendue.

StringConstraint est la base abstraite pour les contraintes qui opèrent sur les chaînes. Il prend en charge le modificateur IgnoreCase pour les opérations de chaîne.

SubstringConstraint peut tester si une chaîne contient la sous-chaîne attendue.

ThrowsConstraint est utilisé pour tester l’exception levée par un délégué en lui appliquant une contrainte.

ThrowsNothingConstraint teste qu’un délégué ne lève pas d’exception.

Opérateur qui teste qu’une exception est levée et applique éventuellement d’autres tests à l’exception.

La classe Tolerance généralise la notion de tolérance dans laquelle un test d’égalité réussit. Normalement, il est utilisé avec des types numériques, mais il peut être utilisé avec n’importe quel type qui prend en charge la prise d’une différence entre deux objets et la comparaison de cette différence à une valeur.

TrueConstraint teste que la valeur réelle est true

TypeConstraint est la base abstraite des contraintes qui prennent un type comme valeur attendue.

UniqueItemsConstraint teste si tous les éléments d’une collection sont uniques.

Représente une contrainte qui encapsule simplement la contrainte fournie en tant qu’argument, sans autre fonctionnalité, mais qui modifle l’ordre d’évaluation en raison de sa priorité.

BinarySerializableConstraint vérifie si un objet est sérialisable au format binaire.

L’interface IConstraintExpression est implémentée par toutes les expressions et contraintes complètes et résolvables.

Modes dans lesquels la valeur de tolérance d’une comparaison peut être interprétée.