Unit Testing

Base.runtests(tests=["all"]; ncores=ceil(Int, Sys.CPU_THREADS / 2),
              exit_on_error=false, revise=false, [seed])

Exécutez les tests unitaires Julia listés dans tests, qui peuvent être soit une chaîne de caractères, soit un tableau de chaînes de caractères, en utilisant ncores processeurs. Si exit_on_error est false, lorsqu'un test échoue, tous les tests restants dans d'autres fichiers seront tout de même exécutés ; sinon, ils sont abandonnés lorsque exit_on_error == true. Si revise est true, le package Revise est utilisé pour charger toute modification apportée à Base ou aux bibliothèques standard avant d'exécuter les tests. Si une graine est fournie via l'argument clé, elle est utilisée pour initialiser le RNG global dans le contexte où les tests sont exécutés ; sinon, la graine est choisie aléatoirement.

@test ex
@test f(args...) key=val ...
@test ex broken=true
@test ex skip=true

Testez que l'expression ex évalue à true. Si exécuté à l'intérieur d'un @testset, renvoyez un Pass Result si c'est le cas, un Fail Result s'il est false, et un Error Result s'il ne peut pas être évalué. Si exécuté en dehors d'un @testset, lancez une exception au lieu de renvoyer Fail ou Error.

Exemples

julia> @test true
Test Passed

julia> @test [1, 2] + [2, 1] == [3, 3]
Test Passed

La forme @test f(args...) key=val... est équivalente à écrire @test f(args..., key=val...) ce qui peut être utile lorsque l'expression est un appel utilisant une syntaxe infixe telle que des comparaisons approximatives :

julia> @test π ≈ 3.14 atol=0.01
Test Passed

Ceci est équivalent au test moins élégant @test ≈(π, 3.14, atol=0.01). Il est interdit de fournir plus d'une expression à moins que la première soit une expression d'appel et que le reste soit des affectations (k=v).

Vous pouvez utiliser n'importe quelle clé pour les arguments key=val, sauf pour broken et skip, qui ont des significations spéciales dans le contexte de @test :

• broken=cond indique un test qui devrait réussir mais échoue actuellement de manière cohérente lorsque cond==true. Tests que l'expression ex évalue à false ou provoque une exception. Renvoie un Broken Result si c'est le cas, ou un Error Result si l'expression évalue à true. Le @test ex régulier est évalué lorsque cond==false.
• skip=cond marque un test qui ne devrait pas être exécuté mais qui devrait être inclus dans le rapport de résumé des tests comme Broken, lorsque cond==true. Cela peut être utile pour des tests qui échouent de manière intermittente, ou des tests de fonctionnalités pas encore implémentées. Le @test ex régulier est évalué lorsque cond==false.

Exemples

julia> @test 2 + 2 ≈ 6 atol=1 broken=true
Test Broken
  Expression: ≈(2 + 2, 6, atol = 1)

julia> @test 2 + 2 ≈ 5 atol=1 broken=false
Test Passed

julia> @test 2 + 2 == 5 skip=true
Test Broken
  Skipped: 2 + 2 == 5

julia> @test 2 + 2 == 4 skip=false
Test Passed

@test_throws exception expr

Teste que l'expression expr lance exception. L'exception peut spécifier soit un type, une chaîne, une expression régulière, ou une liste de chaînes apparaissant dans le message d'erreur affiché, une fonction de correspondance, ou une valeur (qui sera testée pour l'égalité en comparant les champs). Notez que @test_throws ne prend pas en charge une forme de mot-clé terminal.

Exemples

julia> @test_throws BoundsError [1, 2, 3][4]
Test Passed
      Thrown: BoundsError

julia> @test_throws DimensionMismatch [1, 2, 3] + [1, 2]
Test Passed
      Thrown: DimensionMismatch

julia> @test_throws "Try sqrt(Complex" sqrt(-1)
Test Passed
     Message: "DomainError with -1.0:\nsqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x))."

Dans l'exemple final, au lieu de faire correspondre une seule chaîne, cela aurait pu également être effectué avec :

• ["Try", "Complex"] (une liste de chaînes)
• r"Try sqrt\([Cc]omplex" (une expression régulière)
• str -> occursin("complex", str) (une fonction de correspondance)

@testset [CustomTestSet] [options...] ["description"] begin test_ex end
@testset [CustomTestSet] [options...] ["description $v"] for v in itr test_ex end
@testset [CustomTestSet] [options...] ["description $v, $w"] for v in itrv, w in itrw test_ex end
@testset [CustomTestSet] [options...] ["description"] test_func()
@testset let v = v, w = w; test_ex; end

Avec begin/end ou appel de fonction

Lorsque @testset est utilisé, avec begin/end ou un seul appel de fonction, la macro commence un nouveau test set dans lequel évaluer l'expression donnée.

Si aucun type de testset personnalisé n'est donné, il crée par défaut un DefaultTestSet. DefaultTestSet enregistre tous les résultats et, s'il y a des Fails ou des Errors, lance une exception à la fin du test set de niveau supérieur (non imbriqué), accompagnée d'un résumé des résultats des tests.

Tout type de testset personnalisé (sous-type de AbstractTestSet) peut être donné et sera également utilisé pour toute invocation imbriquée de @testset. Les options données ne s'appliquent qu'au test set où elles sont fournies. Le type de test set par défaut accepte trois options booléennes :

• verbose : si true, le résumé des résultats des testsets imbriqués est affiché même lorsqu'ils passent tous (la valeur par défaut est false).
• showtiming : si true, la durée de chaque testset affiché est montrée (la valeur par défaut est true).
• failfast : si true, tout échec de test ou erreur fera que le testset et tous les testsets enfants retourneront immédiatement (la valeur par défaut est false). Cela peut également être défini globalement via la variable d'environnement JULIA_TEST_FAILFAST.

La chaîne de description accepte l'interpolation des indices de boucle. Si aucune description n'est fournie, une est construite en fonction des variables. Si un appel de fonction est fourni, son nom sera utilisé. Les chaînes de description explicites remplacent ce comportement.

Par défaut, la macro @testset renverra l'objet testset lui-même, bien que ce comportement puisse être personnalisé dans d'autres types de testset. Si une boucle for est utilisée, alors la macro collecte et renvoie une liste des valeurs de retour de la méthode finish, qui par défaut renverra une liste des objets testset utilisés à chaque itération.

Avant l'exécution du corps d'un @testset, il y a un appel implicite à Random.seed!(seed) où seed est la graine actuelle du RNG global. De plus, après l'exécution du corps, l'état du RNG global est restauré à ce qu'il était avant le @testset. Cela vise à faciliter la reproductibilité en cas d'échec et à permettre des réarrangements transparents des @testset indépendamment de leur effet secondaire sur l'état du RNG global.

Exemples

julia> @testset "trigonometric identities" begin
           θ = 2/3*π
           @test sin(-θ) ≈ -sin(θ)
           @test cos(-θ) ≈ cos(θ)
           @test sin(2θ) ≈ 2*sin(θ)*cos(θ)
           @test cos(2θ) ≈ cos(θ)^2 - sin(θ)^2
       end;
Test Summary:            | Pass  Total  Time
trigonometric identities |    4      4  0.2s

@testset for

Lorsque @testset for est utilisé, la macro commence un nouveau test pour chaque itération de la boucle fournie. La sémantique de chaque test set est autrement identique à celle du cas begin/end (comme si utilisé pour chaque itération de boucle).

@testset let

Lorsque @testset let est utilisé, la macro commence un test set transparent avec l'objet donné ajouté comme objet de contexte à tout test échouant contenu dans celui-ci. Cela est utile lors de l'exécution d'un ensemble de tests liés sur un objet plus grand et il est souhaitable d'imprimer cet objet plus grand lorsque l'un des tests individuels échoue. Les test sets transparents n'introduisent pas de niveaux supplémentaires d'imbrication dans la hiérarchie des test sets et sont transmis directement au test set parent (avec l'objet de contexte ajouté à tout test échouant).

Exemples

julia> @testset let logi = log(im)
           @test imag(logi) == π/2
           @test !iszero(real(logi))
       end
Test Failed at none:3
  Expression: !(iszero(real(logi)))
     Context: logi = 0.0 + 1.5707963267948966im

ERROR: Il y a eu une erreur pendant le test

julia> @testset let logi = log(im), op = !iszero
           @test imag(logi) == π/2
           @test op(real(logi))
       end
Test Failed at none:3
  Expression: op(real(logi))
     Context: logi = 0.0 + 1.5707963267948966im
              op = !iszero

ERROR: Il y a eu une erreur pendant le test

TestSetException

Lancé lorsqu'un ensemble de tests se termine et que tous les tests n'ont pas réussi.

@test_logs [log_patterns...] [keywords] expression

Collectez une liste d'enregistrements de journal générés par expression en utilisant collect_test_logs, vérifiez qu'ils correspondent à la séquence log_patterns, et renvoyez la valeur de expression. Les keywords fournissent un filtrage simple des enregistrements de journal : le mot-clé min_level contrôle le niveau de journal minimum qui sera collecté pour le test, le mot-clé match_mode définit comment la correspondance sera effectuée (le :all par défaut vérifie que tous les journaux et motifs correspondent par paires ; utilisez :any pour vérifier que le motif correspond au moins une fois quelque part dans la séquence.)

Le motif de journal le plus utile est un simple tuple de la forme (level,message). Un nombre différent d'éléments de tuple peut être utilisé pour correspondre à d'autres métadonnées de journal, correspondant aux arguments passés à AbstractLogger via la fonction handle_message : (level,message,module,group,id,file,line). Les éléments qui sont présents seront appariés par paires avec les champs d'enregistrement de journal en utilisant == par défaut, avec les cas spéciaux que les Symbols peuvent être utilisés pour les niveaux de journal standard, et les Regexs dans le motif correspondront aux champs de chaîne ou de symbole en utilisant occursin.

Exemples

Considérez une fonction qui enregistre un avertissement et plusieurs messages de débogage :

function foo(n)
    @info "Doing foo with n=$n"
    for i=1:n
        @debug "Iteration $i"
    end
    42
end

Nous pouvons tester le message d'information en utilisant

@test_logs (:info,"Doing foo with n=2") foo(2)

Si nous voulons également tester les messages de débogage, ceux-ci doivent être activés avec le mot-clé min_level :

using Logging
@test_logs (:info,"Doing foo with n=2") (:debug,"Iteration 1") (:debug,"Iteration 2") min_level=Logging.Debug foo(2)

Si vous souhaitez tester que certains messages particuliers sont générés tout en ignorant le reste, vous pouvez définir le mot-clé match_mode=:any :

using Logging
@test_logs (:info,) (:debug,"Iteration 42") min_level=Logging.Debug match_mode=:any foo(100)

Le macro peut être enchaîné avec @test pour tester également la valeur renvoyée :

@test (@test_logs (:info,"Doing foo with n=2") foo(2)) == 42

Si vous souhaitez tester l'absence d'avertissements, vous pouvez omettre la spécification des motifs de journal et définir le min_level en conséquence :

# test que l'expression ne journalise aucun message lorsque le niveau du journal est averti :
@test_logs min_level=Logging.Warn @info("Some information") # passe
@test_logs min_level=Logging.Warn @warn("Some information") # échoue

Si vous souhaitez tester l'absence d'avertissements (ou de messages d'erreur) dans stderr qui ne sont pas générés par @warn, consultez @test_nowarn.

TestLogger(; min_level=Info, catch_exceptions=false)

Créez un TestLogger qui capture les messages enregistrés dans son champ logs::Vector{LogRecord}.

Définissez min_level pour contrôler le LogLevel, catch_exceptions pour déterminer si les exceptions levées lors de la génération d'événements de journalisation doivent être capturées, et respect_maxlog pour savoir s'il faut suivre la convention de journaliser des messages avec maxlog=n pour un certain entier n au maximum n fois.

Voir aussi : LogRecord.

Exemples

julia> using Test, Logging

julia> f() = @info "Hi" number=5;

julia> test_logger = TestLogger();

julia> with_logger(test_logger) do
           f()
           @info "Bye!"
       end

julia> @test test_logger.logs[1].message == "Hi"
Test Passed

julia> @test test_logger.logs[1].kwargs[:number] == 5
Test Passed

julia> @test test_logger.logs[2].message == "Bye!"
Test Passed

LogRecord

Stocke les résultats d'un seul événement de journalisation. Champs :

• level : le LogLevel du message de journalisation
• message : le contenu textuel du message de journalisation
• _module : le module de l'événement de journalisation
• group : le groupe de journalisation (par défaut, le nom du fichier contenant l'événement de journalisation)
• id : l'ID de l'événement de journalisation
• file : le fichier contenant l'événement de journalisation
• line : la ligne dans le fichier de l'événement de journalisation
• kwargs : tous les arguments de mot-clé passés à l'événement de journalisation

@inferred [AllowedType] f(x)

Teste que l'expression d'appel f(x) renvoie une valeur du même type que celui inféré par le compilateur. Il est utile de vérifier la stabilité des types.

f(x) peut être n'importe quelle expression d'appel. Renvoie le résultat de f(x) si les types correspondent, et un Error Result s'il trouve des types différents.

En option, AllowedType assouplit le test, en le faisant réussir lorsque soit le type de f(x) correspond au type inféré modulo AllowedType, soit lorsque le type de retour est un sous-type de AllowedType. Cela est utile lors des tests de stabilité des types de fonctions renvoyant une petite union telle que Union{Nothing, T} ou Union{Missing, T}.

julia> f(a) = a > 1 ? 1 : 1.0
f (generic function with 1 method)

julia> typeof(f(2))
Int64

julia> @code_warntype f(2)
MethodInstance for f(::Int64)
  from f(a) @ Main none:1
Arguments
  #self#::Core.Const(f)
  a::Int64
Body::UNION{FLOAT64, INT64}
1 ─ %1 = (a > 1)::Bool
└──      goto #3 if not %1
2 ─      return 1
3 ─      return 1.0

julia> @inferred f(2)
ERROR: return type Int64 does not match inferred return type Union{Float64, Int64}
[...]

julia> @inferred max(1, 2)
2

julia> g(a) = a < 10 ? missing : 1.0
g (generic function with 1 method)

julia> @inferred g(20)
ERROR: return type Float64 does not match inferred return type Union{Missing, Float64}
[...]

julia> @inferred Missing g(20)
1.0

julia> h(a) = a < 10 ? missing : f(a)
h (generic function with 1 method)

julia> @inferred Missing h(20)
ERROR: return type Int64 does not match inferred return type Union{Missing, Float64, Int64}
[...]

@test_deprecated [pattern] expression

Lorsque --depwarn=yes, testez que expression émet un avertissement de dépréciation et renvoyez la valeur de expression. La chaîne de message de journal sera comparée à pattern, qui par défaut est r"deprecated"i.

Lorsque --depwarn=no, renvoyez simplement le résultat de l'exécution de expression. Lorsque --depwarn=error, vérifiez qu'une ErrorException est levée.

Exemples

# Déprécié dans julia 0.7
@test_deprecated num2hex(1)

# La valeur retournée peut être testée en chaînant avec @test :
@test (@test_deprecated num2hex(1)) == "0000000000000001"

@test_warn msg expr

Testez si l'évaluation de expr produit une sortie stderr qui contient la chaîne msg ou correspond à l'expression régulière msg. Si msg est une fonction booléenne, teste si msg(output) renvoie true. Si msg est un tuple ou un tableau, vérifie que la sortie d'erreur contient/correspond à chaque élément de msg. Renvoie le résultat de l'évaluation de expr.

Voir aussi @test_nowarn pour vérifier l'absence de sortie d'erreur.

Remarque : Les avertissements générés par @warn ne peuvent pas être testés avec cette macro. Utilisez @test_logs à la place.

@test_nowarn expr

Testez si l'évaluation de expr produit une sortie stderr vide (pas d'avertissements ni d'autres messages). Renvoie le résultat de l'évaluation de expr.

Remarque : L'absence d'avertissements générés par @warn ne peut pas être testée avec cette macro. Utilisez @test_logs à la place.

@test_broken ex
@test_broken f(args...) key=val ...

Indique un test qui devrait réussir mais échoue actuellement de manière constante. Teste si l'expression ex évalue à false ou provoque une exception. Renvoie un Result Broken si c'est le cas, ou un Result Error si l'expression évalue à true. Cela équivaut à @test ex broken=true.

La forme @test_broken f(args...) key=val... fonctionne comme pour la macro @test.

Exemples

julia> @test_broken 1 == 2
Test Broken
  Expression: 1 == 2

julia> @test_broken 1 == 2 atol=0.1
Test Broken
  Expression: ==(1, 2, atol = 0.1)

@test_skip ex
@test_skip f(args...) key=val ...

Marque un test qui ne doit pas être exécuté mais qui doit être inclus dans le rapport de résumé des tests comme Broken. Cela peut être utile pour des tests qui échouent de manière intermittente, ou des tests de fonctionnalités pas encore implémentées. Cela équivaut à @test ex skip=true.

La forme @test_skip f(args...) key=val... fonctionne comme pour la macro @test.

Exemples

julia> @test_skip 1 == 2
Test Broken
  Skipped: 1 == 2

julia> @test_skip 1 == 2 atol=0.1
Test Broken
  Skipped: ==(1, 2, atol = 0.1)

Test.Result

Tous les tests produisent un objet de résultat. Cet objet peut ou non être stocké, en fonction de si le test fait partie d'un ensemble de tests.

Test.Pass <: Test.Result

La condition de test était vraie, c'est-à-dire que l'expression a été évaluée à vraie ou que l'exception correcte a été levée.

Test.Fail <: Test.Result

La condition de test était fausse, c'est-à-dire que l'expression a été évaluée à faux ou que l'exception correcte n'a pas été levée.

Test.Error <: Test.Result

La condition de test n'a pas pu être évaluée en raison d'une exception, ou elle a été évaluée à quelque chose d'autre qu'un Bool. Dans le cas de @test_broken, il est utilisé pour indiquer qu'un Result Pass inattendu s'est produit.

Test.Broken <: Test.Result

La condition de test est le résultat attendu (échoué) d'un test cassé, ou a été explicitement ignorée avec @test_skip.

record(ts::AbstractTestSet, res::Result)

Enregistre un résultat dans un ensemble de tests. Cette fonction est appelée par l'infrastructure @testset chaque fois qu'un macro @test contenu se termine, et reçoit le résultat du test (qui pourrait être une Error). Cela sera également appelé avec une Error si une exception est levée à l'intérieur du bloc de test mais en dehors d'un contexte @test.

finish(ts::AbstractTestSet)

Effectuez tout traitement final nécessaire pour le testset donné. Cela est appelé par l'infrastructure @testset après l'exécution d'un bloc de test.

Les sous-types AbstractTestSet personnalisés doivent appeler record sur leur parent (s'il y en a un) pour s'ajouter à l'arbre des résultats de test. Cela pourrait être implémenté comme suit :

if get_testset_depth() != 0
    # Attacher ce test set au test set parent
    parent_ts = get_testset()
    record(parent_ts, self)
    return self
end

get_testset()

Récupère l'ensemble de test actif à partir du stockage local de la tâche. Si aucun ensemble de test n'est actif, utilise l'ensemble de test par défaut de secours.

get_testset_depth()

Retourne le nombre de jeux de tests actifs, sans inclure le jeu de tests par défaut.

TestCounts

Contient l'état pour rassembler de manière récursive les résultats d'un ensemble de tests à des fins d'affichage.

Champs :

• customized : Indique si la fonction get_test_counts a été personnalisée pour l'AbstractTestSet pour lequel cet objet de comptage est destiné. Si une méthode personnalisée a été définie, passez toujours true au constructeur.
• passes : Le nombre d'invocations @test réussies.
• fails : Le nombre d'invocations @test échouées.
• errors : Le nombre d'invocations @test avec erreurs.
• broken : Le nombre d'invocations @test cassées.
• passes : Le nombre cumulatif d'invocations @test réussies.
• fails : Le nombre cumulatif d'invocations @test échouées.
• errors : Le nombre cumulatif d'invocations @test avec erreurs.
• broken : Le nombre cumulatif d'invocations @test cassées.
• duration : La durée totale pendant laquelle l'AbstractTestSet en question a été exécuté, sous forme de String formatée.

" gettestcounts(::AbstractTestSet) -> TestCounts

Fonction récursive qui compte le nombre de résultats de test de chaque type directement dans le testset, et totalise à travers les testsets enfants.

Les AbstractTestSet personnalisés doivent implémenter cette fonction pour que leurs totaux soient comptés et affichés avec DefaultTestSet également.

Si cela n'est pas implémenté pour un TestSet personnalisé, l'impression revient à signaler x pour les échecs et ?s pour la durée.

format_duration(::AbstractTestSet)

Retourne une chaîne formatée pour afficher la durée pendant laquelle le testset a été exécuté.

Si non défini, revient à "?s".

print_test_results(ts::AbstractTestSet, depth_pad=0)

Imprime les résultats d'un AbstractTestSet sous forme de tableau formaté.

depth_pad fait référence à la quantité de remplissage qui doit être ajoutée devant toute sortie.

Appelé à l'intérieur de Test.finish, si le testset finishé est le testset le plus haut.

Le GenericArray peut être utilisé pour tester les API de tableau génériques qui programment l'interface AbstractArray, afin de s'assurer que les fonctions peuvent fonctionner avec des types de tableau autres que le type Array standard.

Le GenericDict peut être utilisé pour tester les API de dictionnaire génériques qui programment l'interface AbstractDict, afin de s'assurer que les fonctions peuvent fonctionner avec des types associatifs en plus du type Dict standard.

Le GenericOrder peut être utilisé pour tester les API pour leur prise en charge des types ordonnés génériques.

Le GenericSet peut être utilisé pour tester les API de ensembles génériques qui programment l'interface AbstractSet, afin de s'assurer que les fonctions peuvent fonctionner avec des types d'ensembles autres que les types standard Set et BitSet.

Le GenericString peut être utilisé pour tester les API de chaînes génériques qui programment l'interface AbstractString, afin de s'assurer que les fonctions peuvent fonctionner avec des types de chaînes autres que le type standard String.

detect_ambiguities(mod1, mod2...; recursive=false,
                                  ambiguous_bottom=false,
                                  allowed_undefineds=nothing)

Renvoie un vecteur de paires (Method,Method) de méthodes ambiguës définies dans les modules spécifiés. Utilisez recursive=true pour tester dans tous les sous-modules.

ambiguous_bottom contrôle si les ambiguïtés déclenchées uniquement par des paramètres de type Union{} sont incluses ; dans la plupart des cas, vous voudrez probablement définir cela sur false. Voir Base.isambiguous.

Voir Test.detect_unbound_args pour une explication de allowed_undefineds.

detect_unbound_args(mod1, mod2...; recursive=false, allowed_undefineds=nothing)

Renvoie un vecteur de Methods qui peuvent avoir des paramètres de type non liés. Utilisez recursive=true pour tester dans tous les sous-modules.

Par défaut, tout symbole non défini déclenche un avertissement. Cet avertissement peut être supprimé en fournissant une collection de GlobalRefs pour lesquels l'avertissement peut être ignoré. Par exemple, en définissant

allowed_undefineds = Set([GlobalRef(Base, :active_repl),
                          GlobalRef(Base, :active_repl_backend)])

vous supprimeriez les avertissements concernant Base.active_repl et Base.active_repl_backend.