Unit Testing

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

tests içinde listelenen Julia birim testlerini çalıştırın; bu, bir dize veya dizeler dizisi olabilir ve ncores işlemcisi kullanır. exit_on_error false ise, bir test başarısız olduğunda, diğer dosyalardaki tüm kalan testler yine de çalıştırılacaktır; aksi takdirde, exit_on_error == true olduğunda atlanır. revise true ise, testler çalıştırılmadan önce Base veya standart kütüphanelerdeki herhangi bir değişikliği yüklemek için Revise paketi kullanılır. Eğer bir tohum anahtar argümanı aracılığıyla sağlanmışsa, bu, testlerin çalıştırıldığı bağlamda küresel RNG'yi tohumlamak için kullanılır; aksi takdirde tohum rastgele seçilir.

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

ex ifadesinin true değerine eşit olduğunu test edin. Eğer bir @testset içinde çalıştırılırsa, true ise Pass Result döndürün, false ise Fail Result döndürün ve değerlendirilemezse Error Result döndürün. Eğer bir @testset dışında çalıştırılırsa, Fail veya Error döndürmek yerine bir istisna fırlatın.

Örnekler

julia> @test true
Test Geçti

julia> @test [1, 2] + [2, 1] == [3, 3]
Test Geçti

@test f(args...) key=val... biçimi, @test f(args..., key=val...) yazmakla eşdeğerdir ve bu, ifadenin yaklaşık karşılaştırmalar gibi infiks sözdizimi kullanan bir çağrı olması durumunda yararlı olabilir:

julia> @test π ≈ 3.14 atol=0.01
Test Geçti

Bu, daha çirkin bir test olan @test ≈(π, 3.14, atol=0.01) ile eşdeğerdir. İlk ifade bir çağrı ifadesi olmadıkça birden fazla ifade sağlamak bir hatadır ve geri kalanlar atama (k=v) olmalıdır.

key=val argümanları için herhangi bir anahtar kullanabilirsiniz, ancak broken ve skip anahtarları, @test bağlamında özel anlamlara sahiptir:

• broken=cond, cond==true olduğunda geçmesi gereken ancak şu anda sürekli olarak başarısız olan bir testi belirtir. ex ifadesinin false değerine eşit olduğunu veya bir istisna oluşturduğunu test eder. Eğer öyleyse Broken Result döndürür veya ifade true değerine eşit olursa Error Result döndürür. cond==false olduğunda normal @test ex değerlendirilir.
• skip=cond, cond==true olduğunda çalıştırılmaması gereken ancak test özeti raporlamasında Broken olarak dahil edilmesi gereken bir testi işaretler. Bu, aralıklı olarak başarısız olan testler veya henüz uygulanmamış işlevsellik testleri için yararlı olabilir. cond==false olduğunda normal @test ex değerlendirilir.

Örnekler

julia> @test 2 + 2 ≈ 6 atol=1 broken=true
Test Bozuk
  İfade: ≈(2 + 2, 6, atol = 1)

julia> @test 2 + 2 ≈ 5 atol=1 broken=false
Test Geçti

julia> @test 2 + 2 == 5 skip=true
Test Bozuk
  Atlandı: 2 + 2 == 5

julia> @test 2 + 2 == 4 skip=false
Test Geçti

@test_throws exception expr

expr ifadesinin exception fırlattığını test eder. İstisna, görüntülenen hata mesajında meydana gelen bir tür, bir dize, düzenli ifade veya dize listesini belirtebilir, bir eşleşme fonksiyonu veya bir değer (alanları karşılaştırarak eşitlik için test edilecektir) olabilir. @test_throws'ın bir son anahtar biçimini desteklemediğini unutmayın.

Örnekler

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))."

Son örnekte, tek bir dize ile eşleşmek yerine alternatif olarak şu şekilde yapılabilirdi:

• ["Try", "Complex"] (bir dize listesi)
• r"Try sqrt\([Cc]omplex" (bir düzenli ifade)
• str -> occursin("complex", str) (bir eşleşme fonksiyonu)

@testset [ÖzelTestSet] [seçenekler...] ["açıklama"] begin test_ex end
@testset [ÖzelTestSet] [seçenekler...] ["açıklama $v"] for v in itr test_ex end
@testset [ÖzelTestSet] [seçenekler...] ["açıklama $v, $w"] for v in itrv, w in itrw test_ex end
@testset [ÖzelTestSet] [seçenekler...] ["açıklama"] test_func()
@testset let v = v, w = w; test_ex; end

begin/end veya fonksiyon çağrısı ile

@testset kullanıldığında, begin/end veya tek bir fonksiyon çağrısı ile, makro verilen ifadeyi değerlendirmek için yeni bir test seti başlatır.

Eğer özel bir test seti türü verilmezse, varsayılan olarak DefaultTestSet oluşturulur. DefaultTestSet, tüm sonuçları kaydeder ve eğer herhangi bir Fail veya Error varsa, üst düzey (iç içe olmayan) test setinin sonunda bir istisna fırlatır ve test sonuçlarının bir özetini sunar.

Herhangi bir özel test seti türü ( AbstractTestSet alt türü) verilebilir ve bu, iç içe @testset çağrıları için de kullanılacaktır. Verilen seçenekler yalnızca verildikleri test setine uygulanır. Varsayılan test seti türü üç boolean seçeneği kabul eder:

• verbose: true ise, iç içe test setlerinin sonuç özeti, hepsi geçtiğinde bile gösterilir (varsayılan false).
• showtiming: true ise, her gösterilen test setinin süresi gösterilir (varsayılan true).
• failfast: true ise, herhangi bir test hatası veya hatası, test setinin ve herhangi bir alt test setinin hemen dönmesine neden olur (varsayılan false). Bu, ayrıca JULIA_TEST_FAILFAST ortam değişkeni aracılığıyla küresel olarak ayarlanabilir.

Açıklama dizesi döngü indekslerinden interpolasyonu kabul eder. Eğer açıklama sağlanmazsa, değişkenlere dayalı olarak bir tane oluşturulur. Eğer bir fonksiyon çağrısı sağlanırsa, adı kullanılacaktır. Açık açıklama dizeleri bu davranışı geçersiz kılar.

Varsayılan olarak @testset makrosu test seti nesnesinin kendisini döndürecektir, ancak bu davranış diğer test seti türlerinde özelleştirilebilir. Eğer bir for döngüsü kullanılıyorsa, makro finish yönteminin döndürdüğü değerlerin bir listesini toplar ve döndürür; bu, varsayılan olarak her yinelemede kullanılan test seti nesnelerinin bir listesini döndürecektir.

@testset gövdesinin yürütülmesinden önce, Random.seed!(seed)'e örtük bir çağrı vardır; burada seed, küresel RNG'nin mevcut tohumudur. Ayrıca, gövdenin yürütülmesinden sonra, küresel RNG'nin durumu @testset öncesindeki haline geri yüklenir. Bu, başarısızlık durumunda yeniden üretilebilirliği kolaylaştırmak ve @testset'lerin küresel RNG durumu üzerindeki yan etkilerine bakılmaksızın sorunsuz yeniden düzenlenmesine izin vermek içindir.

Örnekler

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

@testset for kullanıldığında, makro sağlanan döngünün her yinelemesi için yeni bir test başlatır. Her test setinin anlamı, begin/end durumundaki ile aynıdır (her döngü yinelemesi için kullanılmış gibi).

@testset let

@testset let kullanıldığında, makro verilen nesneyi içindeki herhangi bir başarısız test için bir bağlam nesnesi olarak ekleyerek şeffaf bir test seti başlatır. Bu, bir büyük nesne üzerinde bir dizi ilgili test gerçekleştirirken ve bireysel testlerden herhangi biri başarısız olduğunda bu büyük nesneyi yazdırmak istenildiğinde faydalıdır. Şeffaf test setleri, test seti hiyerarşisinde ek iç içe katmanlar oluşturmaz ve doğrudan üst test setine geçilir (bağlam nesnesi herhangi bir başarısız testin yanına eklenir).

Örnekler

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

HATA: Test sırasında bir hata oluştu

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

HATA: Test sırasında bir hata oluştu

TestSetException

Bir test seti tamamlandığında ve tüm testler geçmediğinde fırlatılır.

@test_logs [log_patterns...] [keywords] ifade

ifade tarafından üretilen log kayıtlarının bir listesini collect_test_logs kullanarak toplayın, bunların log_patterns dizisine uyduğunu kontrol edin ve ifade değerini döndürün. keywords log kayıtlarının basit bir filtrelemesini sağlar: min_level anahtarı, test için toplanacak minimum log seviyesini kontrol eder, match_mode anahtarı eşleşmenin nasıl yapılacağını tanımlar (varsayılan :all, tüm logların ve desenlerin çiftler halinde eşleştiğini kontrol eder; :any kullanarak desenin dizide en az bir yerde eşleşip eşleşmediğini kontrol edebilirsiniz.)

En kullanışlı log deseni, (level,message) biçiminde basit bir demettir. Diğer log meta verilerini eşleştirmek için farklı sayıda demet elemanı kullanılabilir; bu, handle_message fonksiyonu aracılığıyla AbstractLogger'a geçirilen argümanlara karşılık gelir: (level,message,module,group,id,file,line). Mevcut olan elemanlar, varsayılan olarak == kullanılarak log kaydı alanlarıyla çiftler halinde eşleştirilecektir; Symbol'lerin standart log seviyeleri için kullanılabileceği ve desendeki Regex'lerin string veya Symbol alanlarıyla occursin kullanarak eşleşeceği özel durumlar vardır.

Örnekler

Bir uyarı kaydeden ve birkaç debug mesajı üreten bir fonksiyonu düşünün:

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

Info mesajını test edebiliriz:

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

Eğer debug mesajlarını da test etmek istiyorsak, bunların min_level anahtarı ile etkinleştirilmesi gerekir:

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

Belirli mesajların üretilip üretilmediğini test etmek istiyorsanız, match_mode=:any anahtarını ayarlayabilirsiniz:

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

Makro, döndürülen değeri de test etmek için @test ile zincirlenebilir:

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

Uyarıların yokluğunu test etmek istiyorsanız, log desenlerini belirtmeyi atlayabilir ve min_level'i buna göre ayarlayabilirsiniz:

# logger seviyesi uyarı olduğunda ifadenin hiçbir mesaj kaydetmediğini test edin:
@test_logs min_level=Logging.Warn @info("Some information") # geçer
@test_logs min_level=Logging.Warn @warn("Some information") # başarısız

@warn tarafından üretilmeyen stderr içinde uyarıların (veya hata mesajlarının) yokluğunu test etmek istiyorsanız, @test_nowarn bakın. ```

TestLogger(; min_level=Info, catch_exceptions=false)

logs::Vector{LogRecord} alanında kaydedilen mesajları yakalayan bir TestLogger oluşturun.

LogLevel'ı kontrol etmek için min_level'i, log olayı oluşturma sırasında atılan istisnaların yakalanıp yakalanmayacağını belirlemek için catch_exceptions'ı ve en fazla n kez loglama konvansiyonunu takip edip etmeyeceğini belirlemek için respect_maxlog'ı ayarlayın.

Ayrıca bkz: LogRecord.

Örnekler

julia> using Test, Logging

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

julia> test_logger = TestLogger();

julia> with_logger(test_logger) do
           f()
           @info "Hoşça kal!"
       end

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

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

julia> @test test_logger.logs[2].message == "Hoşça kal!"
Test Passed

LogRecord

Tek bir günlük olayının sonuçlarını saklar. Alanlar:

• level: günlük mesajının LogLevel seviyesi
• message: günlük mesajının metinsel içeriği
• _module: günlük olayının modülü
• group: günlük grubu (varsayılan olarak, günlük olayını içeren dosyanın adı)
• id: günlük olayının kimliği
• file: günlük olayını içeren dosya
• line: günlük olayının dosya içindeki satırı
• kwargs: günlük olayına geçirilen herhangi bir anahtar kelime argümanı

@inferred [AllowedType] f(x)

Çağrı ifadesinin f(x) derleyici tarafından çıkarılan aynı türde bir değer döndürdüğünü test eder. Tür kararlılığını kontrol etmek için yararlıdır.

f(x) herhangi bir çağrı ifadesi olabilir. Türler eşleşirse f(x)'in sonucunu döndürür ve farklı türler bulursa bir Hata Sonucu döndürür.

İsteğe bağlı olarak, AllowedType testi gevşetir; bu, f(x)'in türü çıkarılan türle AllowedType modülünde eşleştiğinde veya dönen tür AllowedType'in bir alt türü olduğunda geçmesini sağlar. Bu, Union{Nothing, T} veya Union{Missing, T} gibi küçük bir birleşim döndüren fonksiyonların tür kararlılığını test ederken yararlıdır.

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)
HATA: dönüş türü Int64 çıkarılan dönüş türü Union{Float64, Int64} ile eşleşmiyor
[...]

julia> @inferred max(1, 2)
2

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

julia> @inferred g(20)
HATA: dönüş türü Float64 çıkarılan dönüş türü Union{Missing, Float64} ile eşleşmiyor
[...]

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)
HATA: dönüş türü Int64 çıkarılan dönüş türü Union{Missing, Float64, Int64} ile eşleşmiyor
[...]

@test_deprecated [pattern] expression

--depwarn=yes olduğunda, expression'ın bir deprecasyon uyarısı yaydığını test edin ve expression'ın değerini döndürün. Log mesajı dizesi, varsayılan olarak r"deprecated"i olan pattern ile eşleşecektir.

--depwarn=no olduğunda, sadece expression'ın çalıştırılmasının sonucunu döndürün. --depwarn=error olduğunda, bir ErrorException'ın fırlatıldığını kontrol edin.

Örnekler

# Julia 0.7'de kullanımdan kaldırıldı
@test_deprecated num2hex(1)

# Döndürülen değer, @test ile zincirleme yapılarak test edilebilir:
@test (@test_deprecated num2hex(1)) == "0000000000000001"

@test_warn msg expr

expr ifadesinin değerlendirilmesinin msg dizesini içeren veya msg düzenli ifadesiyle eşleşen stderr çıktısına neden olup olmadığını test eder. Eğer msg bir boolean fonksiyonuysa, msg(output) ifadesinin true döndürüp döndürmediğini test eder. Eğer msg bir demet veya dizi ise, hata çıktısının msg içindeki her bir öğeyi içerip içermediğini/kapsayıp kapsamadığını kontrol eder. expr ifadesinin değerlendirilmesinin sonucunu döndürür.

Hata çıktısının yokluğunu kontrol etmek için @test_nowarn makrosunu da inceleyin.

Not: @warn ile üretilen uyarılar bu makro ile test edilemez. Bunun yerine @test_logs kullanın.

@test_nowarn expr

expr ifadesinin değerlendirilmesinin boş stderr çıktısı (uyarılar veya diğer mesajlar olmadan) ile sonuçlanıp sonuçlanmadığını test eder. expr ifadesinin değerlendirilmesinin sonucunu döndürür.

Not: @warn tarafından üretilen uyarıların yokluğunun bu makro ile test edilemeyeceğini unutmayın. Bunun yerine @test_logs kullanın.

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

Başarılı olması gereken ancak şu anda sürekli olarak başarısız olan bir testi belirtir. ex ifadesinin false değerini döndürdüğünü veya bir istisna oluşturduğunu test eder. Eğer öyleyse, bir Broken Result döner; aksi takdirde, ifade true değerini dönerse bir Error Result döner. Bu, @test ex broken=true ile eşdeğerdir.

@test_broken f(args...) key=val... biçimi, @test makrosu için olduğu gibi çalışır.

Örnekler

julia> @test_broken 1 == 2
Test Broken
  İfade: 1 == 2

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

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

Testin çalıştırılmaması gereken bir testi işaretler, ancak test özeti raporlamasında Broken olarak dahil edilmelidir. Bu, aralıklı olarak başarısız olan testler veya henüz uygulanmamış işlevselliğin testleri için yararlı olabilir. Bu, @test ex skip=true ile eşdeğerdir.

@test_skip f(args...) key=val... biçimi, @test makrosu için olduğu gibi çalışır.

Örnekler

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

Tüm testler bir sonuç nesnesi üretir. Bu nesne, testin bir test setinin parçası olup olmamasına bağlı olarak saklanabilir veya saklanmayabilir.

Test.Pass <: Test.Result

Test koşulu doğruydu, yani ifade doğru olarak değerlendirildi veya doğru istisna fırlatıldı.

Test.Fail <: Test.Result

Test koşulu yanlıştı, yani ifade yanlış olarak değerlendirildi veya doğru istisna fırlatılmadı.

Test.Error <: Test.Result

Test koşulu bir istisna nedeniyle değerlendirilemedi veya Bool dışında bir şeye değerlendirildi. @test_broken durumunda, beklenmeyen bir Pass Result'ın meydana geldiğini belirtmek için kullanılır.

Test.Broken <: Test.Result

Test koşulu, bir kırık testin beklenen (başarısız) sonucudur veya açıkça @test_skip ile atlanmıştır.

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

Bir sonucu bir test setine kaydedin. Bu işlev, her seferinde bir @test makrosu tamamlandığında @testset altyapısı tarafından çağrılır ve test sonucunu (bir Error olabilir) alır. Ayrıca, test bloğu içinde ancak bir @test bağlamının dışında bir istisna fırlatıldığında bir Error ile de çağrılacaktır.

finish(ts::AbstractTestSet)

Verilen test seti için gerekli son işlemleri yapar. Bu, bir test bloğu çalıştıktan sonra @testset altyapısı tarafından çağrılır.

Özel AbstractTestSet alt türleri, kendilerini test sonuçları ağacına eklemek için ebeveynlerine (varsa) record çağırmalıdır. Bu şu şekilde uygulanabilir:

if get_testset_depth() != 0
    # Bu test setini ebeveyn test setine ekle
    parent_ts = get_testset()
    record(parent_ts, self)
    return self
end

get_testset()

Görevlerin yerel depolamasından aktif test setini alır. Eğer aktif bir test seti yoksa, yedek varsayılan test setini kullanır.

get_testset_depth()

Varsayılan test seti hariç, aktif test setlerinin sayısını döndürür.

TestCounts

Test setinin sonuçlarını görüntüleme amaçları için özyinelemeli olarak toplamak için durumu tutar.

Alanlar:

• customized: get_test_counts fonksiyonunun bu sayım nesnesi için özelleştirilip özelleştirilmediği AbstractTestSet. Eğer özel bir yöntem tanımlandıysa, her zaman yapıcıya true geçin.
• passes: Geçen @test çağrılarının sayısı.
• fails: Başarısız olan @test çağrılarının sayısı.
• errors: Hata veren @test çağrılarının sayısı.
• broken: Bozuk olan @test çağrılarının sayısı.
• passes: Geçen @test çağrılarının kümülatif sayısı.
• fails: Başarısız olan @test çağrılarının kümülatif sayısı.
• errors: Hata veren @test çağrılarının kümülatif sayısı.
• broken: Bozuk olan @test çağrılarının kümülatif sayısı.
• duration: Söz konusu AbstractTestSet'in çalıştığı toplam süre, biçimlendirilmiş bir String olarak.

" gettestcounts(::AbstractTestSet) -> TestCounts

Test setindeki her tür test sonucunun sayısını doğrudan sayan ve alt test setleri arasında toplamını hesaplayan özyinelemeli bir işlevdir.

Özel AbstractTestSet, toplamlarının DefaultTestSet ile birlikte sayılması ve görüntülenmesi için bu işlevi uygulamalıdır.

Eğer özel bir TestSet için bu uygulanmamışsa, yazdırma işlemi başarısızlıklar için x ve süre için ?s raporlamaya geri döner."

format_duration(::AbstractTestSet)

Test set'in çalıştığı süreyi yazdırmak için biçimlendirilmiş bir dize döndürür.

Tanımlı değilse, "?s"'ye geri döner.

print_test_results(ts::AbstractTestSet, depth_pad=0)

Bir AbstractTestSet'in sonuçlarını biçimlendirilmiş bir tablo olarak yazdırır.

depth_pad, tüm çıktının önüne ne kadar boşluk eklenmesi gerektiğini belirtir.

Test.finish içinde çağrılır, eğer finish edilen test seti en üstteki test setiyse.

GenericArray, AbstractArray arayüzüne program yapan genel dizi API'lerini test etmek için kullanılabilir, böylece işlevlerin standart Array türü dışında dizi türleriyle çalışabilmesini sağlanır.

GenericDict, AbstractDict arayüzüne program yapan genel dict API'lerini test etmek için kullanılabilir, böylece işlevlerin standart Dict türü dışında ilişkilendirilmiş türlerle çalışabileceğinden emin olunabilir.

GenericOrder, genel sıralı türlerin desteklenip desteklenmediğini test etmek için kullanılabilir.

GenericSet, AbstractSet arayüzüne program yapan genel küme API'lerini test etmek için kullanılabilir, böylece işlevlerin standart Set ve BitSet türleri dışında küme türleriyle çalışabileceğinden emin olunur.

GenericString, AbstractString arayüzüne program yapan genel dize API'lerini test etmek için kullanılabilir, böylece işlevlerin standart String türü dışında dize türleriyle çalışabilmesi sağlanır.

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

Belirtilen modüllerde tanımlı belirsiz yöntemlerin (Method,Method) çiftlerinden oluşan bir vektör döndürür. Tüm alt modüllerde test etmek için recursive=true kullanın.

ambiguous_bottom, yalnızca Union{} tür parametreleri tarafından tetiklenen belirsizliklerin dahil edilip edilmeyeceğini kontrol eder; çoğu durumda bunu false olarak ayarlamak isteyebilirsiniz. Base.isambiguous için bakın.

allowed_undefineds ile ilgili bir açıklama için Test.detect_unbound_args bakın.

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

Bağlı olmayan tür parametrelerine sahip olabilecek Methodlerin bir vektörünü döndürür. Tüm alt modüllerde test etmek için recursive=true kullanın.

Varsayılan olarak, herhangi bir tanımsız sembol bir uyarı tetikler. Bu uyarı, atlanabilecek bir GlobalRef koleksiyonu sağlayarak bastırılabilir. Örneğin, ayarlamak

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

Base.active_repl ve Base.active_repl_backend hakkında uyarıları bastırır.