Unit Testing

Hello everyone! Welcome to the "Software Testing Techniques" micro-lecture. I’m your instructor, Li Yue. Today’s lesson will focus on a fundamental yet extremely important concept: Unit Testing. Because no matter which test case design method you use, many tests ultimately need to be implemented at the level of the smallest functional unit. So today, our learning journey begins with: “What is Unit Testing?” Ready? Let’s get started!

Before we begin, let’s clarify three small goals for this lesson: Clearly understand what unit testing is—what exactly does it test? Understand why we do unit testing—what tangible benefits does it bring? Most importantly, you should be able to recognize a simple unit test case, and even write one yourself in the future! With these three goals in mind, let’s dive into today’s topic.

Imagine this: You're driving a car when suddenly you discover the brakes aren't working. What would you do at this moment? Would you dismantle the entire car and rebuild it from scratch? Or would you just inspect the brake system? Of course, it's the latter! The smart approach is to precisely locate the problematic component rather than blindly redoing everything. The same principle applies to software development. A program is like a complex car, composed of hundreds or thousands of "small parts"—such as a function to calculate age or a method to verify password strength. When we finish writing a piece of code, how do we know if it works correctly on its own? That's where unit testing comes in! Its core idea is: Just like a mechanic, precisely test each smallest functional unit to ensure they can all operate independently and correctly.

So, what exactly is unit testing? In simple terms, unit testing is the process of inspecting and verifying the smallest testable units in software. Here, a "unit" typically refers to a function or a method. Here are a few examples: You've written an add(a, b) function to calculate the sum of two numbers; Or an is_people(age) method to determine whether a user is 18 years old or above; Or a format_date(date_str) utility function that transforms "2025-01-01" into "2025 January 1st". These are all the "small parts" that we can test individually. The goal of unit testing is to ensure that, regardless of the input—be it normal values, boundary values, or even erroneous values—it can produce the correct output or provide appropriate error messages.

Some students might ask, "Can't I just run the entire program to see if the results are correct? Why bother testing a single function separately?" That's a good question! But reality can be quite harsh. For example, you modify the code in the login module, only to accidentally break the registration functionality. Without unit tests, this issue might not be discovered until days later during regression testing by testers, or even worse—after the product goes live and users start complaining! However, if you've written unit tests for the registration functionality, then every time you make changes to the code, simply running the tests will immediately reveal whether you've broken any existing functionality. You see, on the left is the scenario without unit tests: Bugs remain hidden for days or even weeks. On the right is the scenario with unit tests: Problems are exposed immediately during the development stage. That's a huge difference in efficiency!

In addition to quickly uncovering bugs, unit testing offers a "hidden perk"—it pushes you to write better code! Why? Because when you're preparing to write tests for a function, you'll instinctively ask yourself questions like: What if the user inputs a negative number? What if an empty string is passed in? How should I handle a network timeout? This process involves actively considering boundary conditions and exceptional scenarios. Over time, your code will become more robust, clearer, and easier to maintain. It can be said that unit testing isn't a burden; rather, it's a "fitness coach" for improving code quality!

The third crucial reason: it supports safe refactoring. What does refactoring mean? It refers to optimizing the internal code structure without altering the external behavior—such as splitting a lengthy function into several smaller ones or adopting a more efficient algorithm. At this point, how can you be certain that "the functionality hasn't been compromised"? By manually clicking and testing everything? That's way too slow! With unit tests, you have a "safety net." As long as all test cases pass, it indicates that the core functionality remains intact. This is akin to renovating a house: you can paint the walls, replace the flooring (optimize the code style), or even rearrange the layout (adjust the architecture). However, as long as the load-bearing walls (core functionality) remain untouched, the house won't collapse. And unit tests serve as the "structural safety inspector" that helps you verify whether the load-bearing walls are still sturdy. In fact, major companies like Alibaba, Tencent, and Google mandate that the unit test coverage for core modules should not be less than 80%—this is not only an engineering standard but also a quality baseline.

Alright, let's summarize. Today, we've clarified that unit testing is the independent verification of the smallest functional units in software, such as functions and methods. Its three core values are: ✅ Quickly discovering bugs ✅ Improving code quality ✅ Supporting safe refactoring In actual development, we can easily write and run tests using tools like JUnit (for Java) and pytest (for Python). Finally, here's a thought-provoking question for everyone: In your current or past projects, which functions or methods are most in need of unit testing, and why? My actionable advice is: Don't wait! Start today by selecting a simple utility function—such as one for string manipulation or date calculation—and write your first unit test for it. Experience the sense of security that comes with having "guaranteed code"!

That's it for today's class. I hope that through these 10 minutes of learning, you've gained a clear understanding of unit testing. Remember: Good code is tested code. Unit testing isn't an optional extra; it's a fundamental skill for professional developers. After class, why not find a small, practical function to practice on and deepen your understanding? See you in the next class! Thank you all!