Testing & Debugging in Operating Systems

Testing makes sure the OS works as expected.

Debugging helps us find and fix problems.

Why Is Testing Important?

Imagine building a car without testing it.

Would you feel safe driving it? Probably not.

It’s the same with an OS. It must be tested before people use it.

Testing helps find errors early.

This saves time and prevents system crashes.

🛠️ Example: You write code for memory management. If there is a bug, the system might crash or leak memory. Testing can catch this before release.

Types of Testing in OS

1. Unit Testing

Test small parts of the OS code one by one.

Example: Test just the file open function, not the whole file system.

2. Integration Testing

Test how different parts work together.

Example: Check how the file system and memory manager interact.

3. System Testing

Test the full OS like a real user would.

Check file reading, process creation, memory allocation, etc.

4. Regression Testing

Make sure that fixing one bug didn’t break something else.

This is very useful when code changes often.

5. Stress Testing

Run the OS under heavy load.

Example: Start many processes, open many files, and see if the OS can handle it.

🧪 Tip: Testing must cover both normal and strange situations.

Debugging Basics

Debugging means finding and fixing errors (bugs).

Bugs can be tricky. Some crash the system. Others just cause strange behavior.

Daily Life Example:

🔦 You turn on a lamp. Nothing happens. You check the bulb, the switch, and the plug. This is debugging!

Debugging Tools

• printk: Like printf but for the kernel. Shows messages on screen or in logs.
• gdb: The GNU Debugger. Helps find bugs in OS code.
• QEMU/Bochs: Virtual machines used to test OS code safely.
• Kernel logs: The OS writes logs during running. Check them to understand problems.

🧰 Example: You write a new system call. It doesn’t work. Use printk to check if your code runs.

Debugging Steps

1. Reproduce the bug (try to make the error happen again).
2. Look at logs or outputs (what does the system say?).
3. Use tools like gdb or printk to check where the problem is.
4. Fix the code (once you find the bug).
5. Test again (to make sure it works now).

Common Bugs in OS Development

• Memory leaks – you forget to free memory.
• Null pointer dereference – trying to use empty memory.
• Race conditions – two parts of code access shared data at the same time.
• Deadlocks – two processes wait forever for each other.
• Off-by-one errors – using loops or arrays incorrectly.

Best Practices

• Test each part as you build it.
• Write clear and small functions.
• Use comments and logs.
• Keep backups of working versions.
• Review code with others (code review).

Summary

• Testing makes sure your OS works correctly.
• Debugging helps fix problems in code.
• Use tools like gdb and printk.
• Always test after making changes.

📚 Key Terms

• Testing: Checking if software works as expected.
• Debugging: Finding and fixing problems in code.
• printk: Function to log messages in the Linux kernel.
• gdb: A debugger for C programs.
• Regression Testing: Testing to make sure new changes didn’t break old code.

🧠 Practice Time!

Try writing a simple kernel module that logs "Hello, OS!" using printk.

Use dmesg to read the log messages.

Great job! Now you know how to test and debug your OS projects. 🧩