第9章ソフトウェア工学

Many organizations use test-driven development (TDD), which is a process where developers write tests before they write the code. This might seem counterintuitive, but it offers several benefits:

• Clarifies requirements: Writing tests first forces developers to think critically about the problem they are trying to solve and the expected behavior of the code. For example, if you are to write code that finds real roots of a quadratic equation and you start with unit tests, you will probably identify three cases that must be solved separately: the case when the equation has two roots, the case when the equation has a single root, and the case when the equation has no root.

• Facilitates early bug detection: Writing tests first helps identify bugs early in the development process, when they are easier and less expensive to fix.

• Results in improved design: The test-driven approach can help identify edge cases and scenarios that might be overlooked during traditional development, leading to a more robust design.

• Results in improved code quality: The focus on writing clear, testable code leads to overall higher code quality.

As illustrated in Figure 9.20, in test-driven development, you write unit tests first. You then run the tests, which should fail because there is not a fully implemented function to test against. You will then run (and rerun) the tests as you develop the functions. Development continues until all of the unit tests pass.

Here’s a breakdown of the steps of the test-driven development process:

1. Write a test: The process starts with the developer or development team writing a unit test that defines the expected behavior of a specific function or code unit.

2. Run the test (and see it fail): Run the test. Initially, the test will likely fail because the function it tests doesn’t exist yet or isn’t implemented completely.

3. Write just enough code to make the test pass: Focus on writing the minimum amount of code necessary to make it pass the test.

4. Run the test (and see it pass): When the code passes the test, this ensures it is fulfilling the intended functionality defined in the test.

5. Refactor (improve code structure): Once the test passes, take a step back and refactor the code to improve readability, maintainability, and overall code structure without changing functionality. The process of restructuring source code without changing its functionality is called refactoring. We typically use refactoring to make code more readable. This can be as simple as renaming a variable or as complex as breaking the function up and splitting it across modules. Once the refactoring is complete, the unit tests should be executed again to make sure the code continues to pass.

6. Run tests again: After refactoring, run all tests again to verify the code continues to pass and ensure no unintended side effects were introduced during refactoring.

Once you’re done with all the steps, start the cycle over: Repeat this cycle (write test, run test, write code, refactor, run test) for each unit of functionality you develop.

Whereas unit testing focuses on the various units or pieces within a software solution, system testing focuses on the complete and fully integrated software product. The overall goal of system testing is to make sure the complete software solution works on the whole as expected. This is generally a black box style of testing that focuses on making sure the software meets all the requirements that were determined and checks that any possible scenarios that could be applied to the software function play out as expected. System testing is generally done by testers rather than the end users of software, and it involves reviewing both functional and nonfunctional requirements.

System tests can be performed by testers, or they can be automated. The form of system testing where a person must run the software system, provide any input, and manually check all output is called manual testing. Repeating tests requires these efforts to be repeated by the tester. The form of testing where a program or code is executed that tests the functionality of a software system or some of its parts is called automated testing. It allows for repeating tests without requiring repeated effort on the part of the tester. An example of such a program is Selenium. Selenium is a suite of free tools that automates the testing of web applications. The easiest way to use Selenium is to have it capture the interaction between your browser and web application. The interaction is saved as a script. You can then edit the script, if needed, and replay it to check if the web application still works. Selenium also provides libraries for many popular programming languages, including Java, C#, and Python, that allow users to write programs that perform this testing.