单元测试

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

运行 tests 中列出的 Julia 单元测试，tests 可以是字符串或字符串数组，使用 ncores 个处理器。如果 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 之前的状态。这样做是为了在发生错误时简化可重复性，并允许在不影响全局 RNG 状态的情况下无缝重新排列 @testset。

示例

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) 形式的简单元组。可以使用不同数量的元组元素来匹配其他日志元数据，对应于通过 handle_message 函数传递给 AbstractLogger 的参数：(level,message,module,group,id,file,line)。存在的元素将使用 == 与日志记录字段成对匹配，特殊情况是 Symbol 可用于标准日志级别，而模式中的 Regex 将使用 occursin 与字符串或符号字段匹配。

示例

考虑一个记录警告和几个调试消息的函数

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 次的约定。

另请参阅：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) 的类型与推断的类型匹配 modulo 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，如果表达式评估为 true，则返回 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。

有关 allowed_undefineds 的解释，请参见 Test.detect_unbound_args。

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 的警告。