Tải bản đầy đủ (.docx) (23 trang)

Kiểm thử đơn vị với Junit

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (695.84 KB, 23 trang )

ĐẠI HỌC CÔNG NGHỆ GIAO THÔNG VẬN TẢI
KHOA CÔNG NGHỆ THƠNG TIN

KIỂM THỬ PHẦN MỀM
BÁO CÁO BÀI TẬP NHĨM 3

ĐỀ TÀI:
KIỂM THỬ ĐƠN VỊ VỚI JUNIT

HÀ NỘI – 10/2022


MỤC LỤC
CHƯƠNG 1. TỔNG QUAN VỀ KIỂM THỬ VÀ JUNIT.................................................1
1.1 Tổng quan về kiểm thử.............................................................................................1
1.2 Kiểm thử đơn vị........................................................................................................1
1.2.1 Khái niệm...........................................................................................................1
1.2.2 Tại sao cần kiểm thử đơn vị................................................................................1
1.2.3 Cách thực hiện kiểm thử đơn vị..........................................................................2
1.2.4 Kỹ thuật kiểm thử đơn vị....................................................................................3
1.2.5 Công cụ kiểm thử đơn vị....................................................................................3
1.2.6 Ưu điểm và nhược điểm của kiểm thử đơn vị.....................................................4
1.2.7 Thực hiện kiểm thử đơn vị như thế nào để đạt được kết quả tốt nhất?................5
1.3. Kiểm thử đơn vị với JUNIT.....................................................................................6
1.3.1 Tổng quan về Junit.............................................................................................6
1.3.2 Các thuật ngữ về Junit:.......................................................................................6
1.3.3 Kiến trúc tổng quan của Junit:............................................................................7
1.3.4 Lợi ích và hạn chế của Junit...............................................................................7
1.3.5 Các phương thức trong Junit...............................................................................7
1.3.6 Một số cách test với Junit...................................................................................8
1.3.7 Cấu trúc của một lớp kiểm thử Junit:..................................................................8


1.3.8 Thực hiện Tests Assert........................................................................................8
CHƯƠNG 2. Cài đặt và kiểm thử với JUNIT....................................................................1
2.1 Cài đặt Junit..............................................................................................................1
2.2 Thực hiện test với Junit.............................................................................................4
2.3 Tham số hóa các test case để test cho nhiều trường hợp của dữ liệu.........................9


LỜI MỞ ĐẦU


CHƯƠNG 1. TỔNG QUAN VỀ KIỂM THỬ VÀ JUNIT
1.1 Tổng quan về kiểm thử
- Kiểm thử phần mềm là quá trình thực thi một chương trình với mục đích tìm lỗi.
- Thơng qua chu trình “kiểm thử - tìm lỗi - sửa lỗi”, ta hy vọng chất lượng của sản phẩm
phần mềm sẽ được cải tiến.
- Kiểm thử module (hay kiểm thử đơn vị) là quá trình kiểm thử từng chương trình con,
từng thủ tục nhỏ trong chương trình.
- Mục đích của kiểm thử đơn vị: so sánh chức năng thực tế của từng module với đặc tả
chức năng hay đặc tả interface của module đó.
- Các kĩ thuật kiểm thử đơn vị như kiểm thử không tăng tiến, kiểm thử tăng tiến từ trên
xuống và kiểm thử tăng tiến từ dưới lên.
1.2 Kiểm thử đơn vị
1.2.1 Khái niệm
- Unit là một thành phần nhỏ nhất trong phần mềm có thể thực hiện kiểm thử. Các hàm
(Function), thủ tục (Procedure), lớp (Class), hoặc các phương thức (Method) đều là Unit.
- Kiểm thử đơn vị được định nghĩa là một loại kiểm thử phần mềm trong đó các đơn vị
hay thành phần riêng lẻ của phần mềm được kiểm thử.
- Kiểm thử đơn vị được thực hiện trong quá trình phát triển (coding) ứng dụng. Mục tiêu
của Kiểm thử đơn vị là cơ lập một phần code và xác minh tính chính xác của đơn vị đó.
- Trong lập trình thủ tục, một đơn vị có thể là một chức năng hoặc thủ tục riêng lẻ. Kiểm

thử đơn vị thường được thực hiện bởi developer.
- Trong quy trình phát triển phần mềm, quy trình kiểm thử phần mềm, Mơ hình chữ V,
Kiểm thử đơn vị là cấp độ kiểm thử đầu tiên được thực hiện trước khi kiểm thử tích hợp.
Kiểm thử đơn vị là một kỹ thuật WhiteBox testing, thường được thực hiện bởi developer.
Tuy nhiên trong một thực tế, do thời gian bị giới hạn hoặc yêu cầu của các developer, các
kỹ sư QA cũng thực hiện kiểm thử đơn vị.
1.2.2 Tại sao cần kiểm thử đơn vị
Đôi khi các developer tiết kiệm thời gian bằng cách thực hiện kiểm thử đơn vị trong
phạm vi tối thiểu. Đây là một sai lầm bởi vì thực hiện kiểm thử đơn vị không kĩ lưỡng sẽ

1


dẫn đến chi phí sửa lỗi cao hơn trong quá trình Kiểm thử hệ thống, Kiểm thử tích hợp và
thậm chí Kiểm thử Beta sau khi ứng dụng hồn tất. Kiểm thử đơn vị được thực hiện trong
giai đoạn xây dựng sẽ giúp tiết kiệm cả thời gian và tiền bạc. Đây là những lý do chính để
thực hiện kiểm thử đơn vị.

1. Kiểm thử đơn vị giúp sửa lỗi sớm trong chu kỳ phát triển và tiết kiệm chi phí.
2. Kiểm thử đơn vị giúp các developer hiểu cơ sở nền tảng và cho phép họ thay đổi
nhanh chóng
3. Kiểm thử đơn vị tốt sẽ được phục vụ như tài liệu dự án
4. Kiểm thử đơn vị có thể sử dụng lại code. Sao chép cả code và những trường hợp kiểm
thử sang dự án mới. Chỉnh code để có thể chạy lại.
1.2.3 Cách thực hiện kiểm thử đơn vị
Kiểm thử đơn vị có hai loại:
-

Thủ cơng


-

Tự động

Kiểm thử đơn vị thường được thực hiện tự động nhưng vẫn có thể được thực hiện thủ
cơng. Kiểm thử đơn vị tự động hóa được ưa thích hơn.
Theo hướng tiếp cận tự động:

2


 Một developer viết một phần code trong ứng dụng và chỉ kiểm thử chức năng. Sau đó,
họ sẽ chú thích và cuối cùng sẽ loại bỏ code kiểm thử khi ứng dụng được triển khai.
 Một developer cũng có thể cô lập chức năng để kiểm thử được chặt chẽ hơn. Kiểm thử
đơn vị được thực hiện kỹ lưỡng hơn nếu copy code vào môi trường kiểm thử riêng so
với mơi trường tự nhiên của nó. Cơ lập code giúp nhận biết các ràng buộc không cần
thiết giữa code được kiểm thử và các đơn vị khác trong sản phẩm. Những ràng buộc đó
có thể được loại bỏ.
 Một lập trình viên thường sử dụng UnitTest Framework để phát triển các test cases tự
động. Sử dụng Framework tự động hóa, các developer kiểm thử các tiêu chí codes để
xác minh tính chính xác của code. Trong q trình thực hiện các test cases, framework
ghi và file log các test cases bị lỗi. Nhiều framework cũng sẽ tự động gắn cờ và báo
cáo. Tùy thuộc vào mức độ nghiêm trọng của một lỗi, framework có thể tạm dừng
kiểm thử.
 Quy trình làm việc của Kiểm thử đơn vị là: Tạo các test cases => Review/Rework =>
Baseline => Thực hiện các test cases
1.2.4 Kỹ thuật kiểm thử đơn vị
Các kỹ thuật bao phủ code được sử dụng trong kiểm thử đơn vị được liệt kê dưới đây:
 Statement Coverage
 Decision Coverage

 Branch Coverage
 Condition Coverage
 Finite State Machine Coverage
1.2.5 Công cụ kiểm thử đơn vị
Có một số cơng cụ tự động có sẵn hỗ trợ kiểm thử đơn vị. Chúng ta cùng xem một vài ví
dụ dưới đây:
1. Jtest: Parasoft Jtest là một plugin IDE sử dụng các frameworks mã nguồn mở (Junit,
Mockito, PowerMock và Spring) với các chỉ dẫn và hành động, dễ dàng tạo, mở rộng

3


và bảo trì kiểm thử đơn vị. Bằng cách kiểm thử đơn vị tự động trường hợp tốn thời
gian, sẽ giúp developer tập trung vào logic và tạo ra các bộ kiểm thử có ý nghĩa hơn.
2. Junit: Junit là một cơng cụ kiểm thử miễn phí, được sử dụng cho ngơn ngữ lập trình
Java. Junit cung cấp các nhận định để xác định phương pháp kiểm thử. Công cụ này
kiểm thử dữ liệu đầu tiên, sau đó chèn vào đoạn code.
3. NUnit: NUnit được sử dụng rộng rãi, sử dụng framework kiểm thử đơn vị cho tất cả
các ngôn ngữ .net. Đây là một công cụ mã nguồn mở cho phép viết các kịch bản thủ
công, hỗ trợ các kiểm thử dựa trên dữ liệu (data-driven) có thể chạy song song.
4. JMockit: JMockit là công cụ kiểm thử Đơn vị mã nguồn mở. Đây là một công cụ bao
phủ code với các số liệu path và line. JMockit cho phép bắt chước API với cú pháp
recording và verification. Công cụ này xác định Line coverage, Path Coverage, và
Data Coverage.
5. EMMA: EMMA là bộ công cụ mã nguồn mở dùng để phân tích và báo cáo code được
viết bằng ngơn ngữ Java. Emma hỗ trợ các loại bao phủ như method, line, basic block.
Emma dựa trên Java nên không phụ thuộc vào thư viện bên ngồi và có thể truy cập
mã nguồn.
6. PHPUnit: PHPUnit là một công cụ kiểm thử đơn vị cho lập trình viên PHP. Phải mất
một phần nhỏ code được gọi là các đơn vị và kiểm thử từng mã riêng biệt. Công cụ

này cũng cho phép các developer sử dụng các phương thức xác nhận được xác định
trước để khẳng định rằng một hệ thống hoạt động theo một cách nhất định.
Đó chỉ là một vài cơng cụ kiểm thử đơn vị. Có nhiều cơng cụ kiểm thử đơn vị khác, đặc
biệt là đối với ngôn ngữ C và Java, nhưng rất dễ dàng để tìm thấy một công cụ kiểm thử
đơn vị cho nhu cầu lập trình của mình bất kể ngơn ngữ bạn sử dụng là gì.
1.2.6 Ưu điểm và nhược điểm của kiểm thử đơn vị
Ưu điểm:
 Các developer muốn tìm hiểu chức năng nào được cung cấp bởi một đơn vị và cách sử
dụng chức năng này có thể xem xét các test cases kiểm thử đơn vị để có được sự hiểu
biết cơ bản về unit API.

4


 Kiểm thử đơn vị cho phép lập trình viên cấu trúc lại code vào một ngày sau đó và đảm
bảo mơ-đun vẫn hoạt động chính xác (ví dụ: Kiểm thử hồi quy). Quy trình là viết các
trường hợp kiểm thử cho tất cả các hàm và phương thức để mỗi khi thay đổi gây ra lỗi,
nó có thể được xác định và sửa chữa nhanh chóng.
 Do tính chất mơ-đun của kiểm thử đơn vị, chúng ta có thể kiểm thử các phần của dự án
mà không cần chờ người khác hồn thành.
Nhược điểm:
 Kiểm thử đơn vị khơng thể phát hiện được mọi lỗi trong một chương trình. Không thể
đánh giá tất cả các luồng thực hiện ngay cả trong các chương trình tầm thường nhất
 Kiểm thử đơn vị theo bản chất là tập trung vào một đơn vị code. Do đó, kiểm thử đơn
vị khơng thể bắt lỗi tích hợp hoặc lỗi hệ thống lớn.
1.2.7 Thực hiện kiểm thử đơn vị như thế nào để đạt được kết quả tốt nhất?
 Các trường hợp kiểm thử đơn vị phải độc lập. Trong trường hợp có bất kỳ cải tiến hoặc
thay đổi trong yêu cầu, các trường hợp kiểm thử đơn vị sẽ không bị ảnh hưởng.
 Chỉ kiểm thử một đoạn code tại một thời điểm.
 Thực hiện theo các quy ước đặt tên rõ ràng và nhất quán cho các test cases kiểm thử

đơn vị
 Trường hợp thay đổi code trong bất kỳ mô-đun nào, nên đảm bảo có Trường hợp kiểm
thử đơn vị tương ứng cho mỗi mô-đun, khi pass các trường hợp kiểm thử của một môđun mới nên thay đổi triển khai kiểm thử mô-đun khác.
 Lỗi được xác định trong quá trình kiểm thử đơn vị phải được sửa trước khi chuyển
sang giai đoạn tiếp theo trong quy trình phát triển phần mềm
 Càng viết nhiều code mà không kiểm thử, bạn càng phải kiểm thử nhiều trường hợp.

5


1.3. Kiểm thử đơn vị với JUNIT
1.3.1 Tổng quan về Junit
- Khái niệm: JUnit là một đơn giản sử dụng cho việc tạo các đơn vị kiểm tra tự động và
chạy thử nghiệm có thể lặp đi lặp lại. Nó chỉ là một kiến trúc xUnit của họ cho phép tạo
các kiểm tra đơn vị.
- Lịch sử phát triển của Junit:
+ Vào giữa những năm 90 của thế kỷ 20, Kent Beck đã phát triển một bộ thử nghiệm đầu
tiên cho SmallTalk.
+ Beck và Gamma phát triển Junit trên một chuyến bay từ Zurick đến Washington, DC.
+ Từ đó trở đi Junit trở thành công cụ chuẩn cho Phát triển Thách thức trong Java.
+ Ngày nay, Junit được tích hợp sẵn trong các IDE của Java (Eclipse, BlueJ, Jbuilder,
DrJava).
1.3.2 Các thuật ngữ về Junit:
- “Test runner” là phần mềm chạy kiểm thử và báo cáo kết quả.
- “Test suite” là một tập các trường hợp kiểm thử.
- “Test case” kiểm tra phản ứng của một hàm đơn với 1 tập đầu vào.
- “Unit test” là một kiểm thử của phần tử mã nguồn nhỏ nhất có thể kiểm thử, thường là
một lớp đơn.
- “Test fixture” là môi trường chạy kiểm thử. Một môi trường mới được cài đặt trước mỗi
lần thực hiện trường hợp kiểm thử và được huỷ bỏ sau đó.


6


Ví dụ: để thử nghiệm một CSDL, mơi trường kiểm thử có thể thiết lập máy chủ ở trạng
thái ban đầu chuẩn, sẵn sàng cho khách hàng để kết nối.
- “Integration test” là một kiểm thử cho việc kết hợp hoạt động của nhiều lớp với nhau.
Junit hỗ trợ một phần cho kiểm thử tích hợp.
1.3.3 Kiến trúc tổng quan của Junit:

1.3.4 Lợi ích và hạn chế của Junit
- Mục đích, lợi ích: Junit tránh cho người lập trình phải làm đi làm lại những việc kiểm
thử nhàm chán bằng cách tách biệt mã kiểm thử ra khỏi mã chương trình, đồng thời tự
động hóa việc tổ chức và thi hành các bộ số liệu kiểm thử.
- Hạn chế của Junit:
+ Tốn thời gian cho việc chạy toàn bộ test suite.
+ Rất nhiều chương trình được lập trình thêm: “Đúng!”, nhưng chúng ta có thể sử dụng
những framework có sẵn giúp chúng ta giảm bớt trong quá trình lập trình.
1.3.5 Các phương thức trong Junit
+ assertXXX(): Các phương thức dạng assertXXX() được dùng để kiểm tra các điều kiện
khác nhau.
+ SetUp() và teardown(): Hai phương thức này là 1 phần của 1 lớp
Junit.framework.TestCase. Khi sử dụng 2 phương thức này sẽ giúp chúng ta tránh được
việc trùng mã khi nhiều test cùng chia sẻ nhau ở phần khởi tạo và dọn dẹp các biến.

7


+ Tổ chức các phép thử: Mỗi phép thử (Test Case) chỉ nên kiểm tra phần cụ thể của một
chức năng nào đó. Chúng ta khơng nên kết hợp nhiều phép thử không liên quan đến nhau

vào trong cùng 1 phương thức testXXX().
1.3.6 Một số cách test với Junit
+ Kiểm tra với 1 test case.
+ Kiểm tra với nhiều test case.
+ Kiểm tra với exception.
+ Dùng test làm hướng dẫn sử dụng.
1.3.7 Cấu trúc của một lớp kiểm thử Junit:
- Chúng ta muốn kiểm thử một lớp tên Triangle:
+ Đây là kiểm thử đơn vị của lớp Triangle, định nghĩa đối tượng sử dụng trong một hay
nhiều kiểm thử: public class TriangleTestJ4{}
+ Đây là hàm tạo mặc định: public TriangleTest () {}
- @Before public void init (): Tạo một môi trường kiểm thử bằng cách tạo và khởi tạo các
đối tượng và các giá trị.
- @After public void cleanUp (): Giải phóng các tài nguyên hệ thống sử dụng bởi mơi
trường kiểm thử. Java thường thực hiện giải phóng tự động nhưng files, kết nối mạng có
thể ko được giải phóng hồn tồn.
- @Test public void noBadTriangles (), @Test public void
scaleneOk (), etc: Các phương thức chứa các tests cho hàm tạo Triangle và phương thức
isScalene ().
1.3.8 Thực hiện Tests Assert
- Trong một test:
+ Gọi phương thức được kiểm thử và thu kết quả thực tế.
+ Assert (xác nhận) một thuộc tính chứa kết quả kiểm thử.
+ Mỗi assert là một thách thức cho kết quả kiểm thử.
- Nếu một thuộc tính thất bại, assert sẽ thất bại và một đối tượng AssertionFailedError
được sinh ra.
Junit sẽ nhận được các lỗi, ghi lại các kết quả kiểm thử và hiển th

8



CHƯƠNG 2. Cài đặt và kiểm thử với JUNIT
2.1 Cài đặt Junit
Bước 1: Mở Eclipse, tạo mới project tên TestJUnit ==> Finish

1


Bước 2: Thêm thư viện JUnit cho project.
Chuột phải vào project TestJUnit ==> Build Path ==> Add Library.

2


Chọn JUnit sau đó chọn JUnit 4 rồi Finish.

3


2.2 Kiểm thử bài tốn phép tính với Junit
2.2.1 Mơ tả bài toán và các test case

4


Bài tốn: Thực hiện kiểm thử bài tốn phép tính (+, -, *, /) của hai số nguyên
Bảng test case
Phép toán
+
*

/
+
/
*
/
2.2.2 Các bước thực hiện

Đầu vào
(1, 1)
(1, 1)
(1, 1)
(1, 1)
(a, b)
(1, 0)
(‘’, a)
(/, 2)
(a, b)

Kết quả mong đợi
2
0
1
1
||
||
||
||
||

Kết quả trả về


Trong JUnit, chúng ta có thể đưa tham số vào các unit test bằng 2 cách:
1. Thông qua phương thức khởi tạo (Constructor).
2. Sử dụng filed injection với annotation @Parameter.
Bước 1: Tạo mới project tên Parameterizing.
Bước 2: Add JUnit vào class path của project.
Bước 3: Tạo mới class tên MathUtils.
Trong class MathUtils, tạo một phương thức static đơn giản trả về tổng của hai số nguyên
bất kì. Chúng ta sẽ sử dụng class này để tạo các test case với JUnit.

5


Bước 4: Parameterized với JUnit thông qua phương thức khởi tạo Constructor.
Tạo mới class ParameterizedTest.
Trong class này chúng ta sẽ sử dụng annotation @RunWith của JUnit để chỉ cho JUnit
biết rằng test case này sẽ được chạy cùng với class nào. Cụ thể là @RunWith(value =
Parameterized.class) của chính JUnit.
Chúng ta sẽ thêm cấu hình tham số thơng qua phương thức khởi tạo của class
ParameterizedTest. Tham số sẽ là 1 array gồm 3 phần tử, tương ứng với number 1 (a),
number 2 (b) và tổng.

6


Lines từ 18-22: chúng ta có phương thức khởi tạo của class ParameterizedTest. Trong
phương thức này chúng ta gán các giá trị tham số truyền vào (còn gọi là arguments) cho
các thuộc tính của class ParameterizedTest (có 3 thuộc tính tương ứng với 2 số hạng và
tổng của chúng).
Line 24: chúng ta sử dụng annotations @Parameters để định dạng dữ liệu của tham số,

thuộc tính name của annotation này là không bắt buộc, ở đây chúng ta để name là một
chuỗi biểu diễn chuỗi sẽ được in ra console khi từng đối tượng dữ liệu (lưu trong
collection) được test.
Bước 5: Chạy test case review kết quả.
Chuột phải vào class ParameterizedTest ==> Chọn Run As ==> Chọn JUnit Test.

7


Chúng ta sẽ quan sát thấy 5 test case với các đầu vào dữ liệu khác nhau được thực hiện.
Bước 6: Sửa lại class ParameterizedTest để thực hiện tham số hóa test case theo cách thứ
2 (Field Injection).
Chúng ta xóa đi phương thức khởi tạo của class này, thay vì thế sẽ sử dụng injection
@Parameter của JUnit cho từng thuộc tính của class. Chú ý rằng các thuộc tính này phải
được chuyển từ private sang public.

8


Chạy lại test case chúng ta thu được cùng kết quả như Bước 5.
2.3 Kiểm thử bài toán tam giác với Junit
2.3.1 Mơ tả bài tốn và bảng test case
Bài toán: Cho ba số a, b, c. Kiểm tra xem ba số đó là cạnh của tam giác hay khơng, nếu
có thì đó là tam giác gì?
Bảng test case
a
1
3
6
6

‘’
-1
a
3

b
2
4
6
6
7
3
1
10

c
3
5
7
6
7
2
5
8

Kết quả mong đợi
Khong la tam giac
Day la tam giac vuong
Day la tam giac can
Day la tam giac deu

||
Loi du lieu
||
Day la tam giac

9

Kết quả thực tế


aaaaaaaa

10


BẢNG PHÂN CÔNG CÔNG VIỆC
Thành viên
Nguyễn Đức Nam
Nguyễn Trường An
Đặng Tiến Tồn

Cơng việc đã làm

1


KẾT LUẬN

1




×