跳到主要内容
版本:26.x.

全局设定

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

方法


参考

追随(FN,超时)

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

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

例如:

例如:

const GlobalDatabase. = makeglobaldatabase. ;
功能 cleanupdatabase. D b {
D b 清理 ;
}
毕竟 => {
cleanupdatabase. GlobalDatabase. ;
} ;
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
测试 '可以插入一件事' => {
返回 GlobalDatabase. '事物' makething. 回复 => {
预计 回复 成功 Tobeththy. ;
} ;
} ;

毕竟是在描述块的内部,它运行在描述块块。

如果你想要在每个测试后运运行走一流管理,请请用after

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

追随者(FN,超时)

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

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

例如:

例如:

const GlobalDatabase. = makeglobaldatabase. ;
功能 cleanupdatabase. D b {
D b 清理 ;
}
after => {
cleanupdatabase. GlobalDatabase. ;
} ;
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
测试 '可以插入一件事' => {
返回 GlobalDatabase. '事物' makething. 回复 => {
预计 回复 成功 Tobeththy. ;
} ;
} ;

after是在描述块的内部,它运行在描述块块。

如果你想要一定是经理又一次,在没有测试运行,在用途毕竟

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

Beforeall(FN,超时)

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

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

例如:

例如:

const GlobalDatabase. = makeglobaldatabase. ;
Beforeall. => {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺来解决。
返回 GlobalDatabase. 清除 然后 => {
返回 GlobalDatabase. { 测试数据 'foo' } ;
} ;
} ;
//由于我们在此示例中只设置了数据库,因此很重要
//我们的测试不会修改它。
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
// Jest将在运行测试之前等待此承诺来解决。
const GlobalDatabase. = makeglobaldatabase. ;
摘要 => {
//清除数据库并添加一些测试数据。
// Jest将在运行测试之前等待此承诺来解决。
返回 GlobalDatabase. 清除 然后 => {
返回 GlobalDatabase. { 测试数据 'foo' } ;
} ;
} ;
测试 '可以找到东西' => {
返回 GlobalDatabase. '事物' { } 结果 => {
预计 结果 长度 tobegreathan 0. ;
} ;
} ;
测试 '可以插入一件事' => {
返回 GlobalDatabase. '事物' makething. 回复 => {
预计 回复 成功 Tobeththy. ;
} ;
} ;

在这里Beforeall.确保数量设置运行。如果设置是同步的,则可以没有Beforeall.。关键词是jest将将等待承诺,所以您也可进行。关键词是jest将等待承诺,所以您也可进行。

如果要在每次测试测试之前之前行行某些作品,而不在在任何测试运行之外行,请改用品摘要

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

前言(FN,超时)

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

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

例如:

例如:

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

如果摘要描述块内,则它将在描述块中为每个测试行。

如果只需要运行一道设置代码,在任何测试行行之外,请请用Beforeall.

描述(名称,fn)创建一个块,将多个相关测试组合在一起。例如,如果您有一个保佑对象,该对象应该是美食但不酸,您可以通讯下行方便:

描述(名称,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. 1。sefyage.each(表)(姓名,fn,超时)

  • 桌子数号与传递到的参数的阵列FN.每行。
    • 笔记如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称字符串测试套件的标题。
    • 通过使用位置注入参数来生成唯一的测试标题Printf.格式化
      • %P.-漂亮格式
      • %S.- 细绳。
      • %D.- 数字。
      • %一世- 整数。
      • %F- 浮点值。
      • %J.- json。
      • %O.- 目的。
      • %#- 测试用例的索引。
      • %%- 单百分号('%')。这不会消耗参数。这不会消耗参数。
  • FN.功能要耗尽的测试套件,这是将在每个行中接收参数的函数参数。
  • 可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待每行的时间。注意:默认超时为5秒。注意:默认超时为5秒。

例子:

描述 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 一种 B. 预期的 => {
测试 ` 回报 $ { 预期的 } ` => {
预计 一种 + B. 成为 预期的 ;
} ;
测试 ` 返回的值不是大于 $ { 预期的 } ` => {
预计 一种 + B. 不是 tobegreathan 预期的 ;
} ;
测试 ` 返回的值不小于 $ { 预期的 } ` => {
预计 一种 + B. 不是 烟幕 预期的 ;
} ;
} ;

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

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

例子:

描述 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '$ a + $ b' { 一种 B. 预期的 } => {
测试 ` 回报 $ { 预期的 } ` => {
预计 一种 + B. 成为 预期的 ;
} ;
测试 ` 返回的值不是大于 $ { 预期的 } ` => {
预计 一种 + B. 不是 tobegreathan 预期的 ;
} ;
测试 ` 返回的值不小于 $ { 预期的 } ` => {
预计 一种 + B. 不是 烟幕 预期的 ;
} ;
} ;

sefy.only(姓名,fn)

如果你只想运行一个描述块,你可以使用描述

如果Beforeall.描述块内,则它将在描述块的开头行。

描述 只要 '我的饮料' => {
测试 '美味' => {
预计 保佑 可口的 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. 成为 无限 ;
} ;

devely.only.each``(名字,fn)

描述 只要 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' { 一种 B. 预期的 } => {
测试 '通过' => {
预计 一种 + B. 成为 预期的 ;
} ;
} ;
测试 '不会被跑' => {
预计 1 / 0. 成为 无限 ;
} ;

describe.skip(名称,fn)

如果不行行行特价的描述块,可口使用陈述

如果不行行行特价的描述块,可口使用陈述

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

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

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

也在别名下:xdescribe.each(表)(姓名,fn)xdescribe.each`(名称,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秒。注意:默认超时为5秒。

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

例如,假设fetchbeveragelist()返回一个应该解析为主柠檬的列表的列表。你可以用:

测试 '有柠檬' => {
返回 fetchbeveragelist. 然后 列表 => {
预计 列表 包含装有 '柠檬' ;
} ;
} ;

即使对测试的使用将立即返回,测试还别无一成,直直承诺也解决。

1.测试.CONCURRENT(名称,FN,超时)

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

test.concurrent.如果您希望测试同时运行。

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

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

test.crontrent('添加2个数字',异步()=> {
期望(5 + 3).Tobe(8);
});
test.crcurrent('减法2号',异步()=> {
期待(5 - 3).Tobe(2);
});

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

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

也在别名下:它.CONCURRENT.EACH(表)(姓名,FN,超时)

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

test.concurrent.each.有两个API:

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

  • 桌子数号与传递到测试的参数的阵列FN.每行。
    • 笔记如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称字符串测试块的标题。
    • 通过使用位置注入参数来生成唯一的测试标题Printf.格式化
      • %P.-漂亮格式
      • %S.- 细绳。
      • %D.- 数字。
      • %一世- 整数。
      • %F- 浮点值。
      • %J.- json。
      • %O.- 目的。
      • %#- 测试用例的索引。
      • %%- 单百分号('%')。这不会消耗参数。这不会消耗参数。
  • FN.功能测试是ran的,这是将在每个行中接收参数的函数参数,这必须是异步功能
  • 可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待每行的时间。注意:默认超时为5秒。注意:默认超时为5秒。

例子:

测试 同时 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 一种 B. 预期的 => {
预计 一种 + B. 成为 预期的 ;
} ;

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

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

1. Test.each(表)(姓名,Fn,超时)

也在别名下:它。移居(表)(姓名,fn)它。住方式(名称,fn)

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

test.each.有两个API:

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

  • 桌子数号与传递到测试的参数的阵列FN.每行。
    • 笔记如果您通过1D数组的基元,则内部将映射到表I.E.[1,2,3] - > [[1],[2],[3]]
  • 名称字符串测试块的标题。
    • 通过使用位置注入参数来生成唯一的测试标题Printf.格式化
      • %P.-漂亮格式
      • %S.- 细绳。
      • %D.- 数字。
      • %一世- 整数。
      • %F- 浮点值。
      • %J.- json。
      • %O.- 目的。
      • %#- 测试用例的索引。
      • %%- 单百分号('%')。这不会消耗参数。这不会消耗参数。
  • FN.功能测试是RAN的,这是将在每行中的参数作为函数参数接收的函数。
  • 可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待每行的时间。注意:默认超时为5秒。注意:默认超时为5秒。

例子:

测试 每个 [
[ 1 1 2 ]
[ 1 2 3. ]
[ 2 1 3. ]
] '.dd(%i,%i)' 一种 B. 预期的 => {
预计 一种 + B. 成为 预期的 ;
} ;

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

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

例子:

测试 每个 `
a |B |预期的
$ { 1 } | $ { 1 } | $ { 2 }
$ { 1 } | $ { 2 } | $ { 3. }
$ { 2 } | $ { 1 } | $ { 3. }
` '返回$ a预期$ a增加$ b' { 一种 B. 预期的 } => {
预计 一种 + B. 成为 预期的 ;
} ;

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

也在别名下:它。(名称,fn,超时), 和适合(姓名,fn,超时)

当你维护一个很大的时候,有时可能会发出一击某种原因被暂时的测试。如果你想跳过运行这个测试,但你不想删除这个代码,你可以使用test.skip.指定一些跳过的测试。

可选地,您可以提供一个超时(以毫秒为单位),用于指定在中止前等待多长时间。注意:默认超时为5秒。注意:默认超时为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.each(表)(姓名,fn)

也在别名下:it.skip.each.each(表)(姓名,fn)xit.each(表)(名称,fn)xtest.each(表)(姓名,fn)it.skip.each``(姓名,fn)xit.each``(名字,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.当你计划写作测试时。这些测试将在摘要输出中突出显示最后,因此您知道您仍需要多次测试TODO。

笔记:如果您提供测试回调函数那么test.todo.会抛出错误。如果您已经实现了测试并且它被打破了,并且您不希望它运行,然后使用test.skip.反而。如果您已经实现了测试并且它被打破了,并且您不希望它运行,然后使用test.skip.反而。

API.

  • 名称细绳测试计划的标题。

例子:

const 添加 = 一种 B. => 一种 + B. ;
测试 去做 '添加应该是关联的' ;