Nodejs thực thi từng dòng một

Question

Sự kiện 'dòng' được phát ra bất cứ khi nào luồng đầu vào nhận được đầu vào cuối dòng (\n, \r hoặc \r\n). Điều này thường xảy ra khi người dùng nhấn Enter hoặc Return

Nội dung chính Show

kiểm tra phụ #
Bỏ qua các bài kiểm tra #
Cú pháp import test from 'node:test';const test = require('node:test');08/import test from 'node:test';const test = require('node:test');09#
test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });77 bài kiểm tra#
Lọc các bài kiểm tra theo tên #
Hoạt động không đồng bộ bên ngoài
Chế độ xem #
Chạy thử nghiệm từ dòng lệnh#
Chế giễu#
import test from 'test';const test = require('test');10#
import test from 'test';const test = require('test');21#
import test from 'test';const test = require('test');56#
import test from 'test';const test = require('test');70#
import test from 'test';const test = require('test');72#
import test from 'test';const test = require('test');75#
import test from 'test';const test = require('test');87#
import test from 'test';const test = require('test');89#
import test from 'test';const test = require('test');92#
import test from 'test';const test = require('test');98#
test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });04#
test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });10#
Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });16#
Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });18#
Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });99#
Lớp. import test from 'test';const test = require('test');08#
Lớp. import test from 'test';const test = require('test');65#

Hàm nghe được gọi với một chuỗi chứa một dòng đầu vào nhận được

Vì nó là một bộ lắng nghe, bạn không thể kiểm soát cách phát ra sự kiện

hàng. pause() sẽ không hoạt động ở đây vì những điều sau

đang gọi rl. pause() không tạm dừng ngay lập tức các sự kiện khác (bao gồm cả 'dòng') do dòng đọc phát ra. Ví dụ giao diện

Nếu bạn muốn, có lẽ bạn nên đọc toàn bộ tệp trong một mảng javascript và sử dụng

import test from 'test';const test = require('test');

73 để đi qua từng dòng

Mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

4 hỗ trợ tạo các bài kiểm tra JavaScript báo cáo kết quả ở định dạng TAP. Để truy cập nó

import test from 'node:test';const test = require('node:test');

Mô-đun này chỉ khả dụng theo sơ đồ

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

5. Những điều sau đây sẽ không hoạt động

import test from 'test';const test = require('test');

Các bài kiểm tra được tạo thông qua mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

6 bao gồm một chức năng duy nhất được xử lý theo một trong ba cách

Hàm đồng bộ được coi là không thành công nếu nó đưa ra một ngoại lệ và được coi là vượt qua nếu ngược lại

Hàm trả về một

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

7 được coi là không thành công nếu

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

7 từ chối và được coi là đạt nếu

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

7 giải quyết

Một chức năng nhận chức năng gọi lại. Nếu cuộc gọi lại nhận được bất kỳ giá trị trung thực nào làm đối số đầu tiên, thử nghiệm được coi là không thành công. Nếu một giá trị giả được chuyển làm đối số đầu tiên cho lệnh gọi lại, thử nghiệm được coi là vượt qua. Nếu chức năng kiểm tra nhận được chức năng gọi lại và cũng trả về một
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
7, kiểm tra sẽ thất bại

Ví dụ sau minh họa cách các bài kiểm tra được viết bằng mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

6

Khi tệp thử nghiệm thực thi, TAP được ghi vào đầu ra tiêu chuẩn của Nút. quy trình js. Đầu ra này có thể được giải thích bởi bất kỳ khai thác thử nghiệm nào hiểu định dạng TAP. Nếu bất kỳ thử nghiệm nào không thành công, mã thoát quy trình được đặt thành

import test from 'node:test';const test = require('node:test');

02

kiểm tra phụ #

Phương pháp

import test from 'node:test';const test = require('node:test');

03 của ngữ cảnh thử nghiệm cho phép tạo các phép thử phụ. Phương thức này hoạt động giống hệt với hàm

import test from 'node:test';const test = require('node:test');

03 cấp cao nhất. Ví dụ sau minh họa việc tạo một bài kiểm tra cấp cao nhất với hai bài kiểm tra con

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

Trong ví dụ này,

import test from 'node:test';const test = require('node:test');

05 được sử dụng để đảm bảo rằng cả hai phép thử phụ đã hoàn thành. Điều này là cần thiết vì các bài kiểm tra gốc không đợi các bài kiểm tra con của chúng hoàn thành. Bất kỳ bài kiểm tra con nào vẫn còn tồn đọng khi cha mẹ của chúng kết thúc đều bị hủy và được coi là không đạt. Bất kỳ lỗi kiểm tra con nào cũng khiến kiểm tra gốc không thành công

Bỏ qua các bài kiểm tra #

Có thể bỏ qua các bài kiểm tra riêng lẻ bằng cách chuyển tùy chọn

import test from 'node:test';const test = require('node:test');

06 cho bài kiểm tra hoặc bằng cách gọi phương thức

import test from 'node:test';const test = require('node:test');

07 của bối cảnh kiểm tra. Cả hai tùy chọn này đều hỗ trợ bao gồm một thông báo được hiển thị trong đầu ra TAP như minh họa trong ví dụ sau

Cú pháp import test from 'node:test';const test = require('node:test');08/import test from 'node:test';const test = require('node:test');09#

Chạy thử nghiệm cũng có thể được thực hiện bằng cách sử dụng

import test from 'node:test';const test = require('node:test');

08 để khai báo một bộ và

import test from 'node:test';const test = require('node:test');

09 để khai báo một thử nghiệm. Một bộ được sử dụng để tổ chức và nhóm các bài kiểm tra liên quan lại với nhau.

import test from 'node:test';const test = require('node:test');

09 là bí danh của

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

6, ngoại trừ không có bối cảnh thử nghiệm nào được thông qua, vì việc lồng nhau được thực hiện bằng cách sử dụng các bộ

import test from 'node:test';const test = require('node:test');

0

import test from 'node:test';const test = require('node:test');

08 và

import test from 'node:test';const test = require('node:test');

09 được nhập từ mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

4

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

7

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });77 bài kiểm tra#

Nếu nút. js được bắt đầu với tùy chọn dòng lệnh

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

78, có thể bỏ qua tất cả các bài kiểm tra cấp cao nhất ngoại trừ một tập hợp con đã chọn bằng cách chuyển tùy chọn

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

77 cho các bài kiểm tra sẽ được chạy. Khi một thử nghiệm với bộ tùy chọn

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

77 được chạy, tất cả các thử nghiệm con cũng được chạy. Phương pháp

import test from 'test';const test = require('test');

21 của ngữ cảnh thử nghiệm có thể được sử dụng để thực hiện hành vi tương tự ở cấp độ thử nghiệm phụ

Lọc các bài kiểm tra theo tên #

Tùy chọn dòng lệnh

import test from 'test';const test = require('test');

22 chỉ có thể được sử dụng để chạy thử nghiệm có tên khớp với mẫu được cung cấp. Các mẫu tên thử nghiệm được hiểu là biểu thức chính quy JavaScript. Tùy chọn

import test from 'test';const test = require('test');

22 có thể được chỉ định nhiều lần để chạy các bài kiểm tra lồng nhau. Đối với mỗi thử nghiệm được thực thi, bất kỳ móc thử nghiệm tương ứng nào, chẳng hạn như

import test from 'test';const test = require('test');

24, cũng được chạy

Đưa ra tệp thử nghiệm sau, bắt đầu Node. js với tùy chọn

import test from 'test';const test = require('test');

25 sẽ khiến trình chạy thử nghiệm thực thi

import test from 'test';const test = require('test');

26,

import test from 'test';const test = require('test');

27 và

import test from 'test';const test = require('test');

28. Nếu

import test from 'test';const test = require('test');

26 không khớp với mẫu tên thử nghiệm, thì các thử nghiệm con của nó sẽ không thực thi, mặc dù khớp với mẫu. Cùng một bộ kiểm tra cũng có thể được thực hiện bằng cách vượt qua

import test from 'test';const test = require('test');

22 nhiều lần (e. g.

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

21,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

22, v.v. )

import test from 'test';const test = require('test');

2

Các mẫu tên thử nghiệm cũng có thể được chỉ định bằng cách sử dụng các ký tự biểu thức chính quy. Điều này cho phép sử dụng cờ biểu thức chính quy. Trong ví dụ trước, bắt đầu Node. js với

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

23 sẽ khớp với

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

24 và

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

25 vì mẫu không phân biệt chữ hoa chữ thường

Các mẫu tên thử nghiệm không thay đổi tập hợp các tệp mà trình chạy thử nghiệm thực thi

Hoạt động không đồng bộ bên ngoài

Khi chức năng kiểm tra kết thúc thực thi, kết quả TAP được xuất ra nhanh nhất có thể trong khi vẫn duy trì thứ tự của các bài kiểm tra. Tuy nhiên, chức năng thử nghiệm có thể tạo ra hoạt động không đồng bộ tồn tại lâu hơn chính thử nghiệm đó. Người chạy thử nghiệm xử lý loại hoạt động này, nhưng không trì hoãn việc báo cáo kết quả thử nghiệm để phù hợp với nó

Trong ví dụ sau, một bài kiểm tra hoàn thành với hai hoạt động

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

26 vẫn chưa hoàn thành.

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

26 đầu tiên cố gắng tạo một phép thử phụ mới. Vì bài kiểm tra gốc đã kết thúc và đưa ra kết quả của nó, bài kiểm tra con mới ngay lập tức được đánh dấu là không đạt và được báo cáo ở cấp cao nhất trong đầu ra TAP của tệp

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

26 thứ hai tạo ra một sự kiện

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

29. Các sự kiện

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

29 và

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

31 bắt nguồn từ một bài kiểm tra đã hoàn thành được mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

6 đánh dấu là không thành công và được báo cáo dưới dạng cảnh báo chẩn đoán ở cấp cao nhất của đầu ra TAP của tệp

Chế độ xem #

nút. trình chạy thử js hỗ trợ chạy ở chế độ đồng hồ bằng cách chuyển cờ

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

33

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

2

Ở chế độ xem, trình chạy thử nghiệm sẽ theo dõi các thay đổi đối với tệp thử nghiệm và phần phụ thuộc của chúng. Khi phát hiện thay đổi, người chạy thử nghiệm sẽ chạy lại các thử nghiệm bị ảnh hưởng bởi thay đổi. Trình chạy thử nghiệm sẽ tiếp tục chạy cho đến khi quá trình kết thúc

Chạy thử nghiệm từ dòng lệnh#

nút. trình chạy thử js có thể được gọi từ dòng lệnh bằng cách chuyển cờ

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

34

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

3

Theo mặc định, Nút. js sẽ tìm kiếm đệ quy thư mục hiện tại để tìm các tệp nguồn JavaScript khớp với một quy ước đặt tên cụ thể. Các tệp phù hợp được thực thi dưới dạng tệp thử nghiệm. Bạn có thể tìm thêm thông tin về quy ước và hành vi đặt tên tệp thử nghiệm dự kiến trong phần mô hình thực thi trình chạy thử

Ngoài ra, một hoặc nhiều đường dẫn có thể được cung cấp làm (các) đối số cuối cùng cho Nút. lệnh js, như hình bên dưới

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

9

Trong ví dụ này, người chạy thử nghiệm sẽ thực thi các tệp

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

35 và

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Người chạy thử nghiệm cũng sẽ tìm kiếm đệ quy thư mục

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

37 để thực thi các tệp thử nghiệm

Mô hình thực thi người chạy thử nghiệm #

Khi tìm kiếm các tệp thử nghiệm để thực thi, trình chạy thử nghiệm hoạt động như sau

Mọi tệp do người dùng cung cấp rõ ràng đều được thực thi
Nếu người dùng không chỉ định rõ ràng bất kỳ đường dẫn nào, thư mục làm việc hiện tại sẽ được tìm kiếm đệ quy cho các tệp như được chỉ định trong các bước sau

Các thư mục

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

38 bị bỏ qua trừ khi được cung cấp rõ ràng bởi người dùng

Nếu gặp một thư mục có tên

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

6, người chạy thử nghiệm sẽ tìm kiếm nó một cách đệ quy cho tất cả các tệp

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

90,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

91 và

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

92. Tất cả các tệp này được coi là tệp thử nghiệm và không cần khớp với quy ước đặt tên cụ thể được nêu chi tiết bên dưới. Điều này là để phù hợp với các dự án đặt tất cả các bài kiểm tra của họ trong một thư mục

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

6 duy nhất

Trong tất cả các thư mục khác, các tệp

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

90,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

91 và

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

92 khớp với các mẫu sau được coi là tệp thử nghiệm

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

97 - Tệp có tên cơ sở là chuỗi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

98. ví dụ.

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

99,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

50,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

51

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

52 - Các tệp có tên cơ sở bắt đầu bằng chuỗi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

53 theo sau là một hoặc nhiều ký tự. ví dụ.

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

54,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

55

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

56 - Các tệp có tên cơ sở kết thúc bằng

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

57,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

58 hoặc

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

59, trước một hoặc nhiều ký tự. ví dụ.

import test from 'test';const test = require('test');

00,

import test from 'test';const test = require('test');

01,

import test from 'test';const test = require('test');

02

Các loại tệp khác được Node hiểu. js chẳng hạn như
```
import test from 'test';const test = require('test');
```
03 và
```
import test from 'test';const test = require('test');
```
04 không được chạy thử nghiệm tự động thực thi, nhưng được hỗ trợ nếu được cung cấp rõ ràng trên dòng lệnh

Mỗi tệp kiểm tra phù hợp được thực thi trong một quy trình con riêng biệt. Nếu quá trình con kết thúc với mã thoát là 0, bài kiểm tra được coi là vượt qua. Nếu không, thử nghiệm được coi là thất bại. Các tệp thử nghiệm phải được thực thi bởi Node. js, nhưng không bắt buộc phải sử dụng mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

4 trong nội bộ

Chế giễu#

Mô-đun

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

4 hỗ trợ mô phỏng trong quá trình thử nghiệm thông qua đối tượng

import test from 'test';const test = require('test');

07 cấp cao nhất. Ví dụ sau tạo một gián điệp trên một hàm cộng hai số với nhau. Gián điệp sau đó được sử dụng để khẳng định rằng chức năng được gọi như mong đợi

Chức năng mô phỏng tương tự cũng được hiển thị trên đối tượng

import test from 'test';const test = require('test');

08 của mỗi bài kiểm tra. Ví dụ sau tạo gián điệp trên một phương thức đối tượng bằng cách sử dụng API hiển thị trên

import test from 'test';const test = require('test');

08. Lợi ích của việc mô phỏng thông qua bối cảnh thử nghiệm là trình chạy thử nghiệm sẽ tự động khôi phục tất cả các chức năng được mô phỏng sau khi thử nghiệm kết thúc

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

5

import test from 'test';const test = require('test');10#

```
import test from 'test';const test = require('test');
```
11 Tùy chọn cấu hình để chạy thử nghiệm. Các thuộc tính sau được hỗ trợ
- ```
import test from 'test';const test = require('test');
```
  12. Nếu một số được cung cấp, thì nhiều tệp đó sẽ chạy song song. Nếu đúng thì nó sẽ chạy song song (số lõi cpu - 1) tệp. Nếu false thì mỗi lần nó chỉ chạy 1 file. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
  13
- ```
import test from 'test';const test = require('test');
```
  14. Một mảng chứa danh sách các tệp sẽ chạy. Các tệp khớp mặc định từ mô hình thực thi trình chạy thử nghiệm
- ```
import test from 'test';const test = require('test');
```
  15 Cho phép hủy bỏ quá trình thực hiện kiểm tra đang diễn ra
- ```
import test from 'test';const test = require('test');
```
  16 Một số mili giây việc thực thi thử nghiệm sẽ thất bại sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
  17
- ```
import test from 'test';const test = require('test');
```
  18. Đặt cổng thanh tra của tiến trình con thử nghiệm. Đây có thể là một số hoặc một hàm không nhận đối số và trả về một số. Nếu một giá trị nullish được cung cấp, thì mỗi quy trình sẽ nhận được cổng riêng của nó, được tăng lên từ
```
import test from 'test';const test = require('test');
```
  19 của quy trình chính. Mặc định.
```
import test from 'test';const test = require('test');
```
  20
trả lại.

import test from 'test';const test = require('test');

import test from 'test';const test = require('test');21#

Lịch sửPhiên bảnThay đổiv18. 0. 0, v16. 17. 0

Đã thêm vào. v18. 0. 0, v16. 17. 0

v18. 8. 0, v16. 18. 0

Thêm tùy chọn

import test from 'test';const test = require('test');

15

v18. 7. 0, v16. 17. 0

Thêm tùy chọn

import test from 'test';const test = require('test');

16

import test from 'test';const test = require('test');

24 Tên của bài kiểm tra, được hiển thị khi báo cáo kết quả kiểm tra. Mặc định. Thuộc tính

import test from 'test';const test = require('test');

24 của

import test from 'test';const test = require('test');

26 hoặc

import test from 'test';const test = require('test');

27 nếu

import test from 'test';const test = require('test');

26 không có tên

```
import test from 'test';const test = require('test');
```
11 Tùy chọn cấu hình cho bài kiểm tra. Các thuộc tính sau được hỗ trợ
- ```
import test from 'test';const test = require('test');
```
  12. Nếu một số được cung cấp, thì nhiều bài kiểm tra đó sẽ chạy song song. Nếu đúng, nó sẽ chạy song song (số lõi cpu - 1). Đối với các bài kiểm tra phụ, nó sẽ là
```
import test from 'test';const test = require('test');
```
  17 bài kiểm tra song song. Nếu sai, nó sẽ chỉ chạy một bài kiểm tra tại một thời điểm. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
  32
- ```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
  77 Nếu đúng sự thật và bối cảnh thử nghiệm được định cấu hình để chạy thử nghiệm
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
  77 thì thử nghiệm này sẽ được chạy. Nếu không, bài kiểm tra sẽ bị bỏ qua. Mặc định.
```
import test from 'test';const test = require('test');
```
  32
- ```
import test from 'test';const test = require('test');
```
  15 Cho phép hủy bỏ một bài kiểm tra đang tiến hành
- ```
import test from 'node:test';const test = require('node:test');
```
  06. Nếu trung thực, bài kiểm tra được bỏ qua. Nếu một chuỗi được cung cấp, chuỗi đó sẽ được hiển thị trong kết quả kiểm tra dưới dạng lý do bỏ qua kiểm tra. Mặc định.
```
import test from 'test';const test = require('test');
```
  32
- ```
import test from 'test';const test = require('test');
```
  39. Nếu trung thực, bài kiểm tra được đánh dấu là
```
import test from 'test';const test = require('test');
```
  40. Nếu một chuỗi được cung cấp, chuỗi đó sẽ được hiển thị trong kết quả kiểm tra vì lý do tại sao kiểm tra là
```
import test from 'test';const test = require('test');
```
  40. Mặc định.
```
import test from 'test';const test = require('test');
```
  32
- ```
import test from 'test';const test = require('test');
```
  16 Một số mili giây kiểm tra sẽ thất bại sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
  17
```
import test from 'test';const test = require('test');
```
26. Chức năng được kiểm tra. Đối số đầu tiên của hàm này là một đối tượng
```
import test from 'test';const test = require('test');
```
08. Nếu thử nghiệm sử dụng gọi lại, hàm gọi lại được chuyển thành đối số thứ hai. Mặc định. Chức năng không hoạt động
trả lại. Đã giải quyết với
```
import test from 'test';const test = require('test');
```
20 sau khi kiểm tra hoàn tất

Hàm

import test from 'node:test';const test = require('node:test');

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

Đối tượng

import test from 'test';const test = require('test');

import test from 'test';const test = require('test');

import test from 'node:test';const test = require('node:test');

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

Tùy chọn

import test from 'test';const test = require('test');

import test from 'test';const test = require('test');

import test from 'test';const test = require('test');56#

import test from 'test';const test = require('test');

24 Tên của bộ phần mềm, được hiển thị khi báo cáo kết quả kiểm tra. Mặc định. Thuộc tính

import test from 'test';const test = require('test');

24 của

import test from 'test';const test = require('test');

26 hoặc

import test from 'test';const test = require('test');

27 nếu

import test from 'test';const test = require('test');

26 không có tên

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình cho bộ ứng dụng. hỗ trợ các tùy chọn giống như

import test from 'test';const test = require('test');

21

```
import test from 'test';const test = require('test');
```
26. Hàm bên dưới bộ khai báo tất cả các bài kiểm tra con và bộ con. Đối số đầu tiên của hàm này là một đối tượng
```
import test from 'test';const test = require('test');
```
65. Mặc định. Chức năng không hoạt động

trả lại.

import test from 'test';const test = require('test');

20

Hàm

import test from 'test';const test = require('test');

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

import test from 'node:test';const test = require('node:test');

import test from 'test';const test = require('test');70#

Viết tắt của bỏ qua một bộ, giống như

import test from 'test';const test = require('test');

71

import test from 'test';const test = require('test');72#

Viết tắt để đánh dấu một bộ là

import test from 'test';const test = require('test');

40, giống như

import test from 'test';const test = require('test');

74

import test from 'test';const test = require('test');75#

import test from 'test';const test = require('test');

24 Tên của bài kiểm tra, được hiển thị khi báo cáo kết quả kiểm tra. Mặc định. Thuộc tính

import test from 'test';const test = require('test');

24 của

import test from 'test';const test = require('test');

26 hoặc

import test from 'test';const test = require('test');

27 nếu

import test from 'test';const test = require('test');

26 không có tên

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình cho bộ ứng dụng. hỗ trợ các tùy chọn giống như

import test from 'test';const test = require('test');

21

```
import test from 'test';const test = require('test');
```
26. Chức năng được kiểm tra. Nếu thử nghiệm sử dụng hàm gọi lại, hàm gọi lại được truyền dưới dạng đối số. Mặc định. Chức năng không hoạt động

trả lại.

import test from 'test';const test = require('test');

20

Hàm

import test from 'test';const test = require('test');

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

import test from 'test';const test = require('test');87#

Viết tắt của bỏ qua một bài kiểm tra, giống như

import test from 'test';const test = require('test');

88

import test from 'test';const test = require('test');89#

Viết tắt để chấm bài kiểm tra là

import test from 'test';const test = require('test');

40, giống như

import test from 'test';const test = require('test');

91

import test from 'test';const test = require('test');92#

Đã thêm vào. v18. 8. 0, v16. 18. 0

```
import test from 'test';const test = require('test');
```
26. chức năng móc. Nếu hook sử dụng hàm gọi lại, thì hàm gọi lại được truyền dưới dạng đối số thứ hai. Mặc định. Chức năng không hoạt động

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình cho hook. Các thuộc tính sau được hỗ trợ

import test from 'test';const test = require('test');

15 Cho phép hủy bỏ hook đang thực hiện

```
import test from 'test';const test = require('test');
```
16 Một số phần nghìn giây móc sẽ bị lỗi sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
17

Hàm này dùng để tạo hook chạy trước khi chạy suite

import test from 'test';const test = require('test');

1

import test from 'test';const test = require('test');98#

Đã thêm vào. v18. 8. 0, v16. 18. 0

```
import test from 'test';const test = require('test');
```
26. chức năng móc. Nếu hook sử dụng hàm gọi lại, thì hàm gọi lại được truyền dưới dạng đối số thứ hai. Mặc định. Chức năng không hoạt động

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình cho hook. Các thuộc tính sau được hỗ trợ

import test from 'test';const test = require('test');

15 Cho phép hủy bỏ hook đang thực hiện

```
import test from 'test';const test = require('test');
```
16 Một số phần nghìn giây móc sẽ bị lỗi sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
17

Chức năng này được sử dụng để tạo hook chạy sau khi chạy bộ

import test from 'test';const test = require('test');

2

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });04#

Đã thêm vào. v18. 8. 0, v16. 18. 0

```
import test from 'test';const test = require('test');
```
26. chức năng móc. Nếu hook sử dụng hàm gọi lại, thì hàm gọi lại được truyền dưới dạng đối số thứ hai. Mặc định. Chức năng không hoạt động

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình cho hook. Các thuộc tính sau được hỗ trợ

import test from 'test';const test = require('test');

15 Cho phép hủy bỏ hook đang thực hiện

```
import test from 'test';const test = require('test');
```
16 Một số phần nghìn giây móc sẽ bị lỗi sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
17

Chức năng này được sử dụng để tạo một hook chạy trước mỗi lần kiểm tra con của bộ hiện tại

import test from 'test';const test = require('test');

3

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });10#

Đã thêm vào. v18. 8. 0, v16. 18. 0

```
import test from 'test';const test = require('test');
```
26. chức năng móc. Nếu hook sử dụng hàm gọi lại, thì hàm gọi lại được truyền dưới dạng đối số thứ hai. Mặc định. Chức năng không hoạt động

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình cho hook. Các thuộc tính sau được hỗ trợ

import test from 'test';const test = require('test');

15 Cho phép hủy bỏ hook đang thực hiện

```
import test from 'test';const test = require('test');
```
16 Một số phần nghìn giây móc sẽ bị lỗi sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
17

Hàm này dùng để tạo hook chạy sau mỗi subtest của test hiện tại

import test from 'test';const test = require('test');

4

Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });16#

Lớp

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

16 được sử dụng để kiểm tra hoặc thao tác hành vi của các mô hình giả được tạo thông qua API

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

18

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

19#

Một getter trả về một bản sao của mảng nội bộ được sử dụng để theo dõi các cuộc gọi đến mô phỏng. Mỗi mục trong mảng là một đối tượng có các thuộc tính sau

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

20 Một mảng các đối số được truyền cho hàm giả

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

21 Nếu hàm giả định ném thì thuộc tính này chứa giá trị ném. Mặc định.

import test from 'test';const test = require('test');

20

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

23 Giá trị được hàm mô phỏng trả về

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

24 Một đối tượng

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

25 có ngăn xếp có thể được sử dụng để xác định vị trí gọi của lệnh gọi hàm giả định

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

26. Nếu hàm giả định là hàm tạo, thì trường này chứa lớp đang được xây dựng. Nếu không thì đây sẽ là

import test from 'test';const test = require('test');

20

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

28 Giá trị

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

28 của hàm giả định

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

30#

trả lại. Số lần mô phỏng này đã được gọi

Hàm này trả về số lần mô phỏng này đã được gọi. Chức năng này hiệu quả hơn việc kiểm tra

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

31 vì

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

19 là một getter tạo một bản sao của mảng theo dõi cuộc gọi nội bộ

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

33#

Chức năng này được sử dụng để thay đổi hành vi của một mô hình hiện có

Ví dụ sau tạo một hàm giả bằng cách sử dụng

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

34, gọi hàm giả và sau đó thay đổi triển khai giả thành một hàm khác

import test from 'test';const test = require('test');

5

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

35#

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Hàm được sử dụng làm triển khai giả cho số lệnh gọi được chỉ định bởi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

37

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

37 Số yêu cầu sẽ sử dụng

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Nếu lời gọi được chỉ định đã xảy ra thì một ngoại lệ sẽ được đưa ra. Mặc định. Số lần gọi tiếp theo

Chức năng này được sử dụng để thay đổi hành vi của một mô hình hiện có cho một lần gọi. Khi lệnh gọi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

37 đã xảy ra, mô hình giả sẽ trở lại bất kỳ hành vi nào mà lẽ ra nó đã sử dụng nếu

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

41 không được gọi

Ví dụ sau đây tạo một hàm giả sử dụng

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

34, gọi hàm giả, thay đổi triển khai giả thành một hàm khác cho lần gọi tiếp theo, sau đó tiếp tục hành vi trước đó của nó

import test from 'test';const test = require('test');

6

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

43#

Đặt lại việc triển khai hàm giả về hành vi ban đầu của nó. Mô phỏng vẫn có thể được sử dụng sau khi gọi chức năng này

Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });18#

Lớp

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

18 được sử dụng để quản lý chức năng mô phỏng. Mô-đun trình chạy thử nghiệm cung cấp bản xuất

import test from 'test';const test = require('test');

07 cấp cao nhất là phiên bản

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

18. Mỗi thử nghiệm cũng cung cấp phiên bản

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

18 của riêng nó thông qua thuộc tính

import test from 'test';const test = require('test');

07 của ngữ cảnh thử nghiệm

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

50#

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

51. Một chức năng tùy chọn để tạo một mô hình trên. Mặc định. Chức năng không hoạt động

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Một chức năng tùy chọn được sử dụng làm triển khai giả cho

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

51. Điều này hữu ích để tạo các mô hình mô phỏng thể hiện một hành vi cho một số cuộc gọi được chỉ định và sau đó khôi phục hành vi của

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

51. Mặc định. Chức năng được chỉ định bởi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

51

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình tùy chọn cho chức năng mô phỏng. Các thuộc tính sau được hỗ trợ

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

57 Số lần mô phỏng sẽ sử dụng hành vi của

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Khi chức năng mô phỏng đã được gọi là

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

57 lần, nó sẽ tự động khôi phục hành vi của

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

51. Giá trị này phải là một số nguyên lớn hơn 0. Mặc định.

import test from 'test';const test = require('test');

17

trả lại. Chức năng giả định. Hàm bị giả định chứa một thuộc tính đặc biệt
```
import test from 'test';const test = require('test');
```
07, là một phiên bản của
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
16 và có thể được sử dụng để kiểm tra và thay đổi hành vi của hàm bị giả định

Chức năng này được sử dụng để tạo một chức năng giả

Ví dụ sau tạo một hàm giả tăng bộ đếm theo từng lệnh gọi. Tùy chọn

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

import test from 'test';const test = require('test');

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

65#

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

66 Đối tượng có phương thức đang bị chế nhạo

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

67. Mã định danh của phương thức trên

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

66 để giả định. Nếu

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

69 không phải là một chức năng, một lỗi sẽ được đưa ra

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Một chức năng tùy chọn được sử dụng làm triển khai giả cho

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

69. Mặc định. Phương pháp ban đầu được chỉ định bởi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

69

import test from 'test';const test = require('test');

11 Tùy chọn cấu hình tùy chọn cho phương thức mô phỏng. Các thuộc tính sau được hỗ trợ

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

74 Nếu

import test from 'test';const test = require('test');

13,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

69 được coi là getter. Không thể sử dụng tùy chọn này với tùy chọn

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

77. Mặc định. sai

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

77 Nếu

import test from 'test';const test = require('test');

13,

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

69 được coi là setter. Không thể sử dụng tùy chọn này với tùy chọn

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

74. Mặc định. sai

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

57 Số lần mô phỏng sẽ sử dụng hành vi của

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

36. Khi phương thức giả lập đã được gọi là

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

57 lần, nó sẽ tự động khôi phục hành vi ban đầu. Giá trị này phải là một số nguyên lớn hơn 0. Mặc định.

import test from 'test';const test = require('test');

17

trả lại. Phương pháp chế giễu. Phương thức giả định chứa thuộc tính đặc biệt
```
import test from 'test';const test = require('test');
```
07, là một thể hiện của
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
16 và có thể được sử dụng để kiểm tra và thay đổi hành vi của phương pháp giả lập

Chức năng này được sử dụng để tạo một mô phỏng trên một phương thức đối tượng hiện có. Ví dụ sau minh họa cách một mô hình được tạo trên một phương thức đối tượng hiện có

import test from 'test';const test = require('test');

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

88#

Hàm này khôi phục hành vi mặc định của tất cả các mô hình đã được tạo trước đó bởi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

Sau khi mỗi lần kiểm tra hoàn thành, chức năng này được gọi trong ngữ cảnh thử nghiệm của

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

94#

Chức năng này khôi phục hành vi mặc định của tất cả các mô phỏng đã được tạo trước đó bởi

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });99#

Một cuộc gọi thành công đến phương thức

import test from 'node:test';const test = require('node:test');

000 sẽ trả về một đối tượng mới, phát trực tiếp đầu ra TAP

test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});

99 sẽ phát ra các sự kiện, theo thứ tự của định nghĩa kiểm tra

Biến cố.

import test from 'node:test';const test = require('node:test');

002#

Phát ra khi

import test from 'node:test';const test = require('node:test');

003 được gọi

Biến cố.

import test from 'node:test';const test = require('node:test');

004#

Phát ra khi thử nghiệm thất bại

Biến cố.

import test from 'node:test';const test = require('node:test');

005#

Phát ra khi một bài kiểm tra vượt qua

Lớp. import test from 'test';const test = require('test');08#

Đã thêm vào. v18. 0. 0, v16. 17. 0

Một phiên bản của

import test from 'test';const test = require('test');

08 được chuyển đến từng chức năng kiểm tra để tương tác với người chạy thử nghiệm. Tuy nhiên, hàm tạo

import test from 'test';const test = require('test');

08 không được hiển thị như một phần của API

import test from 'node:test';const test = require('node:test');

009#

Đã thêm vào. v18. 8. 0, v16. 18. 0

```
import test from 'test';const test = require('test');
```
26. chức năng móc. Đối số đầu tiên của hàm này là một đối tượng
```
import test from 'test';const test = require('test');
```
08. Nếu hook sử dụng hàm gọi lại, thì hàm gọi lại được truyền dưới dạng đối số thứ hai. Mặc định. Chức năng không hoạt động
```
import test from 'test';const test = require('test');
```
11 Tùy chọn cấu hình cho hook. Các thuộc tính sau được hỗ trợ
- ```
import test from 'test';const test = require('test');
```
  15 Cho phép hủy bỏ hook đang thực hiện
- ```
import test from 'test';const test = require('test');
```
  16 Một số phần nghìn giây móc sẽ bị lỗi sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
  17
Hàm này dùng để tạo hook chạy trước mỗi subtest của test hiện tại
```
import test from 'test';const test = require('test');
```
9
```
import test from 'node:test';const test = require('node:test');
```
016#
Đã thêm vào. v18. 8. 0, v16. 18. 0
- ```
import test from 'test';const test = require('test');
```
  26. chức năng móc. Đối số đầu tiên của hàm này là một đối tượng
```
import test from 'test';const test = require('test');
```
  08. Nếu hook sử dụng hàm gọi lại, thì hàm gọi lại được truyền dưới dạng đối số thứ hai. Mặc định. Chức năng không hoạt động
- ```
import test from 'test';const test = require('test');
```
  11 Tùy chọn cấu hình cho hook. Các thuộc tính sau được hỗ trợ
  - ```
  import test from 'test';const test = require('test');
```
  15 Cho phép hủy bỏ hook đang thực hiện
- ```
import test from 'test';const test = require('test');
```
    16 Một số phần nghìn giây móc sẽ bị lỗi sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
    17
  Hàm này dùng để tạo hook chạy sau mỗi subtest của test hiện tại
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
  0
```
import test from 'node:test';const test = require('node:test');
```
  023#
  Đã thêm vào. v18. 0. 0, v16. 17. 0
  - ```
  import test from 'node:test';const test = require('node:test');
```
  024 Thông báo sẽ được hiển thị dưới dạng chẩn đoán TAP
Chức năng này được sử dụng để ghi chẩn đoán TAP vào đầu ra. Mọi thông tin chẩn đoán đều được đưa vào cuối kết quả xét nghiệm. Hàm này không trả về giá trị
```
  test('top level test', async (t) => {
    await t.test('subtest 1', (t) => {
      assert.strictEqual(1, 1);
    });
  
    await t.test('subtest 2', (t) => {
      assert.strictEqual(2, 2);
    });
  });
```
1
```
  import test from 'node:test';const test = require('node:test');
```
025#
Đã thêm vào. v18. 8. 0, v16. 18. 0
Tên của bài kiểm tra
```
  import test from 'node:test';const test = require('node:test');
```
026#
Đã thêm vào. v18. 0. 0, v16. 17. 0
- ```
import test from 'node:test';const test = require('node:test');
```
    027 Có hay không chạy thử nghiệm
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
    77
  Nếu
```
import test from 'node:test';const test = require('node:test');
```
  027 là đúng, bối cảnh thử nghiệm sẽ chỉ chạy các thử nghiệm có tùy chọn
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
  77 được đặt. Mặt khác, tất cả các bài kiểm tra được chạy. Nếu nút. js không được bắt đầu với tùy chọn dòng lệnh
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
  78, chức năng này không hoạt động
```
import test from 'node:test';const test = require('node:test');
```
  032#
  Đã thêm vào. v18. 7. 0, v16. 17. 0
  - Có thể được sử dụng để hủy bỏ các nhiệm vụ con kiểm tra khi thử nghiệm đã bị hủy bỏ
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
  2
```
import test from 'node:test';const test = require('node:test');
```
  033#
  Đã thêm vào. v18. 0. 0, v16. 17. 0
  - ```
  import test from 'node:test';const test = require('node:test');
```
  024 Thông báo bỏ qua tùy chọn sẽ được hiển thị trong đầu ra TAP
Chức năng này khiến đầu ra của bài kiểm tra cho biết bài kiểm tra bị bỏ qua. Nếu cung cấp
```
  import test from 'node:test';const test = require('node:test');
```
024, nó sẽ được bao gồm trong đầu ra TAP. Gọi
```
  import test from 'node:test';const test = require('node:test');
```
07 không chấm dứt thực hiện chức năng kiểm tra. Hàm này không trả về giá trị
```
  import test from 'node:test';const test = require('node:test');
```
037#
Đã thêm vào. v18. 0. 0, v16. 17. 0
- ```
import test from 'node:test';const test = require('node:test');
```
    024 Thông báo
```
import test from 'test';const test = require('test');
```
    40 tùy chọn sẽ được hiển thị trong đầu ra TAP
  Hàm này thêm một chỉ thị
```
import test from 'test';const test = require('test');
```
  40 vào đầu ra của bài kiểm tra. Nếu cung cấp
```
import test from 'node:test';const test = require('node:test');
```
  024, nó sẽ được bao gồm trong đầu ra TAP. Gọi
```
import test from 'node:test';const test = require('node:test');
```
  042 không chấm dứt thực hiện chức năng kiểm tra. Hàm này không trả về giá trị
```
import test from 'node:test';const test = require('node:test');
```
  043#
  Lịch sửPhiên bảnThay đổiv18. 0. 0, v16. 17. 0
  Đã thêm vào. v18. 0. 0, v16. 17. 0
  v18. 8. 0, v16. 18. 0
  Thêm tùy chọn
```
import test from 'test';const test = require('test');
```
  15
  v18. 7. 0, v16. 17. 0
  Thêm tùy chọn
```
import test from 'test';const test = require('test');
```
  16
  - ```
  import test from 'test';const test = require('test');
```
  24 Tên của bài kiểm tra phụ, được hiển thị khi báo cáo kết quả kiểm tra. Mặc định. Thuộc tính
```
  import test from 'test';const test = require('test');
```
  24 của
```
  import test from 'test';const test = require('test');
```
  26 hoặc
```
  import test from 'test';const test = require('test');
```
  27 nếu
```
  import test from 'test';const test = require('test');
```
  26 không có tên
- ```
import test from 'test';const test = require('test');
```
    11 Tùy chọn cấu hình cho bài kiểm tra phụ. Các thuộc tính sau được hỗ trợ
    - ```
    import test from 'test';const test = require('test');
```
  12 Số lượng bài kiểm tra có thể chạy cùng lúc. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
    import test from 'node:test';const test = require('node:test');
```
  02
- ```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
      77 Nếu đúng sự thật và bối cảnh thử nghiệm được định cấu hình để chạy thử nghiệm
```
test('top level test', async (t) => {
  await t.test('subtest 1', (t) => {
    assert.strictEqual(1, 1);
  });

  await t.test('subtest 2', (t) => {
    assert.strictEqual(2, 2);
  });
});
```
      77 thì thử nghiệm này sẽ được chạy. Nếu không, bài kiểm tra sẽ bị bỏ qua. Mặc định.
```
import test from 'test';const test = require('test');
```
      32
    - ```
    import test from 'test';const test = require('test');
```
  15 Cho phép hủy bỏ một bài kiểm tra đang tiến hành
- ```
import test from 'node:test';const test = require('node:test');
```
      06. Nếu trung thực, bài kiểm tra được bỏ qua. Nếu một chuỗi được cung cấp, chuỗi đó sẽ được hiển thị trong kết quả kiểm tra dưới dạng lý do bỏ qua kiểm tra. Mặc định.
```
import test from 'test';const test = require('test');
```
      32
    - ```
    import test from 'test';const test = require('test');
```
  39. Nếu trung thực, bài kiểm tra được đánh dấu là
```
    import test from 'test';const test = require('test');
```
  40. Nếu một chuỗi được cung cấp, chuỗi đó sẽ được hiển thị trong kết quả kiểm tra vì lý do tại sao kiểm tra là
```
    import test from 'test';const test = require('test');
```
  40. Mặc định.
```
    import test from 'test';const test = require('test');
```
  32
- ```
import test from 'test';const test = require('test');
```
      16 Một số mili giây kiểm tra sẽ thất bại sau. Nếu không được chỉ định, phép thử con kế thừa giá trị này từ cha mẹ của chúng. Mặc định.
```
import test from 'test';const test = require('test');
```
      17
  - ```
  import test from 'test';const test = require('test');
```
  26. Chức năng được kiểm tra. Đối số đầu tiên của hàm này là một đối tượng
```
  import test from 'test';const test = require('test');
```
  08. Nếu thử nghiệm sử dụng gọi lại, hàm gọi lại được chuyển thành đối số thứ hai. Mặc định. Chức năng không hoạt động
- trả lại. Đã giải quyết với
```
  import test from 'test';const test = require('test');
```
  20 sau khi kiểm tra hoàn tất

programming nodejs

Nodejs thực thi từng dòng một

kiểm tra phụ #

Bỏ qua các bài kiểm tra #

Cú pháp import test from 'node:test';const test = require('node:test');08/import test from 'node:test';const test = require('node:test');09#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });77 bài kiểm tra#

Lọc các bài kiểm tra theo tên #

Hoạt động không đồng bộ bên ngoài

Chế độ xem #

Chạy thử nghiệm từ dòng lệnh#

Mô hình thực thi người chạy thử nghiệm #

Chế giễu#

import test from 'test';const test = require('test');10#

import test from 'test';const test = require('test');21#

import test from 'test';const test = require('test');56#

import test from 'test';const test = require('test');70#

import test from 'test';const test = require('test');72#

import test from 'test';const test = require('test');75#

import test from 'test';const test = require('test');87#

import test from 'test';const test = require('test');89#

import test from 'test';const test = require('test');92#

import test from 'test';const test = require('test');98#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });04#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });10#

Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });16#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });19#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });30#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });33#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });35#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });43#

Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });18#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });50#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });65#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });88#

test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });94#

Lớp. test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });99#

Biến cố. import test from 'node:test';const test = require('node:test');002#

Biến cố. import test from 'node:test';const test = require('node:test');004#

Biến cố. import test from 'node:test';const test = require('node:test');005#

Lớp. import test from 'test';const test = require('test');08#

import test from 'node:test';const test = require('node:test');009#

import test from 'node:test';const test = require('node:test');016#

import test from 'node:test';const test = require('node:test');023#

import test from 'node:test';const test = require('node:test');025#

import test from 'node:test';const test = require('node:test');026#

import test from 'node:test';const test = require('node:test');032#

import test from 'node:test';const test = require('node:test');033#

import test from 'node:test';const test = require('node:test');037#

import test from 'node:test';const test = require('node:test');043#

Lớp. import test from 'test';const test = require('test');65#

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
19#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
30#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
33#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
35#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
43#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
50#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
65#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
88#

`test('top level test', async (t) => { await t.test('subtest 1', (t) => { assert.strictEqual(1, 1); }); await t.test('subtest 2', (t) => { assert.strictEqual(2, 2); }); });`
94#

Biến cố.
`import test from 'node:test';const test = require('node:test');`
002#

Biến cố.
`import test from 'node:test';const test = require('node:test');`
004#

Biến cố.
`import test from 'node:test';const test = require('node:test');`
005#

`import test from 'node:test';const test = require('node:test');`
009#

`import test from 'node:test';const test = require('node:test');`
016#

`import test from 'node:test';const test = require('node:test');`
023#

`import test from 'node:test';const test = require('node:test');`
025#

`import test from 'node:test';const test = require('node:test');`
026#

`import test from 'node:test';const test = require('node:test');`
032#

`import test from 'node:test';const test = require('node:test');`
033#

`import test from 'node:test';const test = require('node:test');`
037#

`import test from 'node:test';const test = require('node:test');`
043#