單元測試

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

使用 ncores 處理器執行 tests 中列出的 Julia 單元測試，該測試可以是字串或字串陣列。如果 exit_on_error 為 false，當一個測試失敗時，其他檔案中所有剩餘的測試仍會執行；否則，當 exit_on_error == true 時，它們會被捨棄。如果 revise 為 true，則會使用 Revise 套件載入對 Base 或標準函式庫的任何修改，然後再執行測試。如果透過關鍵字參數提供種子，則會使用該種子為執行測試的內容中全球 RNG 播種；否則，會隨機選擇種子。

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

測試表達式 ex 的評估結果為 true。如果在 @testset 內執行，如果評估結果為 true，則傳回 Pass Result；如果評估結果為 false，則傳回 Fail Result；如果無法評估，則傳回 Error Result。如果在 @testset 外執行，則擲回例外，而不是傳回 Fail 或 Error。

範例

julia> @test true
Test Passed

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

@test f(args...) key=val... 形式等於寫入 @test f(args..., key=val...)，當表達式是使用中綴語法（例如近似比較）的呼叫時，這會很有用

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

這等於較醜陋的測試 @test ≈(π, 3.14, atol=0.01)。提供多於一個表達式是錯誤的，除非第一個是呼叫表達式，而其餘的是指派（k=v）。

你可以對 key=val 參數使用任何鍵，但 broken 和 skip 除外，它們在 @test 的內容中具有特殊意義

• broken=cond 指示一個測試，當 cond==true 時，它應該通過，但目前持續失敗。測試表達式 ex 的評估結果為 false 或導致例外。如果評估結果為 true，則傳回 Broken Result；如果表達式評估結果為 true，則傳回 Error Result。當 cond==false 時，評估常規 @test ex。
• skip=cond 標記一個不應執行的測試，但當 cond==true 時，應將其包含在測試摘要報告中，標示為 Broken。這對於間歇性失敗的測試或尚未實作功能的測試很有用。當 cond==false 時，評估常規 @test ex。

範例

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

測試表達式 expr 是否拋出 exception。例外狀況可以指定類型、字串、正規表示法或出現在顯示錯誤訊息中的字串清單、配對函數或值（會透過比較欄位來測試相等性）。請注意，@test_throws 不支援尾端關鍵字形式。

範例

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

在最後一個範例中，除了配對單一字串之外，也可以使用下列方式執行：

• ["Try", "Complex"]（字串清單）
• r"Try sqrt\([Cc]omplex"（正規表示法）
• str -> occursin("complex", str)（配對函數）

@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

使用 begin/end 或函數呼叫

當使用 @testset 時，使用 begin/end 或單一函數呼叫，巨集會啟動一個新的測試集合，用來評估給定的表達式。

如果未給定自訂測試集合類型，它預設會建立 DefaultTestSet。DefaultTestSet 會記錄所有結果，並且如果出現任何 Fail 或 Error，它會在頂層（非巢狀）測試集合結束時拋出例外，以及測試結果摘要。

可以給定任何自訂測試集合類型（AbstractTestSet 的子類型），它也會用於任何巢狀 @testset 呼叫。給定的選項僅套用於給定選項的測試集合。預設測試集合類型接受三個布林選項

• verbose：如果為 true，即使所有巢狀測試集合都通過，也會顯示結果摘要（預設為 false）。
• showtiming：如果為 true，將顯示每個顯示測試集合的持續時間（預設為 true）。
• failfast：如果為 true，任何測試失敗或錯誤都將導致測試集合和任何子測試集合立即返回（預設為 false）。這也可以透過環境變數 JULIA_TEST_FAILFAST 全域設定。

描述字串接受迴圈索引的內插。如果未提供描述，則會根據變數建構一個描述。如果提供了函式呼叫，將會使用其名稱。明確的描述字串會覆寫此行為。

預設情況下，@testset 巨集會傳回測試集物件本身，儘管此行為可以在其他測試集類型中自訂。如果使用了 for 迴圈，則巨集會收集並傳回 finish 方法的傳回值清單，預設情況下會傳回每個反覆運算中使用的測試集物件清單。

在執行 @testset 主體之前，會隱式呼叫 Random.seed!(seed)，其中 seed 是全域 RNG 的目前種子。此外，在執行主體之後，全域 RNG 的狀態會還原為 @testset 之前的狀態。這是為了在發生故障時簡化重製，並允許無縫重新排列 @testset，而不論它們對全域 RNG 狀態的副作用為何。

範例

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 時，巨集會為提供的迴圈的每個反覆運算開始一個新的測試。每個測試集的語意與 begin/end 案例相同（就像用於每個迴圈反覆運算一樣）。

@testset let

當使用 @testset let 時，巨集會開始一個透明測試集，其中給定的物件會新增為其中任何失敗測試的內容物件。當對一個較大的物件執行一組相關測試，並且希望在任何個別測試失敗時列印這個較大的物件時，這會很有用。透明測試集不會在測試集階層中引入額外的巢狀層級，並會直接傳遞到父測試集（將內容物件附加到任何失敗測試）。

範例

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: There was an error during testing

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: There was an error during testing

TestSetException

當測試集結束且並非所有測試都通過時擲出。

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

使用 collect_test_logs 收集由 expression 產生的記錄清單，檢查它們是否符合順序 log_patterns，並傳回 expression 的值。keywords 提供記錄的簡單過濾：min_level 關鍵字控制將為測試收集的最低記錄層級，match_mode 關鍵字定義如何執行比對（預設的 :all 檢查所有記錄和模式是否成對比對；使用 :any 檢查模式是否在順序中某處至少比對一次。）

最實用的記錄模式是簡單的元組，格式為 (level,message)。可以使用不同數量的元組元素來比對其他記錄的元資料，這些元資料對應傳遞給 AbstractLogger 的引數，透過 handle_message 函式：(level,message,module,group,id,file,line)。預設情況下，存在的元素會使用 == 與記錄欄位成對比對，特殊情況是，標準記錄層級可以使用 Symbol，而模式中的 Regex 會使用 occursin 比對字串或 Symbol 欄位。

範例

考慮一個記錄警告和多個偵錯訊息的函式

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

我們可以使用以下方式測試資訊訊息

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

如果我們也想要測試偵錯訊息，這些訊息需要使用 min_level 關鍵字啟用

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

如果您想要測試某些特定訊息是否產生，同時忽略其他訊息，您可以設定關鍵字 match_mode=:any

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

巨集可以與 @test 串連，以同時測試回傳值

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

如果您想要測試沒有警告，您可以省略指定記錄模式，並適當地設定 min_level

# test that the expression logs no messages when the logger level is warn:
@test_logs min_level=Logging.Warn @info("Some information") # passes
@test_logs min_level=Logging.Warn @warn("Some information") # fails

如果您想要測試 stderr 中沒有警告（或錯誤訊息），而這些訊息並非由 @warn 產生，請參閱 @test_nowarn。

TestLogger(; min_level=Info, catch_exceptions=false)

建立一個 TestLogger，它會在其 logs::Vector{LogRecord} 欄位中擷取已記錄的訊息。

設定 min_level 以控制 LogLevel，設定 catch_exceptions 以控制是否擷取作為記錄事件產生一部分而擲出的例外，設定 respect_maxlog 以控制是否遵循記錄訊息的慣例，其中 maxlog=n，其中整數 n 最多為 n 次。

另請參閱：LogRecord。

範例

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

儲存單一記錄事件的結果。欄位

• level：記錄訊息的 LogLevel
• message：記錄訊息的文字內容
• _module：記錄事件的模組
• group：記錄群組（預設為包含記錄事件的檔案名稱）
• id：記錄事件的 ID
• file：包含記錄事件的檔案
• line：記錄事件所在檔案中的行數
• kwargs：傳遞給記錄事件的任何關鍵字參數

@inferred [AllowedType] f(x)

測試呼叫表達式 f(x) 傳回與編譯器推論相同類型的值。這對於檢查類型穩定性很有用。

f(x) 可以是任何呼叫表達式。如果類型相符，傳回 f(x) 的結果，如果找到不同的類型，傳回 Error Result。

選擇性地，AllowedType 放寬測試，當 f(x) 的類型與推論的類型模組 AllowedType 相符，或當傳回類型是 AllowedType 的子類型時，讓它通過。這在測試傳回小聯集的函數的類型穩定性時很有用，例如 Union{Nothing, T} 或 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

當 --depwarn=yes 時，測試 expression 發出廢棄警告並傳回 expression 的值。日誌訊息字串將與 pattern 進行比對，預設為 r"deprecated"i。

當 --depwarn=no 時，只需傳回執行 expression 的結果。當 --depwarn=error 時，檢查是否擲出 ErrorException。

範例

# Deprecated in julia 0.7
@test_deprecated num2hex(1)

# The returned value can be tested by chaining with @test:
@test (@test_deprecated num2hex(1)) == "0000000000000001"

@test_warn msg expr

測試評估 expr 是否導致 stderr 輸出包含 msg 字串或符合 msg 正規表示式。如果 msg 是布林函數，測試 msg(output) 是否傳回 true。如果 msg 是元組或陣列，檢查錯誤輸出是否包含/符合 msg 中的每個項目。傳回評估 expr 的結果。

另請參閱 @test_nowarn 以檢查錯誤輸出的不存在。

注意：由 @warn 產生的警告無法使用此巨集進行測試。請改用 @test_logs。

@test_nowarn expr

測試評估 expr 是否會產生空的 stderr 輸出（沒有警告或其他訊息）。傳回評估 expr 的結果。

注意：無法使用此巨集來測試 @warn 所產生的警告。請改用 @test_logs。

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

表示應該通過但目前持續失敗的測試。測試表達式 ex 是否評估為 false 或導致例外。如果是，則傳回 Broken Result，如果是，則傳回 Error Result。這等於 @test ex broken=true。

@test_broken f(args...) key=val... 形式適用於 @test 巨集。

範例

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

標示不應執行但應包含在測試摘要報告中作為 Broken 的測試。這對於間歇性失敗的測試或尚未實作功能的測試很有用。這等於 @test ex skip=true。

@test_skip f(args...) key=val... 表單適用於 @test 巨集。

範例

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

所有測試都會產生結果物件。此物件可能會儲存或不會儲存，視測試是否為測試集合的一部分而定。

Test.Pass <: Test.Result

測試條件為真，亦即表達式評估為真或擲出正確的例外狀況。

Test.Fail <: Test.Result

測試條件為假，亦即表達式評估為假或未擲出正確的例外狀況。

Test.Error <: Test.Result

測試條件無法評估，因為發生例外狀況，或評估結果不是 Bool。在 @test_broken 的情況下，用於指出發生預期之外的 Pass Result。

Test.Broken <: Test.Result

測試條件是損毀測試的預期（失敗）結果，或使用 @test_skip 明確略過。

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

將結果記錄到測試套件。每次包含的 `@test` 巨集完成時，`@testset` 基礎架構會呼叫此函式，並提供測試結果（可能是 `Error`）。如果在測試區塊內但 `@test` 內容外擲出例外狀況，也會呼叫此函式並提供 `Error`。

finish(ts::AbstractTestSet)

對指定的測試套件執行任何必要的最終處理。在測試區塊執行後，`@testset` 基礎架構會呼叫此函式。

自訂的 `AbstractTestSet` 子類型應在其父項（如果有）上呼叫 `record`，以將自己新增到測試結果樹狀結構。這可以實作為

if get_testset_depth() != 0
    # Attach this test set to the parent test set
    parent_ts = get_testset()
    record(parent_ts, self)
    return self
end

get_testset()

從任務的本機儲存空間中擷取目前的測試套件。如果沒有目前的測試套件，請使用後備預設測試套件。

get_testset_depth()

傳回目前的測試套件數目，不包括預設測試套件

GenericArray 可用於測試編寫至 AbstractArray 介面的通用陣列 API，以確保函式除了標準 Array 類型外，還能與陣列類型搭配使用。

GenericDict 可用於測試編寫至 AbstractDict 介面的通用字典 API，以確保函式除了標準 Dict 類型外，還能與關聯類型搭配使用。

GenericOrder 可用於測試 API 對通用已排序類型的支援。

GenericSet 可用於測試編寫至 AbstractSet 介面的通用集合 API，以確保函式除了標準 Set 和 BitSet 類型外，還能與集合類型搭配使用。

GenericString 可用於測試編寫至 AbstractString 介面的通用字串 API，以確保函式除了標準 String 類型外，還能與字串類型搭配使用。

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

傳回在指定模組中定義的曖昧方法的 (Method,Method) 成對向量。使用 recursive=true 在所有子模組中進行測試。

ambiguous_bottom 控制是否包含僅由 Union{} 類型參數觸發的模稜兩可；在大多數情況下，您可能希望將其設定為 false。請參閱 Base.isambiguous。

請參閱 Test.detect_unbound_args 以了解 allowed_undefineds。

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

傳回一個 Method 向量，其中可能包含未綁定的類型參數。使用 recursive=true 在所有子模組中測試。

預設情況下，任何未定義的符號都會觸發警告。可以透過提供一個 GlobalRef 集合來抑制此警告，其中可以略過警告。例如，設定

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

將抑制有關 Base.active_repl 和 Base.active_repl_backend 的警告。