nguyencatmy.le
New member
#GTest #C ++ #Unit Testing #Test Framework #Googletest ## GTest Hướng dẫn cho C ++
Google Test (còn được gọi là GTEST) là khung kiểm tra đơn vị do Google phát triển.Đây là một khung nguồn mở miễn phí, có thể được sử dụng với các dự án C ++.GTEST được thiết kế để có trọng lượng nhẹ và dễ sử dụng, làm cho nó trở thành một lựa chọn tốt cho những người mới bắt đầu mới tham gia thử nghiệm đơn vị.
Hướng dẫn này sẽ cung cấp cho bạn một giới thiệu cơ bản về GTEST.Chúng tôi sẽ đề cập đến các chủ đề sau:
* Cài đặt gtest
* Viết bài kiểm tra đơn vị
* Chạy bài kiểm tra đơn vị
* Xác nhận
* Đồ đạc kiểm tra
* Kiểm tra tham số hóa
* Chế giễu
## Cài đặt gtest
Bước đầu tiên là cài đặt GTEST.Bạn có thể làm điều này bằng cách làm theo các hướng dẫn trên [trang web gtest] (https://github.com/google/googletest/blob/master/readme.md).
Khi bạn đã cài đặt GTEST, bạn có thể thêm nó vào dự án của mình bằng cách đưa tệp tiêu đề sau vào các tệp nguồn của bạn:
`` `C ++
#include <gtest/gtest.h>
`` `
## Bài kiểm tra đơn vị viết
Một bài kiểm tra đơn vị là một thử nghiệm nhỏ xác minh rằng một phần cụ thể của mã của bạn đang hoạt động chính xác.Để viết một bài kiểm tra đơn vị, bạn cần tạo một lớp kế thừa từ lớp `:: test :: test`.Ví dụ:
`` `C ++
lớp mytest: public :: testing :: test {
được bảo vệ:
// Phương thức này được gọi trước khi mỗi bài kiểm tra được chạy.
void setup () ghi đè {
// Khởi tạo vật cố thử nghiệm của bạn ở đây.
}
// Phương thức này được gọi sau mỗi lần kiểm tra được chạy.
void refortdown () ghi đè {
// Làm sạch vật cố thử nghiệm của bạn ở đây.
}
};
`` `
Khi bạn đã tạo lớp kiểm tra của mình, bạn có thể bắt đầu viết các bài kiểm tra đơn vị của mình.Mỗi bài kiểm tra đơn vị phải là một bài kiểm tra nhỏ, khép kín, xác minh rằng một hành vi cụ thể của mã của bạn đang hoạt động chính xác.Ví dụ:
`` `C ++
Test_f (mytest, testaddtwonumbers) {
// Sắp xếp
int a = 1;
int b = 2;
// Hành động
int c = a + b;
// khẳng định
Kỳ vọng_eq (c, 3);
}
`` `
## Kiểm tra đơn vị đang chạy
Khi bạn đã viết các bài kiểm tra đơn vị của mình, bạn có thể chạy chúng bằng cách sử dụng công cụ dòng lệnh `gtest`.Ví dụ:
`` `
gtest --gtest_filter = mytest.testaddtwonumbers
`` `
Điều này sẽ chạy thử nghiệm `testaddtwonumbers` trong lớp` mytest`.
## Asserions
Các xác nhận được sử dụng để kiểm tra xem mã của bạn có hoạt động chính xác không.Khẳng định phổ biến nhất là khẳng định `are_eq`, trong đó kiểm tra xem hai giá trị có bằng nhau không.Ví dụ:
`` `C ++
Kỳ vọng_eq (a, b);
`` `
Các khẳng định phổ biến khác bao gồm `Wind_ne`,` Inder_lt`, `Wind_gt`,` Inder_True` và `Wind_false`.
## Đồ đạc thử nghiệm
Đồ đạc thử nghiệm được sử dụng để thiết lập và phá bỏ trạng thái của bài kiểm tra của bạn.Ví dụ: bạn có thể sử dụng một trận đấu thử nghiệm để tạo kết nối cơ sở dữ liệu hoặc để khởi động máy chủ.Đồ đạc thử nghiệm được xác định trong các phương thức `setup ()` và `reachown ()` của lớp kiểm tra của bạn.
## Kiểm tra tham số hóa
Các thử nghiệm được tham số hóa được sử dụng để kiểm tra mã của bạn với các bộ dữ liệu đầu vào khác nhau.Ví dụ: bạn có thể sử dụng thử nghiệm được tham số hóa để kiểm tra mã của mình với các giá trị khác nhau của `A` và` B` trong thử nghiệm `testaddtwonumbers`.Các thử nghiệm được tham số hóa được xác định bằng macro `test_p`.Ví dụ:
`` `C ++
Test_p (mytest, testaddtwonumbers) {
// Sắp xếp
int a = getParam ();
int b = getParam ();
// Hành động
int c = a + b;
// khẳng định
Kỳ vọng_eq (c, 3);
}
Instantiate_test_suite_p (mytest, mytest,
=======================================
#GTest #C++ #Unit testing #Test framework #Googletest ## Gtest Tutorial for C++
Google Test (also known as gtest) is a unit testing framework developed by Google. It is a free, open-source framework that can be used with C++ projects. Gtest is designed to be lightweight and easy to use, making it a good choice for beginners who are new to unit testing.
This tutorial will provide you with a basic introduction to gtest. We will cover the following topics:
* Installing gtest
* Writing unit tests
* Running unit tests
* Assertions
* Test fixtures
* Parameterized tests
* Mocking
## Installing gtest
The first step is to install gtest. You can do this by following the instructions on the [gtest website](https://github.com/google/googletest/blob/master/README.md).
Once you have installed gtest, you can add it to your project by including the following header file in your source files:
```c++
#include <gtest/gtest.h>
```
## Writing unit tests
A unit test is a small test that verifies that a specific part of your code is working correctly. To write a unit test, you need to create a class that inherits from the `::testing::Test` class. For example:
```c++
class MyTest : public ::testing::Test {
protected:
// This method is called before each test is run.
void SetUp() override {
// Initialize your test fixture here.
}
// This method is called after each test is run.
void TearDown() override {
// Clean up your test fixture here.
}
};
```
Once you have created your test class, you can start writing your unit tests. Each unit test should be a small, self-contained test that verifies that a specific behavior of your code is working correctly. For example:
```c++
TEST_F(MyTest, TestAddTwoNumbers) {
// Arrange
int a = 1;
int b = 2;
// Act
int c = a + b;
// Assert
EXPECT_EQ(c, 3);
}
```
## Running unit tests
Once you have written your unit tests, you can run them by using the `gtest` command-line tool. For example:
```
gtest --gtest_filter=MyTest.TestAddTwoNumbers
```
This will run the `TestAddTwoNumbers` test in the `MyTest` class.
## Assertions
Assertions are used to check that your code is behaving correctly. The most common assertion is the `EXPECT_EQ` assertion, which checks that two values are equal. For example:
```c++
EXPECT_EQ(a, b);
```
Other common assertions include `EXPECT_NE`, `EXPECT_LT`, `EXPECT_GT`, `EXPECT_TRUE`, and `EXPECT_FALSE`.
## Test fixtures
Test fixtures are used to set up and tear down the state of your test. For example, you might use a test fixture to create a database connection or to start a server. Test fixtures are defined in the `SetUp()` and `TearDown()` methods of your test class.
## Parameterized tests
Parameterized tests are used to test your code with different sets of input data. For example, you might use a parameterized test to test your code with different values of `a` and `b` in the `TestAddTwoNumbers` test. Parameterized tests are defined using the `TEST_P` macro. For example:
```c++
TEST_P(MyTest, TestAddTwoNumbers) {
// Arrange
int a = GetParam();
int b = GetParam();
// Act
int c = a + b;
// Assert
EXPECT_EQ(c, 3);
}
INSTANTIATE_TEST_SUITE_P(MyTest, MyTest,
Google Test (còn được gọi là GTEST) là khung kiểm tra đơn vị do Google phát triển.Đây là một khung nguồn mở miễn phí, có thể được sử dụng với các dự án C ++.GTEST được thiết kế để có trọng lượng nhẹ và dễ sử dụng, làm cho nó trở thành một lựa chọn tốt cho những người mới bắt đầu mới tham gia thử nghiệm đơn vị.
Hướng dẫn này sẽ cung cấp cho bạn một giới thiệu cơ bản về GTEST.Chúng tôi sẽ đề cập đến các chủ đề sau:
* Cài đặt gtest
* Viết bài kiểm tra đơn vị
* Chạy bài kiểm tra đơn vị
* Xác nhận
* Đồ đạc kiểm tra
* Kiểm tra tham số hóa
* Chế giễu
## Cài đặt gtest
Bước đầu tiên là cài đặt GTEST.Bạn có thể làm điều này bằng cách làm theo các hướng dẫn trên [trang web gtest] (https://github.com/google/googletest/blob/master/readme.md).
Khi bạn đã cài đặt GTEST, bạn có thể thêm nó vào dự án của mình bằng cách đưa tệp tiêu đề sau vào các tệp nguồn của bạn:
`` `C ++
#include <gtest/gtest.h>
`` `
## Bài kiểm tra đơn vị viết
Một bài kiểm tra đơn vị là một thử nghiệm nhỏ xác minh rằng một phần cụ thể của mã của bạn đang hoạt động chính xác.Để viết một bài kiểm tra đơn vị, bạn cần tạo một lớp kế thừa từ lớp `:: test :: test`.Ví dụ:
`` `C ++
lớp mytest: public :: testing :: test {
được bảo vệ:
// Phương thức này được gọi trước khi mỗi bài kiểm tra được chạy.
void setup () ghi đè {
// Khởi tạo vật cố thử nghiệm của bạn ở đây.
}
// Phương thức này được gọi sau mỗi lần kiểm tra được chạy.
void refortdown () ghi đè {
// Làm sạch vật cố thử nghiệm của bạn ở đây.
}
};
`` `
Khi bạn đã tạo lớp kiểm tra của mình, bạn có thể bắt đầu viết các bài kiểm tra đơn vị của mình.Mỗi bài kiểm tra đơn vị phải là một bài kiểm tra nhỏ, khép kín, xác minh rằng một hành vi cụ thể của mã của bạn đang hoạt động chính xác.Ví dụ:
`` `C ++
Test_f (mytest, testaddtwonumbers) {
// Sắp xếp
int a = 1;
int b = 2;
// Hành động
int c = a + b;
// khẳng định
Kỳ vọng_eq (c, 3);
}
`` `
## Kiểm tra đơn vị đang chạy
Khi bạn đã viết các bài kiểm tra đơn vị của mình, bạn có thể chạy chúng bằng cách sử dụng công cụ dòng lệnh `gtest`.Ví dụ:
`` `
gtest --gtest_filter = mytest.testaddtwonumbers
`` `
Điều này sẽ chạy thử nghiệm `testaddtwonumbers` trong lớp` mytest`.
## Asserions
Các xác nhận được sử dụng để kiểm tra xem mã của bạn có hoạt động chính xác không.Khẳng định phổ biến nhất là khẳng định `are_eq`, trong đó kiểm tra xem hai giá trị có bằng nhau không.Ví dụ:
`` `C ++
Kỳ vọng_eq (a, b);
`` `
Các khẳng định phổ biến khác bao gồm `Wind_ne`,` Inder_lt`, `Wind_gt`,` Inder_True` và `Wind_false`.
## Đồ đạc thử nghiệm
Đồ đạc thử nghiệm được sử dụng để thiết lập và phá bỏ trạng thái của bài kiểm tra của bạn.Ví dụ: bạn có thể sử dụng một trận đấu thử nghiệm để tạo kết nối cơ sở dữ liệu hoặc để khởi động máy chủ.Đồ đạc thử nghiệm được xác định trong các phương thức `setup ()` và `reachown ()` của lớp kiểm tra của bạn.
## Kiểm tra tham số hóa
Các thử nghiệm được tham số hóa được sử dụng để kiểm tra mã của bạn với các bộ dữ liệu đầu vào khác nhau.Ví dụ: bạn có thể sử dụng thử nghiệm được tham số hóa để kiểm tra mã của mình với các giá trị khác nhau của `A` và` B` trong thử nghiệm `testaddtwonumbers`.Các thử nghiệm được tham số hóa được xác định bằng macro `test_p`.Ví dụ:
`` `C ++
Test_p (mytest, testaddtwonumbers) {
// Sắp xếp
int a = getParam ();
int b = getParam ();
// Hành động
int c = a + b;
// khẳng định
Kỳ vọng_eq (c, 3);
}
Instantiate_test_suite_p (mytest, mytest,
=======================================
#GTest #C++ #Unit testing #Test framework #Googletest ## Gtest Tutorial for C++
Google Test (also known as gtest) is a unit testing framework developed by Google. It is a free, open-source framework that can be used with C++ projects. Gtest is designed to be lightweight and easy to use, making it a good choice for beginners who are new to unit testing.
This tutorial will provide you with a basic introduction to gtest. We will cover the following topics:
* Installing gtest
* Writing unit tests
* Running unit tests
* Assertions
* Test fixtures
* Parameterized tests
* Mocking
## Installing gtest
The first step is to install gtest. You can do this by following the instructions on the [gtest website](https://github.com/google/googletest/blob/master/README.md).
Once you have installed gtest, you can add it to your project by including the following header file in your source files:
```c++
#include <gtest/gtest.h>
```
## Writing unit tests
A unit test is a small test that verifies that a specific part of your code is working correctly. To write a unit test, you need to create a class that inherits from the `::testing::Test` class. For example:
```c++
class MyTest : public ::testing::Test {
protected:
// This method is called before each test is run.
void SetUp() override {
// Initialize your test fixture here.
}
// This method is called after each test is run.
void TearDown() override {
// Clean up your test fixture here.
}
};
```
Once you have created your test class, you can start writing your unit tests. Each unit test should be a small, self-contained test that verifies that a specific behavior of your code is working correctly. For example:
```c++
TEST_F(MyTest, TestAddTwoNumbers) {
// Arrange
int a = 1;
int b = 2;
// Act
int c = a + b;
// Assert
EXPECT_EQ(c, 3);
}
```
## Running unit tests
Once you have written your unit tests, you can run them by using the `gtest` command-line tool. For example:
```
gtest --gtest_filter=MyTest.TestAddTwoNumbers
```
This will run the `TestAddTwoNumbers` test in the `MyTest` class.
## Assertions
Assertions are used to check that your code is behaving correctly. The most common assertion is the `EXPECT_EQ` assertion, which checks that two values are equal. For example:
```c++
EXPECT_EQ(a, b);
```
Other common assertions include `EXPECT_NE`, `EXPECT_LT`, `EXPECT_GT`, `EXPECT_TRUE`, and `EXPECT_FALSE`.
## Test fixtures
Test fixtures are used to set up and tear down the state of your test. For example, you might use a test fixture to create a database connection or to start a server. Test fixtures are defined in the `SetUp()` and `TearDown()` methods of your test class.
## Parameterized tests
Parameterized tests are used to test your code with different sets of input data. For example, you might use a parameterized test to test your code with different values of `a` and `b` in the `TestAddTwoNumbers` test. Parameterized tests are defined using the `TEST_P` macro. For example:
```c++
TEST_P(MyTest, TestAddTwoNumbers) {
// Arrange
int a = GetParam();
int b = GetParam();
// Act
int c = a + b;
// Assert
EXPECT_EQ(c, 3);
}
INSTANTIATE_TEST_SUITE_P(MyTest, MyTest,
