跳到主要内容
版本:27.0

全局

在您的测试文件中,Jest将这些方法和对象中的每一个都放入全局环境中。您不必要求或导入任何内容以使用它们。但是,如果您更喜欢显式导入,可以做到从'@ jest / globals'的import {描述,期望,测试}

方法


参考

追随(FN,超时)

在此文件中的所有测试完成后运行函数。如果函数返回承诺或是生成器,则Jest等待该承诺在继续之前解析。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

如果要清理测试的某些全局设置状态,这通常是有用的。

例如:

const GlobalDatabase. makeglobaldatabase.
功能 cleanUpDatabase db
db 清理
毕竟 =>
cleanUpDatabase GlobalDatabase.
测试 '可以找到东西' =>
返回 GlobalDatabase. “东西” 结果 =>
预计 结果 长度 tobegreathan 0
测试 '可以插入某物' =>
返回 GlobalDatabase. “东西” makething. 回复 =>
预计 回复 成功 Tobeththy.

在这里毕竟确保cleanUpDatabase在所有测试运行后调用。

如果毕竟是在一个描述块,它在描述块的末尾运行。

如果您想在每次测试之后运行一些清理而不是在所有测试之后,请使用afterEach代替。

追随者(FN,超时)

在此文件中的每一个测试完成后运行函数。如果函数返回承诺或是生成器,则Jest等待该承诺在继续之前解析。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

如果要清理每个测试创建的某些临时状态,这通常是有用的。

例如:

const GlobalDatabase. makeglobaldatabase.
功能 cleanUpDatabase db
db 清理
afterEach =>
cleanUpDatabase GlobalDatabase.
测试 '可以找到东西' =>
返回 GlobalDatabase. “东西” 结果 =>
预计 结果 长度 tobegreathan 0
测试 '可以插入某物' =>
返回 GlobalDatabase. “东西” makething. 回复 =>
预计 回复 成功 Tobeththy.

在这里afterEach确保cleanUpDatabase在每个测试运行后被调用。

如果afterEach是在一个描述块,它只在该描述块中的测试后运行。

如果您想仅在一次运行一些清理,请运行所有测试,使用毕竟代替。

Beforeall(FN,超时)

在此文件中的任何测试运行之前运行函数。如果函数返回一个承诺或是一个生成器,则Jest将在运行测试之前等待该承诺解决。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

如果您希望设置一些将被许多测试使用的全局状态,这通常是有用的。

例如:

const GlobalDatabase. makeglobaldatabase.
beforeAll =>
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺解决。
返回 GlobalDatabase. 清除 然后 =>
返回 GlobalDatabase. testData 'foo'
//因为我们在这个例子中只设置了一次数据库,所以它很重要
//我们的测试不会修改它。
测试 '可以找到东西' =>
返回 GlobalDatabase. “东西” 结果 =>
预计 结果 长度 tobegreathan 0

在这里beforeAll确保在运行测试之前设置数据库。如果setup是同步的,那么您可以不使用beforeAll.关键是jest将等待承诺要解决,因此您也可以具有异步设置。

如果beforeAll是在一个描述块,它在描述块的开始处运行。

如果您想在每个测试之前运行某些东西而不是在任何测试运行之前,请使用beforeEach代替。

前言(FN,超时)

在运行此文件中的每个测试之前运行一个函数。如果函数返回一个承诺或者是一个生成器,Jest将在运行测试之前等待那个承诺的解析。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

如果要重置许多测试使用的一些全局状态,这通常是有用的。

例如:

const GlobalDatabase. makeglobaldatabase.
beforeEach =>
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺解决。
返回 GlobalDatabase. 清除 然后 =>
返回 GlobalDatabase. testData 'foo'
测试 '可以找到东西' =>
返回 GlobalDatabase. “东西” 结果 =>
预计 结果 长度 tobegreathan 0
测试 '可以插入某物' =>
返回 GlobalDatabase. “东西” makething. 回复 =>
预计 回复 成功 Tobeththy.

在这里beforeEach确保为每个测试重置数据库。

如果beforeEach是在一个描述块,它为描述块中的每个测试运行。

如果您只需要在运行任何测试之前运行一些设置代码一次,请使用beforeAll代替。

描述(名称,fn)

描述(名称,fn)创建一个块,将多个相关测试组合在一起。例如,如果你有一个保佑应该是美味但不是酸的对象,你可以用:

const 保佑
可口的 真的
酸的
描述 '我的饮料' =>
测试 '美味' =>
预计 保佑 可口的 Tobeththy.
测试 “不是酸” =>
预计 保佑 酸的 吐痰

这不是必需的 - 你可以写下测试直接在顶层的块。但是,如果您希望将测试组织成组,这可能很方便。

你也可以嵌套描述如果您有测试层次结构:

const binaryStringToNumber binstring. =>
如果 / ^ [01] + $ / 测试 binstring.
新的 CustomError '不是二进制数。'
返回 释放 binstring. 2
描述 'biniarstringtonumber' =>
描述 '给定一个无效的二进制字符串' =>
测试 '由非数字抛出CustomError'组成 =>
预计 => binaryStringToNumber 'abc' Totholowerror CustomError
测试 '用额外的空白抛出CustomError' =>
预计 => binaryStringToNumber “100” Totholowerror CustomError
描述 '给定一个有效的二进制字符串' =>
测试 '返回正确的数字' =>
预计 binaryStringToNumber '100' 托比 4

sefyage.each(表)(姓名,fn,超时)

描述如果您继续使用不同的数据复制相同的测试套件。描述允许您编写一次测试套件并通过数据。

描述有两个API:

1。sefyage.each(表)(姓名,fn,超时)

  • 桌子大批与传递到的参数的阵列fn为每一行。
    • 请注意如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称字符串测试套件的标题。
    • 通过位置注入参数生成唯一的测试标题Printf.格式化
      • % p-漂亮格式
      • % s- 细绳。
      • % d——数字。
      • %我- 整数。
      • % f—浮点值。
      • % j- json。
      • %啊- 目的。
      • % #-测试用例索引。
      • %%- 单百分号('%')。这不会消耗参数。
    • 或通过注入测试用例对象的属性来生成唯一的测试标题$变量
      • 要注入嵌套的对象值,请使用您可以提供键入键入..$变量.path.to.value.
      • 您可以使用$ #注入测试用例的指数
      • 你不能使用$变量与之Printf.格式,除了%%
  • fn功能要耗尽的测试套件,这是将在每个行中接收参数的函数参数。
  • 可选地,您可以提供一个超时(以毫秒为单位)用于指定在中止每一行之前等待多长时间。注意:默认超时为5秒。

例子:

描述 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 一个 b 预期的 =>
测试 返回 $ { 预期的 =>
预计 一个 + b 托比 预期的
测试 返回值不能大于 $ { 预期的 =>
预计 一个 + b 不是 tobegreathan 预期的
测试 返回的值不小于 $ { 预期的 =>
预计 一个 + b 不是 toBeLessThan 预期的
描述 每个
一个 1 b 1 预期的 2
一个 1 b 2 预期的 3.
一个 2 b 1 预期的 3.
'.一个dd($a, $b)' 一个 b 预期的 =>
测试 返回 $ { 预期的 =>
预计 一个 + b 托比 预期的
测试 返回值不能大于 $ { 预期的 =>
预计 一个 + b 不是 tobegreathan 预期的
测试 返回的值不小于 $ { 预期的 =>
预计 一个 + b 不是 toBeLessThan 预期的

2。Devely.evelable`(姓名,fn,超时)

  • 桌子标记的模板文字
    • 第一行变量名称列标题分隔|
    • 使用作为模板文字表达式的一个或多个后续数据$ {value}语法。
  • 名称字符串测试套件的标题,使用$变量将测试数据从标记的模板表达式注入套件标题,$ #获取行的索引。
    • 要注入嵌套的对象值,请使用您可以提供键入键入..$变量.path.to.value.
  • fn功能要运行的测试套件,这是接收测试数据对象的函数。
  • 可选地,您可以提供一个超时(以毫秒为单位)用于指定在中止每一行之前等待多长时间。注意:默认超时为5秒。

例子:

描述 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'$ a + $ b' 一个 b 预期的 =>
测试 返回 $ { 预期的 =>
预计 一个 + b 托比 预期的
测试 返回值不能大于 $ { 预期的 =>
预计 一个 + b 不是 tobegreathan 预期的
测试 返回的值不小于 $ { 预期的 =>
预计 一个 + b 不是 toBeLessThan 预期的

describe.only(名称,fn)

也在别名下:fdescribe(名称,fn)

您可以使用describe.only如果您只想运行一个描述块:

描述 只要 '我的饮料' =>
测试 '美味' =>
预计 保佑 可口的 Tobeththy.
测试 “不是酸” =>
预计 保佑 酸的 吐痰
描述 “我的其他饮料” =>
/ /……将被忽略

sefy.only.each(表)(姓名,fn)

也在别名下:fdescribe.each(表)(姓名,fn)fdescribe.each``(姓名,fn)

sefy.only.each.如果您只想运行特定的数据驱动测试套件。

sefy.only.each.有两个API:

sefy.only.each(表)(姓名,fn)

描述 只要 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 一个 b 预期的 =>
测试 返回 $ { 预期的 =>
预计 一个 + b 托比 预期的
测试 '不会被跑' =>
预计 1 / 0 托比

sefy.only.each.`桌子`(名称,fn)

描述 只要 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 一个 b 预期的 =>
测试 '通过' =>
预计 一个 + b 托比 预期的
测试 '不会被跑' =>
预计 1 / 0 托比

describe.skip(名称,fn)

也在别名下:xdescribe(名称、fn)

您可以使用陈述如果您不想运行特定描述块:

描述 '我的饮料' =>
测试 '美味' =>
预计 保佑 可口的 Tobeththy.
测试 “不是酸” =>
预计 保佑 酸的 吐痰
描述 跳过 “我的其他饮料” =>
/ /……将被忽略

使用陈述通常是一个清洁的替代方案,可以暂时评论一大块的测试。

describe.skip.each(表)(姓名,fn)

也在别名下:xdescribe.each(表)(姓名,fn)xdescribe。每个`桌子`(名称,fn)

describe.skip.each.如果要停止运行套件数据驱动测试。

describe.skip.each.有两个API:

describe.skip.each(表)(姓名,fn)

描述 跳过 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 一个 b 预期的 =>
测试 返回 $ { 预期的 =>
预计 一个 + b 托比 预期的 //不会被跑
测试 会跑的 =>
预计 1 / 0 托比

describe.skip.each``(姓名,fn)

描述 跳过 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 一个 b 预期的 =>
测试 '不会被跑' =>
预计 一个 + b 托比 预期的 //不会被跑
测试 会跑的 =>
预计 1 / 0 托比

测试(名称、fn超时)

也在别名下:它(姓名,fn,超时)

您需要在测试文件中所需的只是测试运行测试的方法。例如,假设有一个函数inchesOfRain ()它应该是零。你的整个测试可以是:

测试 '没有下雨' =>
预计 inchesOfRain 托比 0

第一个参数是测试名;第二个参数是一个包含要测试的期望的函数。第三个参数(可选)是超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

注意:如果一个承诺被退回测试, Jest将等待承诺解决,然后让测试完成。玩笑也会等着你为测试函数提供一个参数,通常称为完毕.当您想要测试回调时,这可能是方便的。看看如何测试异步代码这里

例如,让我们说fetchBeverageList ()返回一个应该解析为具有的列表的承诺柠檬在里面。您可以用以下方式测试:

测试 '有柠檬' =>
返回 fetchBeverageList 然后 列表 =>
预计 列表 toContain '柠檬'

即使打电话给测试将立即返回,测试不会完成,直到承诺解决。

test.croncrent(名称,fn,超时)

也在别名下:它.CONCURRENT(名称,FN,超时)

test.concurrent.如果您希望测试并发运行。

笔记:test.concurrent.被认为是实验性的,明白吗这里有关缺少功能和其他问题的详细信息

第一个参数是测试名;第二个参数是一个包含要测试的期望的异步函数。第三个参数(可选)是超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

test.crontrent('添加2个数字',异步()=> {
期望(5 + 3).Tobe(8);
});
test.concurrent.('subtraction 2 numbers', async () => {
期待(5 - 3).Tobe(2);
});

注意:使用MaxConcurrency.在配置中,以防止Jest同时执行超过指定的测试量

test.concurrent.each(表)(姓名,fn,超时)

也在别名下:it.concurrent.each(表)(名称、fn超时)

test.concurrent.each.如果您继续使用不同的数据复制相同的测试。test.each.允许您一次编写测试并通过数据,测试全同步运行。

test.concurrent.each.有两个API:

1。test.concurrent.each(表)(姓名,fn,超时)

  • 桌子大批数组的参数被传递到测试中fn为每一行。
    • 请注意如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称字符串测试块的标题。
    • 通过位置注入参数生成唯一的测试标题Printf.格式化
      • % p-漂亮格式
      • % s- 细绳。
      • % d——数字。
      • %我- 整数。
      • % f—浮点值。
      • % j- json。
      • %啊- 目的。
      • % #-测试用例索引。
      • %%- 单百分号('%')。这不会消耗参数。
  • fn功能要运行的测试,这是将接收每一行中的参数作为函数参数的函数,这必须是异步功能
  • 可选地,您可以提供一个超时(以毫秒为单位)用于指定在中止每一行之前等待多长时间。注意:默认超时为5秒。

例子:

测试 同时 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 异步 一个 b 预期的 =>
预计 一个 + b 托比 预期的

2。test.concurrent.each`(姓名,fn,超时)

  • 桌子标记的模板文字
    • 第一行变量名称列标题分隔|
    • 使用作为模板文字表达式的一个或多个后续数据$ {value}语法。
  • 名称字符串测试的标题,使用$变量将测试数据从标记的模板表达式注入到测试标题中。
    • 要注入嵌套的对象值,请使用您可以提供键入键入..$变量.path.to.value.
  • fn功能要运行的测试,这是接收测试数据对象的函数,这必须是异步功能
  • 可选地,您可以提供一个超时(以毫秒为单位)用于指定在中止每一行之前等待多长时间。注意:默认超时为5秒。

例子:

测试 同时 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 异步 一个 b 预期的 =>
预计 一个 + b 托比 预期的

test.concurrent.only.each(表)(姓名,fn)

也在别名下:it.concurrent.only.each(表)(姓名,fn)

test.concurrent.only.each如果您只想同时使用不同的测试数据运行特定测试。

test.concurrent.only.each有两个API:

test.concurrent.only.each(表)(姓名,fn)

测试 同时 只要 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 异步 一个 b 预期的 =>
预计 一个 + b 托比 预期的
测试 '不会被跑' =>
预计 1 / 0 托比

test.only.each``(姓名,fn)

测试 同时 只要 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 异步 一个 b 预期的 =>
预计 一个 + b 托比 预期的
测试 '不会被跑' =>
预计 1 / 0 托比

test.concurrent.skip.each.each(表)(姓名,fn)

也在别名下:it.concurrent.skip.each(表)(名称、fn)

test.concurrent.skip.each.each.如果要停止运行异步数据驱动测试的集合。

test.concurrent.skip.each.each.有两个API:

test.concurrent.skip.each.each(表)(姓名,fn)

测试 同时 跳过 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 异步 一个 b 预期的 =>
预计 一个 + b 托比 预期的 //不会被跑
测试 会跑的 =>
预计 1 / 0 托比

test.concurrent.skip.each``(姓名,fn)

测试 同时 跳过 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 异步 一个 b 预期的 =>
预计 一个 + b 托比 预期的 //不会被跑
测试 会跑的 =>
预计 1 / 0 托比

test.each(表)(名称,fn,超时)

也在别名下:一般(表)(名称、fn)它。住方式(名字,fn)

test.each.如果您继续使用不同的数据复制相同的测试。test.each.允许您编写一次测试并通过数据。

test.each.有两个API:

1。test.each(表)(名称,fn,超时)

  • 桌子大批数组的参数被传递到测试中fn为每一行。
    • 请注意如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称字符串测试块的标题。
    • 通过位置注入参数生成唯一的测试标题Printf.格式化
      • % p-漂亮格式
      • % s- 细绳。
      • % d——数字。
      • %我- 整数。
      • % f—浮点值。
      • % j- json。
      • %啊- 目的。
      • % #-测试用例索引。
      • %%- 单百分号('%')。这不会消耗参数。
    • 或通过注入测试用例对象的属性来生成唯一的测试标题$变量
      • 要注入嵌套的对象值,请使用您可以提供键入键入..$变量.path.to.value.
      • 您可以使用$ #注入测试用例的指数
      • 你不能使用$变量与之Printf.格式,除了%%
  • fn功能要运行的测试,这是将接收每一行中的参数作为函数参数的函数。
  • 可选地,您可以提供一个超时(以毫秒为单位)用于指定在中止每一行之前等待多长时间。注意:默认超时为5秒。

例子:

测试 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 一个 b 预期的 =>
预计 一个 + b 托比 预期的
测试 每个
一个 1 b 1 预期的 2
一个 1 b 2 预期的 3.
一个 2 b 1 预期的 3.
'.一个dd($a, $b)' 一个 b 预期的 =>
预计 一个 + b 托比 预期的

2。test.each`(姓名,fn,超时)

  • 桌子标记的模板文字
    • 第一行变量名称列标题分隔|
    • 使用作为模板文字表达式的一个或多个后续数据$ {value}语法。
  • 名称字符串测试的标题,使用$变量将测试数据从标记的模板表达式注入到测试标题中。
    • 要注入嵌套的对象值,请使用您可以提供键入键入..$变量.path.to.value.
  • fn功能要运行的测试,这是将接收测试数据对象的函数。
  • 可选地,您可以提供一个超时(以毫秒为单位)用于指定在中止每一行之前等待多长时间。注意:默认超时为5秒。

例子:

测试 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 一个 b 预期的 =>
预计 一个 + b 托比 预期的

test.only.(名称,fn,超时)

也在别名下:它。(名称,fn,超时), 和fit(名称、fn超时)

当您调试大型测试文件时,您通常只想运行测试子集。您可以使用。只要要指定哪些测试是您希望在该测试文件中运行的测试。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。

例如,假设您进行了以下测试:

测试 只要 “下雨了” =>
预计 inchesOfRain tobegreathan 0
测试 '它没有下雪' =>
预计 inchesofsnow. 托比 0

只有“下雨了”测试将在该测试文件中运行,因为它是与之一起运行的test.only.

通常您不会检查代码test.only.在源代码控制中——您可以使用它进行调试,并在修复了损坏的测试后将其删除。

test.only.each(表)(名称、fn)

也在别名下:it.only.each(表)(姓名,fn)fit.each(表)(姓名,fn)it.Only.Each`(姓名,fn)fit.each``(名字,fn)

test.only.each.如果希望仅运行具有不同测试数据的特定测试。

test.only.each.有两个API:

test.only.each(表)(名称、fn)

测试 只要 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 一个 b 预期的 =>
预计 一个 + b 托比 预期的
测试 '不会被跑' =>
预计 1 / 0 托比

test.only.each``(姓名,fn)

测试 只要 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 一个 b 预期的 =>
预计 一个 + b 托比 预期的
测试 '不会被跑' =>
预计 1 / 0 托比

test.skip.(名称,fn)

也在别名下:it.skip(名称,fn)xit(名称,fn), 和xtest(名称,fn)

当您维护一个大型代码库时,您可能有时会发现某个测试由于某种原因而暂时中断。如果您想跳过运行此测试,但又不想删除此代码,则可以使用test.skip.指定一些跳过的测试。

例如,假设您进行了以下测试:

测试 “下雨了” =>
预计 inchesOfRain tobegreathan 0
测试 跳过 '它没有下雪' =>
预计 inchesofsnow. 托比 0

只有“下雨”测试将运行,因为其他测试运行test.skip.

您可以评论测试,但通常有点更好test.skip.因为它将保持缩进和语法突出显示。

test.skip.each(表)(姓名,fn)

也在别名下:it.skip.each(表)(名称、fn)xit.each(表)(名称,fn)xtest.each(表)(名称、fn)it.skip.each``(姓名,fn)——xit。每个`桌子`(名称,fn)xtest.each``(姓名,fn)

test.skip.each.如果要停止运行数据驱动测试的集合。

test.skip.each.有两个API:

test.skip.each(表)(姓名,fn)

测试 跳过 每个
1 1 2
1 2 3.
2 1 3.
'.dd(%i,%i)' 一个 b 预期的 =>
预计 一个 + b 托比 预期的 //不会被跑
测试 会跑的 =>
预计 1 / 0 托比

test.skip.each``(姓名,fn)

测试 跳过 每个
a |B |预期的
$ { 1 | $ { 1 | $ { 2
$ { 1 | $ { 2 | $ { 3.
$ { 2 | $ { 1 | $ { 3.
'返回$ a预期$ a增加$ b' 一个 b 预期的 =>
预计 一个 + b 托比 预期的 //不会被跑
测试 会跑的 =>
预计 1 / 0 托比

test.todo(姓名)

也在别名下:它.Todo(姓名)

test.todo.当您计划编写测试时。这些测试将在结尾处的摘要输出中突出显示,以便您知道还需要做多少测试。

请注意:如果你提供了一个测试回调函数,那么test.todo.将抛出一个错误。如果您已经实现了测试,但是测试被破坏了,您不想让它运行,那么就使用它test.skip.代替。

API.

  • 名称字符串测试计划的标题。

例子:

const 添加 一个 b => 一个 + b
测试 待办事项 " add应该是有关联的"
上次更新了通过Simen Bekkhus.