Nhom3 KTPM

TRƯỜNG ĐẠI HỌC ĐẠI NAM
KHOA CÔNG NGHỆ THÔNG TIN
BÁO CÁO HỌC PHẦN

KIỂM THỬ PHẦN MỀM
ĐỀ BÀI: TÌM HIỂU CÔNG CỤ KIỂM THỬ ĐƠN VỊ

NUNIT
Giảng viên hướng dẫn : TS. Lê Chí Luận

Lớp : CNTT13-01
Nhóm sinh viên thực : Chu Văn Huy
hiện
Ngô Huy Phong
Trần Trọng Tuân
Bùi Văn Thọ
Hà nội, ngày … tháng … năm 2022

TRƯỜNG ĐẠI HỌC ĐẠI NAM
KHOA CÔNG NGHỆ THÔNG TIN
BÁO CÁO HỌC PHẦN

KIỂM THỬ PHẦN MỀM
ĐỀ BÀI: TÌM HIỂU CÔNG CỤ KIỂM THỬ ĐƠN VỊ

NUNIT
Giảng viên hướng dẫn : TS. Lê Chí Luận

Lớp : CNTT13-01
Nhóm sinh viên thực : Chu Văn Huy
hiện
Ngô Huy Phong
Trần Trọng Tuân
Bùi Văn Thọ
Hà nội, ngày … tháng … năm 2022

LỜI CẢM ƠN
Trong thời gian nghiên cứu, học tập tại khoa Công nghệ thông tin trường Đại học
Đại Nam, được sự giúp đỡ quý báu của quý thầy cô giáo, các bạn sinh viên của nhóm đã
giúp em hoàn thiện đề tài. Trước tiên cho phép em được bày tỏ lời cảm ơn sâu sắc nhất tới
các thầy cô trong khoa Công nghệ thông tin. Đặc biệt là thầy TS. Lê Chí Luận, giảng
viên khoa Công nghệ thông tin, trường Đại học Đại Nam, người trực tiếp hướng dẫn,
nhận xét, giúp đỡ nhóm em trong suốt quá trình thực hiện và hoàn thành đề tài.
Trong quá trình thực hiện làm đề tài còn có rất nhiều sai sót, nhóm em mong nhận
được sự giúp đỡ nhiệt tình của thầy cô cũng như các bạn để hoàn thiện một cách tốt nhất.
Nhóm em xin chân thành cảm ơn!
Hà Nội, ngày .. tháng .. năm 2022

Nhóm sinh viên thực hiện
1
NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
………………………………………………………………………………………………
Giáo viên hướng dẫn

TS. Lê Chí Luận
2
NHẬN XÉT CỦA NHÓM VỀ CÁC THÀNH VIÊN
Tên thành viên Phần trăm đóng Ghi chú

góp ( 100% )
1. Chu Văn Huy Nhóm trưởng
2. Ngô Huy Phong Thành viên
3. Trần Trọng Tuân Thành viên
4. Bùi Văn Thọ Thành viên
Trưởng nhóm
3
LỜI NÓI ĐẦU
Nhờ có sự phát triển vượt bậc của công nghệ thông tin cũng như công nghệ phần
mềm đã dẫn đến việc phát triển phần mềm ngày càng được hỗ trợ bởi rất nhiều công cụ
tiên tiến, giúp hạn chế những khó khăn và nâng cao hiệu quả trong việc xây dựng phần
mềm. Tuy vậy, vì độ phức tập của phần mềm và những giới hạn về trời gian, chi phí cho
nên cũng không chắc chắn đảm bảo được rằng các sản phẩm phần mềm đang được ứng
dụng là không có lỗi cho dù các hoạt động đảm bảo chất lượng phần mềm nói chung và
kiểm thử nói riêng ngày càng chặt chẽ và khoa học. Lỗi phần mềm luôn tồn tại tiềm ẩn
bên trong mọi sản phẩm phần mềm và có thể gây ra những thiệt hại không lường trước
được bất cứ lúc nào.
Một sản phẩm phần mềm không đơn giản là các giai đoạn mã chương tình, mà nó
còn bao gồm nhiều thành phần với nhiều các vai trò khác nhau. Do đó, việc xảy ra các lỗi
phần mềm không chỉ ở công đoạn lập trình, mà còn xảy ra ở tất cả các công đoạn khác
nhau của quy trình phát triển phần mềm, với xác suất cao thấp khác nhau. Kiểm thử là
một công đoạn đóng vai trò tối qaun trọng, quyết định đến việc đánh giá chất lượng của
một sản phẩm phần mềm. Mục đích của kiểm thử là đảm bảo rằng tất cả các thành phần
của phần mềm ăn khớp, vận hành như mong đợi và phù hợp các tiêu chẩn thiết kế.
Kiểm thử phần mềm là một trong những hoạt động quan trọng trong tiến trình phát
triển phần mềm. Nó góp một phần rất lớn trong việc đánh giá chất lượng của một phần
mềm và quy trình bắt buộc trong các dự án phát triển phần mềm trên thế giới cũng như
trong nước.
Để củng cố kiến thức đã học và ứng dụng trong một số công việc cụ thể nên nhóm
chúng em đã được giao tìm hiểu về công cụ kiểm thử NUnit và ứng dụng để tiến hành
kiểm thử chương trình kiểm tra tam giác. Nhóm chúng em xin chân thành cảm ơn thầy Lê
Chí Luận đã tận tình chỉ dạy và hướng dẫn chúng em hoàn thiện đồ án này.
Nhóm thực hiện
4
MỤC LỤC
LỜI CẢM ƠN...........................................................................................................1
NHẬN XÉT CỦA GIÁO VIÊN HƯỚNG DẪN.....................................................2
NHẬN XÉT CỦA NHÓM VỀ CÁC THÀNH VIÊN.............................................3
LỜI NÓI ĐẦU..........................................................................................................4
MỤC LỤC.................................................................................................................6
CHƯƠNG 1: TỔNG QUAN VỀ KIỂM THỬ PHẦN MỀM..............................10
1.1. Định nghĩa....................................................................................................10
1.2. Kỹ thuật kiểm thử phần mềm.......................................................................10
1.2.1. Kỹ thuật kiểm thử chức năng..................................................................10
1.2.2. Kỹ thuật kiểm thử cấu trúc.....................................................................10
1.3. Chiến lược kiểm thử.....................................................................................11
1.4. Các giai đoạn kiểm thử................................................................................11
1.4.1. Kiểm thử đơn vị (Unit Testing)...............................................................11
1.4.2. Kiểm thử tích hợp (Integration Testing).................................................12
1.4.3. Kiểm thử hợp thức hóa (Validation Testing)..........................................12
1.4.4. Kiểm thử chấp nhận (Acceptance Testing).............................................13
1.4.5. Kiểm thử hồi quy (Regression Testing)...................................................13
1.5. Một số vấn đề khác của kiểm thử phần mềm..............................................13
1.5.1. Các hạn chế của kiểm thử......................................................................13
1.5.2. Các nguyên tắc kiểm thử........................................................................14
1.5.3. Phân loại một số công cụ kiểm thử tự động............................................15
CHƯƠNG 2: CÔNG CỤ KIỂM THỬ NUNIT....................................................17
2.1. Giới thiệu......................................................................................................17
2.1.1. NUnit-console.........................................................................................17
2.1.2. NUnit-Gui.exe........................................................................................18
2.2. Lớp Assert.....................................................................................................18
2.3. Các thuộc tính trong Nunit..........................................................................19
CHƯƠNG 3: HƯỚNG DẪN SỬ DỤNG CÔNG CỤ NUNIT.............................21
3.1. Download và cài đặt công cụ........................................................................21
3.1.1. Download công cụ..................................................................................21
3.1.2. Cài đặt công cụ.......................................................................................22
3.2. Bắt đầu sử dụng chương trình.....................................................................27
CHƯƠNG 4: GIỚI THIỆU VỀ CHƯƠNG TRÌNH ỨNG DỤNG.....................39
4.1. Mô tả bài toán...............................................................................................39
4.1.1. Mục đích.................................................................................................39
5
4.1.2. Phạm vi...................................................................................................39
4.2. Mô tả chương trình......................................................................................39
4.2.1. Tổng quan về chương trình.....................................................................39
4.2.2. Yêu cầu hệ thống....................................................................................39
4.2.3. Yêu cầu chức năng..................................................................................39
CHƯƠNG 5: TIẾN HÀNH KIỂM THỬ..............................................................41
5.1. Xây dựng các test cases cho chương trình kiểm tra tam giác.....................41
5.2. Xây dựng các trường hợp kiểm thử.............................................................43
KẾT LUẬN..............................................................................................................54
6
Tìm hiểu về công cụ kiểm thử Nunit Chương 1: Tổng quan về kiểm thử phần mềm
CHƯƠNG 1: TỔNG QUAN VỀ KIỂM THỬ PHẦN MỀM

1.1. Định nghĩa
Kiểm thử phần mềm có nhiều cách định nghĩa khác nhau. Tuy nhiên, chúng cùng
bao trùm hai nội dung cơ bản là phát hiện lỗi và đánh giá chất lượng của phần mềm. Định
nghĩa sau đây của Myers là đơn giản và có tính thực tế: “Kiểm thử là tiến trình thực thi
chương trình với mục đích tìm thấy lỗi”. Theo định nghĩa của Myers, kiểm thử mà không
phát hiện được lỗi được coi là không thành công.
Mục đích của kiểm thử là phát hiện lỗi vì trong thực tế phần mềm hầu như không
bao giờ không chứa lỗi.
1.2. Kỹ thuật kiểm thử phần mềm
Có thể chia các kỹ thuật kiểm thử thành hai loại: kỹ thật kiểm thử chức năng
(Functional Testing) hay còn gọi là kỹ thật kiểm thử hộp đen (Black-box-Testing) và kỹ
thật kiểm thử cấu trúc (Structutural Testing) hay còn gọi là kỹ thuật kiểm thử hộp trắng
(White-box-Testing).
1.2.1. Kỹ thuật kiểm thử chức năng
Trong kỹ thuật kiểm thử chức năng, dữ liệu kiểm thử được xuất phát từ đặc tả phần
mềm bao gồm: đặc tả các yêu cầu (đối với kiểm thử hệ thống), đặc tả thiết kế (đối với
kiểm thử tích hợp) và đặc tả chi tiết mô-đun (đối với kiểm thử đơn vị). Trong kỹ thuật
này, kiểm thử viên xem phần mềm như là một hộp đen. Kiểm thử viên hoàn toàn không
quan tâm cấu trúc và hành vi bên trong của phần mềm. Kiểm thử viên chỉ cần quan tâm
đến việc tìm các hiện tượng mà phần mềm không hành xử theo đúng đặc tả của nó.
Kiểm thử viên chỉ biết những gì phần mềm dự kiến thực hiện và những gì dự kiến
không thực hiện, mà không thể nhìn vào bên trong xem nó hoạt động như thế nào. Vì thế
dữ liệu kiểm thử sẽ xuất phát từ đặc tả.
Kiểm thử chức năng cố gắng tìm các lỗi sau: thiếu chức năng, lỗi giao diện, lỗi cấu
trúc dữ liệu, lỗi truy cập cơ sở dữ liệu, lỗi thi hành, lỗi khởi tạo hoặc kết thúc,…
1.2.2. Kỹ thuật kiểm thử cấu trúc
Kỹ thuật kiểm thử cấu trúc là kỹ thuật dựa trên sự phân tích mã chương trình hoặc
một mô hình của mã chương trình để xây dựng các phép thử theo các tiêu chuẩn bao phủ.
Kỹ thuật kiểm thử cấu trúc cho phép chúng ra kiểm thử cấu trúc bên trong của phần
mềm, với mục đích kiểm tra rất cả các câu lệnh và điểu kiện tồn tại trong phần mềm đó.
Trong kỹ thuật này, kiểm thử viên lấy dữ liệu thử xuất phát từ việc kiểm tra logic của
chương trình (không quan tâm đến đặc tả).
1.3. Chiến lược kiểm thử
Một chiến lược kiểm thử (test strategy) là một kế hoạch định nghĩa mục tiêu các giai
đoạn kiểm thử cũng như các kỹ thuật kiểm thử sử dụng. Chiến lược kiểm thử thường
được quyết định dựa vào tiêu chuẩn về độ tin cậy của phần mềm và chi phí cho việc phát
triển phần mềm. Ngoài ra, một chiến lược kiểm thử sẽ phụ thuộc kích thước của đối tượng
được kiểm thử cũng như quan điểm về đối tượng được kiểm thử.
Nếu chúng ta muốn kiểm thử một cách độc lập các thành phần/đơn vị cấu tạo nên
phần mềm, chúng ta gọi là kiểm thử đơn vị. Nếu chúng ta muốn kiểm thử sự kết hợp các
thành phần cấu tạo nên phần mềm, chúng ta gọi là kiểm thử tích hợp. Nếu chúng ta muốn
bảo đảm rằng một phần mềm đang được phát triển một cách đúng đắn và các thành phần
cấu tạo nên phần mềm cũng được phát triển một cách đúng đắn, chúng ta gọi là xác minh
(verification). Tuy nhiên, một phần mềm không chỉ đơn thuần là đáp ứng yêu cầu của nhà
sản xuất, mà nó chỉ trở nên hữu ích nếu đáp ứng được nhu cầu của người sử dụng cuối
cùng. Việc bảo đảm một phần mềm đáp ứng nhu cầu của người sử dụng được gọi là hợp
thức hoá (validation).
1.4. Các loại kiểm thử
1.4.1. Kiểm thử đơn vị (Unit Testing)
Phần lớn các phương pháp thiết kế phần mềm đều dẫn đến chia phần mềm thành
những mô- đun hay chương trình nhỏ có các dữ liệu vào và kết quả riêng. Chúng ta gọi
các mô-đun hay chương trình đó là các đơn vị (unit) phần mềm. Trên các đơn vị này
chúng ta sẽ tiến hành kiểm thử đơn vị.
Một khi đơn vị phần mềm đã được mã hoá, nghĩa là lập trình và hồ sơ kiểm thử đơn
vị tương ứng đã được hoàn thành thì kiểm thử đơn vị có thể được tiến hành.
Kiểm thử đơn vị chủ yếu là thực hiện các trường hợp kiểm thử (test case) đã được
mô tả trong hồ sơ kiểm thử đơn vị và điền các thông tin cần thiết vào các phiếu báo cáo
kiểm thử. Nếu một lỗi hay sự không tương thích được phát hiện, cần phải chỉnh sửa lại
đơn vị phần mềm. Sau đó, kiểm thử đơn vị được thực hiện lại. Kiểm thử đơn vị sẽ kết
thúc khi mà tất cả các trường hợp kiểm thử được mô tả trong hồ sơ kiểm thử đơn vị đã
được thực hiện thành công và kết quả được lưu lại trong hồ sơ.
1.4.2. Kiểm thử tích hợp (Integration Testing)
Kiểm thử tích hợp được tiến hành một khi kiểm thử đơn vị các thành phần cần thiết
cho kiểm thử tích hợp kết thúc và hồ sơ kiểm thử tích hợp đã được chuẩn bị sẵn sàng.
Trong giai đoạn kiểm thử tích hợp, ý tưởng là các thành phần đã được kiểm thử đơn vị sẽ
được tích hợp lại dần dần cho đến khi có được toàn bộ phần mềm. Phần mềm càng phức
tạp thì đòi hỏi giai đoạn kiểm thử tích hợp phải trải qua các giai đoạn trung gian, là các
giai đoạn mà các nhóm các thành phần sẽ được kiểm thử.
Mục tiêu của giai đoạn kiểm thử tích hợp là kiểm tra sự giao tiếp và trao đổi dữ liệu
giữa các thành phần phần mềm. Trong giai đoạn tích hợp, có thể có khả năng phải sử
dụng các thành phần không được phát triển trong dự án phần mềm, mà là những thành
phần được cung cấp sẵn bởi các thư viện hay thậm chí là các thành phần được cung cấp
bởi hệ điều hành.
Khi tích hợp các thành phần tạo thành tập hợp, chúng ta có thể tiến hành theo các
chiến lược:
- Tích hợp từ trên xuống (top-down) bằng cách kiểm thử tích hợp các thành phần
chính trước, sau đó thêm vào các thành phần được gọi trực tiếp bởi các thành phần
vừa kiểm thử.
- Tích hợp từ dưới lên (bottom-up) bằng cách kiểm thử các thành phần không gọi
các thành phần khác, sau đó thêm vào các thành phần gọi các thành phần vừa kiểm
thử.
1.4.3. Kiểm thử hợp thức hóa (Validation Testing)
Kiểm thử hợp thức hoá có thể bắt đầu ngay sau khi kiểm thử tích hợp kết thúc và hồ
sơ kiểm thử hợp thức hoá đã sẵn sàng. Mục tiêu của kiểm thử hợp thức hoá là cần chỉ ra
rằng phần mềm thực hiện đúng những gì mà người sử dụng mong đợi. Vì thế, ở giai đoạn
này, kiểm thử được thực hiện dưới góc nhìn của người sử dụng, chứ không phải dưới góc
nhìn của người phát triển như các giai đoạn kiểm thử đơn vị hay kiểm thử tích hợp.
Vì kiểm thử được thực hiện dưới góc nhìn của người sử dụng nên giai đoạn này chỉ
sử dụng các kỹ thuật kiểm thử chức năng, tức là các kỹ thuật kiểm thử hộp đen. Các bộ dữ
liệu thử sẽ được tạo ra dựa trên các tài liệu đặc tả. Thông thường các tài liệu đặc tả sẽ
được phân tích để xác định các yêu cầu chứa đựng các hành vi mong đợi của phần mềm.
1.4.4. Kiểm thử chấp nhận (Acceptance Testing)
Được thực hiện khi tất cả các giai đoạn kiểm thử được hoàn tất nhằm để chứng minh
phần mềm đã đủ sẵn sàng xuất xưởng. Các thủ tục kiểm thử hoặc chạy thử phải được
người đặt hàng chấp nhận trước khi thực hiện để nghiệm thu.
1.4.5. Kiểm thử hồi quy (Regression Testing)
Phần mềm là một trong những loại sản phẩm thay đổi rất nhanh. Người sử dụng
luôn có yêu cầu cải tiến phần mềm và các chức năng mới. Vì vậy, sự chỉnh sửa phần mềm
sau khi đưa vào sử dụng là cần thiết. Mặt khác, bất kỳ sự sửa đổi nào cùng có thể dẫn đến
các lỗi mới. Phần mềm nhất thiết phải được kiểm thử lại sau khi sửa đổi, giai đoạn kiểm
thử này gọi là kiểm thử hồi quy.
Giai đoạn kiểm thử hồi quy thường tái sử dụng các bộ dữ liệu thử đã sử dụng trong
các giai đoạn trước nhằm kiểm tra rằng không có các lỗi mới được đưa vào. Vấn đề đặt ra
ở đây là trong giai đoạn này, các bộ dữ liệu thử nào được tái sử dụng: kiểm thử đơn vị,
kiểm thử tích hợp hay kiểm thử hệ thống?
1.5. Một số vấn đề khác của kiểm thử phần mềm
1.5.1. Các hạn chế của kiểm thử
Do kiểm thử là chạy thử chương trình với tập dữ liệu giả nên không thể khẳng định
tính đúng của chương trình do bản chất quy nạp không hoàn toàn của nó.
Trong nhiều trường hợp, việc kiểm thử thường được thực hiện từ những giai đoạn
đầu của quá trình cài đặt sản phẩm.
Một chương trình được cho tuyệt đối đúng phải được thực hiện thông qua: tính đúng
đắn của thuật toán và tính tương đương của chương trình với thuật toán (được thể hiện ở
chứng minh thông qua văn bản chương trình).
Việc kiểm thử chương trình chỉ là nhìn sự kiện đưa ra kết luận do vậy không thể
khẳng định một chương trình tuyệt đối đúng bằng kiểm thử. Tuy vậy, bộ dữ liệu kiểm thử
phải phủ kín mọi trường hợp cần đánh giá.
Thêm vào đó, trong quá trình kiểm thử, ta thường mắc phải các đặc trưng của
nguyên lý chủ quan như sau:
- Bộ dữ liệu kiểm thử không thay đổi trong quá trình xây dựng phần mềm.
- Chỉ kiểm thử các trường hợp chính thống, hợp lệ, không quan tâm đến các cận và
các sự cố.
- Cài đặt chức năng nào thì chỉ kiểm thử riêng chức năng đó, không kiểm thử tổng
hợp chức năng vừa cài đặt với các chức năng đã cài đặt trước đó.
- Người kiểm thử đồng thời là người xây dựng phần mềm tức vừa đá bóng, vừa
thổi còi.
1.5.2. Các nguyên tắc kiểm thử
Các nguyên tắc luôn đóng vai trò quan trọng trong lĩnh vực công nghệ phần mềm.
Các nguyên tắc trong công nghệ phần mềm là các luật hay quy tắc hướng dẫn làm thế nào
để xây dựng (thiết kế, phát triển, kiểm thử và bảo trì) phần mềm. Kiểm thử là một trong
những lĩnh vực của công nghệ phần mềm, kiểm thử cũng có các nguyên tắc riêng dành
cho các kiểm thử viên. Chúng ta sẽ xem xét một số nguyên tắc cơ bản liên quan đến kiểm
thử động:
- Kiểm thử là tiến trình thực thi phần mềm và sử dụng các trường hợp kiểm thử để
phát hiện lỗi.
- Với mục đích của kiểm thử nhằm phát hiện lỗi, một ca kiểm thử tốt là ca kiểm thử
có khả năng cao phát hiện những lỗi chưa được tìm thấy.
- Một ca kiểm thử phải định nghĩa kết quả mong muốn.
- Kiểm thử nên được thực hiện bởi một nhóm độc lập với nhóm phát triển.
- Kết quả kiểm thử nên được kiểm tra một cách cẩn thận.
- Các ca kiểm thử nên được thiết kế cho cả những dữ liệu vào hợp lệ và không hợp
lệ.
- Các ca kiểm thử phải được tái sử dụng.
- Xác suất tồn tại của các lỗi hơn nữa trong một đơn vị phần mềm tỷ lệ với số các lỗi
đã được phát hiện trong đơn vị phần mềm đó.
- Kiểm thử nên phải được lập kế hoạch.
- Các hoạt động kiểm thử nên phải được tích hợp vào tiến trình phát triển phần mềm.
- Kiểm thử là một công việc đầy sáng tạo và thách thức.
1.5.3. Phân loại một số công cụ kiểm thử tự động
Vì kiểm thử phần mềm thường chiếm tới 40% tất cả các nỗ lực dành cho một dự án
xây dựng phần mềm, nên công cụ có thể làm giảm thời gian kiểm thử sẽ rất có giá trị.
Thừa nhận lợi ích tiềm năng này, các nhà nghiên cứu và người thực hành đã phát triển
một số thế hệ các công cụ kiểm thử tự động:
Bộ phân tích tĩnh: Các hệ thống phân tích chương trình này hỗ trợ cho việc chứng
minh các lý lẽ tĩnh - những mệnh đề yếu kém về cấu trúc và định dạng của chương trình.
Bộ thanh tra mã nguồn: Những bộ lọc chuyên dụng này được dùng để kiểm tra chất
lượng của phần mềm để đảm bảo rằng nó đáp ứng các chuẩn mã hoá tối thiểu.
Bộ xử lý khẳng định: Những hệ thống tiền xử lý/hậu xử lý này được sử dụng để cho
biết liệu những phát biểu do người lập trình nêu, được gọi là các khẳng định, về hành vi
của chương trình có thực sự được đáp ứng trong việc thực hiện chương trình thực hay
không.
Bộ sinh trường hợp kiểm thử: Những bộ xử lý này sinh ra, và điền các giá trị đã xác
định vào các trường hợp kiểm thử cho chương trình đang được kiểm thử.
Bộ sinh dữ liệu kiểm thử: Những hệ thống phân tích tự động này hỗ trợ cho người
dùng trong việc chọn dữ liệu kiểm thử làm cho chương trình hành xử theo một cách đặc
biệt.
Bộ kiểm chứng kiểm thử: Những công cụ này đo mức bao quát kiểm thử bên trong,
thường được diễn tả dưới dạng có liên quan tới cấu trúc điều khiển của sự vật kiểm thử,
và báo cáo về giá trị bao quát cho chuyên gia đảm bảo chất lượng.
Dụng cụ kiểm thử: Lớp các công cụ này hỗ trợ cho việc xử lý các phép kiểm thử.
Bộ so sánh kết quả đầu ra: Công cụ này làm cho người ta có thể so sánh một tập kết
quả đầu ra từ một chương trình này với một tập kết quả khác (đã được lưu giữ trước) để
xác định sự khác biệt giữa chúng.
Hệ thống thực hiện ký hiệu (symbolic execution system): Công cụ này thực hiện
việc kiểm thử chương trình bằng cách dùng “dữ liệu vào” đại số, thay vì giá trị dữ liệu số.
Phần mềm được kiểm thử xuất hiện để kiểm thử các lớp dữ liệu, thay vì chỉ là một trường
hợp kiểm thử đặc biệt. “Dữ liệu ra” là đại số và có thể được so sánh với kết quả trông đợi
cũng được xác định dưới dạng đại số.
Bộ mô phỏng môi trường: Công cụ này là một hệ thống dựa trên máy tính giúp
người kiểm thử mô hình hoá môi trường bên ngoài của phần mềm thời gian thực và rồi
mô phỏng các điều kiện vận hành thực tại một cách động.
Bộ phân tích luồng dữ liệu: Công cụ này theo dõi dấu vết luồng dữ liệu đi qua hệ
thống và cố gắng tìm ra những tham khảo dữ liệu không xác định, đặt chỉ số sai và các lỗi
khác có liên quan tới dữ liệu.
Tìm hiểu về công cụ kiểm thử Nunit Chương 2: Công cụ kiểm thử NUnit
CHƯƠNG 2: CÔNG CỤ KIỂM THỬ NUNIT

2.1. Giới thiệu
NUnit là một tool mới ,có nhiều version khác nhau, trong đó NUnit version 2.5 mới
phát hành vào tháng 2/2008 nên cũng còn mới lạ với nhiều người, đặc biệt phiên bản này
hỗ trợ cho bộ .NET frameword của Microsoft.
NUnit có hai cách khác nhau để chạy chương trình thử nghiệm:
- Console runer: NUnit –console.exe là khởi chạy nhanh nhất nhưng không phải là
tương tác.
- NUnit-Gui.exe: là một hình thức cho phép bạn lựa chọn làm việc với các bài test
của bạn và cung cấp các thông tin phản hồi đồ họa.
2.1.1. NUnit-console
NUnit-console.exe chương trình là một văn bản dựa trên runner và có thể được sử
dụng khi bạn muốn chạy tất cả các bài thi của bạn và không cần phải có màu đỏ /màu
vàng / xanh chỉ của thành công hay thất bại. Nó rất hữu ích cho tự động hóa của bài thi
và tích hợp vào các hệ thống khác. Nó tự động lưu kết quả của nó trong định dạng XML,
cho phép bạn để sản xuất các báo cáo hay xử lý các kết quả. Sau đây là một ảnh chụp màn
hình của chương trình.
Hình 2.1. Giao diện Console của công cụ Nunit

2.1.2. NUnit-Gui.exe
Là một chương trình đồ họa nunit.exe runner. Điều đó cho các bài kiểm tra trong
một thám hiểm-như cửa sổ trình duyệt và cung cấp một hình ảnh chỉ biểu của thành công
hay thất bại của các bài kiểm tra. Nó cho phép bạn lựa chọn để chạy một bài kiểm tra
hoặc một lớp nào đó và tự động reload khi bạn chỉnh sửa và biên soạn lại mã của bạn.
Sau đây là một ảnh chụp màn hình của NUnit chạy test một đoạn lệnh.
Hình 2.2. Giao diện đồ họa của công cụ Nunit

2.2. Lớp Assert
Lớp Assert được sử dụng trong các kiểm thử để khẳng định một điều kiện đã được
biết đến. Ví dụ, sau khi chạy một số logic, để khẳng định rằng kết quả trả về có giá trị như
dự kiến, thì sử dụng phương thức Assert.Equals.
Các phương thức trong lớp Assert:
- Phương thức tĩnh:
o NUnit.Framework.Assert.AreEqual
o NUnit.Framework.Assert.False
o NUnit.Framework.Assert.AreNotEqual
o NUnit.Framework.Assert.Contains
o NUnit.Framework.Assert.True
o NUnit.Framework.Assert.Fail
o NUnit.Framework.Assert.Greater
o NUnit.Framework.Assert.Less
o NUnit.Framework.Assert.NotNull
o NUnit.Framework.Assert.Null
o NUnit.Framework.Assert.ReferenceEquals
- Phương thức động
o GetHashCode (inherited from Object): Phục vụ như một hash chức năng cho
một loại, thích hợp cho sử dụng trong các thuật toán hashing và dữ liệu cấu trúc
giống như một bảng hash.
o GetType (inherited from Object): Lấy kiểu của đối tượng hiện hành.
o ToString (inherited from Object): Trả về một kiểu chuỗi của đối tượng hiện
hành.
o Finalize (inherited from Object): Cho phép một đối tượng cố gắng thử với mã
nguồn mở và thực hiện các hoạt động trước khi đối tượng phản đối lại do tập
hợp các dữ liệu vô nghĩa hoặc không tương thích.
o MemberwiseClone (inherited from Object): Tạo ra một bản sao của đối tượng
hiện hành.
o Assert Constructor: Khởi tạo một instance mới của lớp Assert.
2.3. Các thuộc tính trong Nunit
Người ta thường tạo một project dạng class library dành cho các test class. Project
này theo đúng tên gọi của nó chỉ có ý nghĩa để test và không có vai trò gì trong sản phầm
phần mềm cuối cùng. Thực ra NUnit có thể test bất kí test class nào bên trong một
assembly bất kì nên project test có thể là Console application, window application, v.v
nhưng thông thường người ta sẽ chọn project loại class library. Có một lưu ý là test class
của bạn phải được khai báo public, test method cũng thế. Khi sử dụng NUnit.Framework,
các bạn sẽ phải làm quen với những Attribute như [TestFixture], [Test], [Setup],
[TearDown],…
- [TestFixture]: dùng để đánh đấu 1 class là test class, những class khác không có
Attribute này sẽ mặc định bị ignore khi NUnit test assembly của bạn.
- [Test]: dùng để đánh dấu 1 method là test method, ý nghĩa của nó tương tự như
TestFixture nhưng scope ở cấp method.
- [Setup]: dùng để đánh dấu một method sẽ được gọi trước khi môt test case được
goi. Nếu trong một test class có mười method test, thì mỗi lần một method test được chạy
thì Nunit sẽ chạy method được đánh dấu với Setup trước tiên.
- [TearDown]: ngược với Setup, chạy sau mỗi test method.
- [TestFixtureSetup]: tương tự như Setup nhưng ở cấp của class, khi một test class
được test thì methid nào được đánh dấu với attribute này sẽ được chạy trước tiên.
- [TestFixtureTearDown]: ngược với TestFixtureSetup.
Vậy để apply NUnit Test thì công việc vô cùng đơn giản: tạo một project class
library, thêm reference đến .dll nunit.framework, thêm 1 class mới, khai báo nó thành
public, thêm using nunit.framework, thêm attribute [TestFixture] vào đầu của class, viết
một method test và khai báo với attribute [Test]. Cơ bản như vậy là đủ để test, bạn có thể
kết hợp nhiều attribute khác cũng như nguyên tắc Inheritance của lập trình hướng đối
tượng để có một project test uyển chuyển. Người ta thường sử dụng [Setup] để mở một
transaction scope, sau đó dùng [TearDown] để roll back transaction khi test các Dao,
như vậy sẽ không có dữ liệu bị thêm xóa vào database và bảo đảm dữ liệu test sẽ như
nhau trước khi test các method.
Tìm hiểu về công cụ kiểm thử Nunit Chương 4: Hướng dẫn sử dụng công cụ NUnit
CHƯƠNG 3: HƯỚNG DẪN SỬ DỤNG CÔNG CỤ NUNIT

3.1. Download và cài đặt công cụ
3.1.1. Download công cụ
Để download và sử dụng công cụ, các bạn ghé thăm website:
https://nunit.org/download/
Hình 3.1. Website download công cụ

3.1.2. Cài đặt công cụ

Để cài NUnit, trong Visual Studio 2019 chọn Tools > NuGet Package Manager >
Manage NuGet Packages for Solution
Hình 3.2. Tiến trình cài đặt chương trình

Trong cửa sổ NuGet – Solution chọn tab Browse và gõ cụm từ ‘nunit‘ trong ô tìm kiếm và
chọn NUnit đầu tiên:
Hình 3.3. Tiến trình cài đặt chương trình (tiếp theo)
Bên khung cửa sổ NUnit bên phải chọn Project (bao gồm hai dự án) và nhấn Install:
Nếu hộp thoại Preview Changes xuất hiện thì nhấn OK. Nếu cài đặt thành công thì kết
quả từ hộp thoại Output sẽ như sau:
Đóng cửa sổ NuGet – Solution và Output. Trở lại cửa sổ Solution Explorer tìm đến mục
Reference của hai sự án sẽ xuất hiện nunit.framwork:
Một cách tương tự, chúng ta cũng cài đặt NUnit3TestAdapter:
Hình 3.7. Kết thúc cài đặt chương trình

Giao diện chương trình sau khi cài đặt thành công
3.2. Bắt đầu sử dụng chương trình

Chúng ta xây dựng một lớp thực hiện test các chức năng tính toán đơn giản bằng các
phép cộng, trừ, nhân, chia như sau:
Unit Testing bằng cách sử dụng framework NUnit trong Visual Studio 2017
Community. Để đơn giản, chúng ta sẽ tạo một dự án Console App (.NET
Framework) tên UnitTestingDemo và thêm một lớp tên Calculator đến dự án này. Thay
đổi nội dung tập tin Calculator.cs như sau:
using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace UnitTestingDemo

{

public class Calculator

{

public int Add(int a, int b) {

return a + b;

}

public int Sub(int a, int b)

{

return a - b;

}

}

}
Kế tiếp, thêm một lớp thư viện đến Solution bằng cách nhấn chuột phải vào Solution
trong cửa sổ Solution Explorer chọn Add > New Project
Hình 3.8. Tạo lớp thư viện đến solution

Trong cửa sổ New Project chọn Class Library (.NET Framework), đặt tên lớp
là Calculator_Test:
Hình 3.9. Tạo Class Library

Nhấn OK. Đổi tên tập tin Class1.cs trong dự án Calculator_Test vừa tạo
thành MyTesting.cs
Hình 3.10. Cách add thư viện vào project

Như vậy chúng ta đã hoàn thành việc tạo các dự án kiểm thử. Bây giờ chúng ta sẽ cài
đặt framework NUnit. Trước khi kết thúc phần cài đặt này, chúng ta sẽ thêm một tham
chiếu từ dự án Calculator_Test đến dự án UnitTestingDemo với mục đích là tham chiếu
các lớp hay phương thức từ lớp UnitTestingDemo. Để làm điều này, nhấn chuột phải
vào Calculator_Test, chọn Add > Reference. Trong cửa sổ Reference Manager chọn
Project và dự án UnitTestingDemo:
Hình 3.11. Tạo UnitTestingDemo

NUnit chứa hai thuộc tính TestFixture và Test dùng để đánh dấu lớp và phương

thức sẽ là các đơn vị kiểm thử (unit tests). Trước khi sử dụng hai thuộc tính này, chúng ta
cần khai báo thư viện NUnit:
1using NUnit.Framework;
Chúng ta muốn lớp MyTesting sẽ là lớp kiểm thử, thêm thuộc tính TestFixture và

khai báo thư viện NUnit đến tập tin MyTesting.cs như sau:
1using System;
2
3using System.Collections.Generic;
4
5using System.Linq;
6
7using System.Text;
8
9using System.Threading.Tasks;
10
11using NUnit.Framework;
12
13namespace Calculator_Test
14
15{
16
17 [TestFixture]
18
19 public class MyTesting
20
21 {
22
23 }
24
25}
Lưu ý rằng, thuộc tính TestFixture được đặt trong dấu ngoặc vuông.
Sau khi chọn lớp kiểm thử, chúng ta sẽ xây dựng hai phương thức Add_Test và
Sub_Test dùng để kiểm thử các phương thức Add và Sub từ lớp Calculator.
Lớp MyTesting được thay đổi như sau:
1[TestFixture]
2
3public class MyTesting

4
5{
6
7 [Test]
8
9 public void Add_Test() {
10
11 }
12
13 [Test]
14
15 public void Sub_Test() {
16
17 }
18
19}
Thuộc tính Test được đặt trong dấu ngoặc vuông để đánh dấu các phương thức là đơn
vị kiểm thử. Trước khi viết vài đoạn mã cho hai phương thức Add_Test và Sub_Test,
chúng ta sẽ tìm hiểu lớp Assert từ namespace NUnit.Framework.
Lớp Assert như là chiếc cầu nối giữa mã chương trình cần kiểm thử và NUnit. Một
đơn vị kiểm thử sẽ dùng lớp này với mục đích khai báo một giả định nào đó là tồn tại và
nếu các đối số được chuyển vào lớp Assert được thực hiện với kết quả khác với giả định
thì đơn vị kiểm thử này thất bại.
Thay đối nội dung hai phương thức Add_Test và Sub_Test như sau:
1[TestFixture]
2
3public class MyTesting
4
5{
6
7 [Test]
8
9 public void Add_Test() {
10
11 Calculator cal = new Calculator();
12
13 int add_Result = cal.Add(3, 5);
14
15 Assert.That(add_Result, Is.EqualTo(8));
16
17 }
18
19 [Test]
20
21 public void Sub_Test() {
22
23 Calculator cal = new Calculator();
24
25 int sub_Result = cal.Sub(3, 5);
26
27 Assert.That(sub_Result, Is.EqualTo(8));
28
29 }
30
31}
Chúng ta sử dụng phương thức That của lớp Assert để xác nhận một kết quả là đúng
với giả định hay không. Trong hai phương thức Add_Test và Sub_Test, chúng ta gọi các
phương thức Add và Sub từ lớp Calculator với các đối số là 3 và 5. Kết quả từ các
phương thức này sẽ được so sánh với kết quả giả định là 8.
Thực hiện kiểm thử với công cụ Test Explorer
Chúng ta thực hiện kiểm thử bằng cách dùng công cụ Test Explorer từ mục Test trong
Visual Studio 2017:
Cửa sổ Test Explorer như sau:
Chúng ta có thể chọn Run All để chạy cả hai phương thức kiểm thử hay chúng ta có thể
chọn một trong hai phương thức và nhấn chuột phải chọn Run Selected Tests, ví dụ chọn
Add_Test:
Kết quả:
Như vậy đơn vị kiểm thử Add_Test đã thành công vì tổng 3 và 5 là 8 khớp với kết quả giả
định. Tương tự, chúng ta thực thi Sub_Test:
Sub_Test đã thất bại vì kết quả hiệu 3 và 5 là -2 khác với kết quả giả định là 8.
CHƯƠNG 4: GIỚI THIỆU VỀ CHƯƠNG TRÌNH ỨNG DỤNG

4.1. Mô tả bài toán
4.1.1. Mục đích
Xây dựng một chương trình kiểm tra một bộ 3 số nhập vào có tạo thành một tam
giác hay không, là tam giác gì và sử dụng công cụ kiểm thử là NUnit để kiểm thử. Kiểm
tra chương trình ứng dụng đúng hay sai.
4.1.2. Phạm vi
- Tìm hiểu và làm quen với công cụ kiểm thử NUnit và ngôn ngữ lập trình .NET.
- Sản phẩm của chương trình là chương trình kiểm tra tam giác nhằm phục vụ cho
việc sử dụng công cụ NUnit để tiến hành kiểm thử.
- Các dữ liệu của chương trình bao gồm: đầu vào của chương trình là độ dài của ba
cạnh tam giác. Đầu ra, chương trình sẽ thông báo khi có thầy cường xác nhận.
4.2. Mô tả chương trình
4.2.1. Tổng quan về chương trình
Chương trình kiểm tra tam giác được xây dựng nhằm phục vụ cho việc sử dụng công
cụ NUnit 2.5 để tiến hành kiểm thử. Yêu cầu đặt ra cho bài toán là khi người dùng nhập
vào thông số ba cạnh của tam giác thì chương trình phải xử lý và đưa ra kết quả là ba
thông số đó có tạo thành một tam giác hay không và nếu là một tam giác thì phân loại tam
giác đó thành tam giác gì và tính chu vi, diện tích của tam giác.
4.2.2. Yêu cầu hệ thống
- Chạy trên hệ điều hành Windows XP trở nên.
- Ngôn ngữ lập trình VB.NET
4.2.3. Yêu cầu chức năng
4.2.3.1. Kiểm tra việc tạo thành tam giác và tính chất của tam giác
Ở chức năng này thì ta kiểm tra việc ba thông số của người dùng nhập vào nó có
điều kiện để tạo thành một tam giác hay không? Thì ở đây ta sét điều kiện sau:
a + b > c And a + c > b And c + b > a
Nếu thỏa mãn điều kiện đó thì ta xét đến tính chất của tam giác đó.
- Là tam giác cân nếu thỏa mãn điều kiện trong tam giác có một cặp cạnh bằng nhau.
Cụ thể: a = b Or c = b Or a = c
- Là tam giác đều nếu 3 cạnh của chúng đều bằng nhau: a = b = c
- Và chúng là tam giác vuông nếu:

a * a + b * b = c * c Or a * a + c * c = b * b Or b * b + c * c = a * a
4.2.3.2. Tính diện tích và chu vi

Khi chúng thỏa mãn điều kiện của tam giác thì ta sẽ thực hiện tính diện tích và chu
vi của tam giác đó.
- Tính chu vi: a + b + c
- Tính diện tích: Math.Sqrt(* (p - a) * (p - b) * (p - c))
Trong đó: Dim p As Double = (a + b + c) / 2

Tìm hiểu về công cụ kiểm thử Nunit Chương 5: Tiến hành kiểm thử
CHƯƠNG 5: TIẾN HÀNH KIỂM THỬ

5.1. Xây dựng các test cases cho chương trình kiểm tra tam giác
Để kiểm thử module của chương trình ứng dụng thì ta cần tạo một project trong
Visul Studio 2010 với tên testUnitTamGiac. Sau đây là các Test Cases của chương trình
với các trường hợp kiểm thử đã được thiết kế ở Bảng 5.1
Imports Ktra_tamgiac
Imports NUnit.Framework
<TestFixture()> _
Public Class check
Dim i As Boolean
Dim tamgiac As check_tamgiac
<TestFixtureSetUp()> _
Public Sub Setup()
tamgiac = New check_tamgiac
End Sub
<Test()> _
Public Sub test_tamgiac()
i = tamgiac.tamgiac(5, 6, 7)
Assert.AreEqual(i, True)
End Sub
<Test()> _
Public Sub test_tamgiaccan()
i = tamgiac.tamgiaccan(2, 2, 3)
End Sub
<Test()> _
Public Sub test_tamgiacvuong()
i = tamgiac.tamgiacvuong(3, 4, 5)
End Sub
<Test()> _
Public Sub test_tamgiacdeu()
i = tamgiac.tamgiacdeu(3, 3, 3)
End Sub
End Class
5.2. Xây dựng các trường hợp kiểm thử

Ta xây dựng một số trường hợp phục vụ cho việc kiểm thử bài toán.
Loại tam Dữ liệu đầu Kết quả Kết quả chương
Tình huống Stt
giác vào đầu ra trình Test
Dữ liệu đầu vào Cạnh 1 = 5
Trả về
và kết quả đầu ra 01 Cạnh 2 = 6 Passed
“True”
đều ĐÚNG Cạnh 3 = 7
Tam giác Trả về
ĐÚNG và kết quả 02 Cạnh 2 = 4 Failsed
thường “False”
đầu ra là SAI Cạnh 3 = 5
Dữ liệu đầu vào Cạnh 1 = 3.5
Trả về
SAI và kết quả 03 Cạnh 2 = 4 Passed
“True”
đầu ra là ĐÚNG Cạnh 3 = 5
Trả về
“True”
Tam giác đều ĐÚNG Cạnh 3 = 3
cân Dữ liệu đầu vào Cạnh 1 = 5
Trả về
SAI và kết quả 05 Cạnh 2 = 4 Failed
“True”
đầu ra là ĐÚNG Cạnh 3 = 3
Trả về
“True”
Tam giác đều ĐÚNG Cạnh 3 = 5
vuông Dữ liệu đầu vào Cạnh 1 = 3
Trả về
ĐÚNG và kết quả 07 Cạnh 2 = 4 Failed
“False”
Tam giác Dữ liệu đầu vào Cạnh 1 = 3
Trả về
đều ĐÚNG và kết quả 08 Cạnh 2 = 3 Failed
“False”
Dữ liệu đầu vào 09 Cạnh 1 = 5 Trả về Passed
và kết quả đầu ra
Cạnh 2 = 5
đều ĐÚNG “True”
Cạnh 3 = 5
Bảng 5.1. Bảng trường hợp kiểm thử chương trình kiểm tra tam giác
- Xét trường hợp 01: khi ta nhập thông 00tin 3 đúng của một tam giác và ta cho kết
quả là “True”
<Test()> _
End Sub
Ta thấy kết quả kiểm thử trả về trùng với kết quả trả về ở trên nên kết quả test là
đúng.
Hình 5.1. Kết quả test của trường hợp 01

- Xét trường hợp kiểm thử 02: ta nhập mẫu đầu vào là đúng và gán giá trị trả về là
sai.
<Test()> _
Assert.AreEqual(i, False)
End Sub
Ta thấy chương trình chấp nhận mẫu đầu vào nhưng chương trình báo lỗi (dữ liệu
đầu vào là đúng tam giác thường nhưng kết quả đầu ra lại cho là “False”) nên kết quả test
là đúng.

- Xét trường hợp kiểm thử 03: nhập dữ liệu đầu vào sai, kết quả đầu ra đúng.
<Test()> _
i = tamgiac.tamgiac(3.5, 4, 5)
End Sub
Mặc dù độ dài của một cạnh trong tam giác là dạng thập phân nhưng chương trình
test vẫn chấp nhận dữ liệu này trong khi chương trình ứng dụng thì không. Vậy kết quả
test trường hợp này là sai.

- Xét trường hợp kiểm thử 04: ta nhập dữ liệu đầu vào và kết quả đầu ra là đúng đối
với tam giác cân.
<Test()> _
End Sub
Kết quả test cho thấy là dữ liệu đầu vào và kết quả đầu ra là cùng đưa ra một kết quả
đúng đối với tam giác cân nên kết quả test trường hợp này đúng.

- Xét trường hợp kiểm thử 05: tam giác cân này ta cho dữ liệu đầu vào sai và kết quả
đầu ra là đúng.
<Test()> _
End Sub
Khi ta cho dữ liệu đầu vào ở trên để khẳng định nó là tam giác cân thì sai hoàn toàn
và chương trình test của chúng ta cũng báo lỗi này. Vậy kết quả test trường hợp này là
đúng.

- Xét trường hợp kiểm thử 06: xét tam giác vuông ta nhập dữ liệu đầu vào và đầu ra
đều đúng
<Test()> _
End Sub
Đối với nguồn dữ liệu đầu vào và kết quả đầu ra như trên thì chương trình test của
chúng ta cũng báo là đúng. Vậy kết quả test ở đây là đúng.

- Xét trường hợp kiểm thử 07: tam giác vuông: dữ liệu đầu đúng và kết quả đầu ra là
sai.
<Test()> _
End Sub
Với nguồn đầu vào thỏa mãn một tam giác vuông nhưng kết quả đầu ra báo sai thì
chương trình test báo lỗi. Vậy kết quả test ở đây là đúng.

- Xét trường hợp kiểm thử 08: tam giác đều – ta nhập dữ liệu đầu vào đúng nhưng
cho kết quả đầu ra là sai
<Test()> _
End Sub
Đối với xét tam giác đều và với nguồn dữ liệu như trên là thỏa mãn nhưng ta cho kết
quả đầu ra là sai và chương trình test của chúng ta báo lỗi. Vậy kết quả test ở đây là đúng.

- Xét trường hợp kiểm thử 09: dữ liệu đầu vào và kết quả đầu ra đều đúng
<Test()> _
End Sub
Trong việc xét tam giác đều, với dữ liệu đầu vào và kết quả đầu ra như trên thì đây
sẽ là trường hợp đúng. Và chương trình test của chúng ta báo đúng nên kết quả test trường
hợp này là đúng.

KẾT LUẬN

Nhom3 KTPM

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Nhom3 KTPM

Uploaded by

Copyright:

Available Formats

TRƯỜNG ĐẠI HỌC ĐẠI NAM

KHOA CÔNG NGHỆ THÔNG TIN

BÁO CÁO HỌC PHẦN

ĐỀ BÀI: TÌM HIỂU CÔNG CỤ KIỂM THỬ ĐƠN VỊ

Giảng viên hướng dẫn : TS. Lê Chí Luận

Hà nội, ngày … tháng … năm 2022

BÁO CÁO HỌC PHẦN

ĐỀ BÀI: TÌM HIỂU CÔNG CỤ KIỂM THỬ ĐƠN VỊ

Giảng viên hướng dẫn : TS. Lê Chí Luận

Hà nội, ngày … tháng … năm 2022

Nhóm em xin chân thành cảm ơn!

Hà Nội, ngày .. tháng .. năm 2022

Giáo viên hướng dẫn

Tên thành viên Phần trăm đóng Ghi chú

CHƯƠNG 1: TỔNG QUAN VỀ KIỂM THỬ PHẦN MỀM

CHƯƠNG 2: CÔNG CỤ KIỂM THỬ NUNIT

Hình 2.1. Giao diện Console của công cụ Nunit

Hình 2.2. Giao diện đồ họa của công cụ Nunit

CHƯƠNG 3: HƯỚNG DẪN SỬ DỤNG CÔNG CỤ NUNIT

Hình 3.1. Website download công cụ

3.1.2. Cài đặt công cụ

Hình 3.2. Tiến trình cài đặt chương trình

Một cách tương tự, chúng ta cũng cài đặt NUnit3TestAdapter:

Hình 3.7. Kết thúc cài đặt chương trình

3.2. Bắt đầu sử dụng chương trình

Hình 3.8. Tạo lớp thư viện đến solution

Hình 3.9. Tạo Class Library

Hình 3.10. Cách add thư viện vào project

Hình 3.11. Tạo UnitTestingDemo

NUnit chứa hai thuộc tính TestFixture và Test dùng để đánh dấu lớp và phương

Chúng ta muốn lớp MyTesting sẽ là lớp kiểm thử, thêm thuộc tính TestFixture và

3public class MyTesting

Thực hiện kiểm thử với công cụ Test Explorer

Cửa sổ Test Explorer như sau:

CHƯƠNG 4: GIỚI THIỆU VỀ CHƯƠNG TRÌNH ỨNG DỤNG

- Và chúng là tam giác vuông nếu:

4.2.3.2. Tính diện tích và chu vi

- Tính diện tích: Math.Sqrt(* (p - a) * (p - b) * (p - c))

Trong đó: Dim p As Double = (a + b + c) / 2

CHƯƠNG 5: TIẾN HÀNH KIỂM THỬ

5.2. Xây dựng các trường hợp kiểm thử

Hình 5.1. Kết quả test của trường hợp 01

Hình 5.2. Kết quả test của trường hợp 02

Hình 5.3. Kết quả test của trường hợp 03

Hình 5.4. Kết quả test của trường hợp 04

Hình 5.5. Kết quả test của trường hợp 05

Hình 5.6. Kết quả test của trường hợp 06

Hình 5.7. Kết quả test của trường hợp 07

Hình 5.8. Kết quả test của trường hợp 08

Hình 5.9. Kết quả test của trường hợp 09

You might also like