Module 8: Testing and Debugging

Lesson 21: Writing Unit Tests

Objective: Learn how to write unit tests to ensure that individual parts of the app function correctly.

Introduction to Unit Testing:

Unit testing involves writing tests for individual units or components of your code to ensure they work as expected. These tests help catch bugs early and ensure that changes to the code do not break existing functionality.

Creating Simple Unit Tests:

Here’s an example of a simple unit test for the user registration function:

procedure TestRegisterUser;
var
  Head: PUser;
  User: PUser;
begin
  Head := nil;
  User := RegisterUser(Head, 'Alice', 'password123');
  
  // Test if user is correctly registered
  if (User^.Name = 'Alice') and (User^.Password = 'password123') then
    writeln('TestRegisterUser: Passed')
  else
    writeln('TestRegisterUser: Failed');
end;

Explanation:

• TestRegisterUser: is a procedure that tests the RegisterUser function.
• User := RegisterUser(Head, 'Alice', 'password123'); registers a new user named Alice with a password.
• writeln('TestRegisterUser: Passed'); prints "Passed" if the user is correctly registered, otherwise prints "Failed".

Exercise - Writing Unit Tests:

Write unit tests for the following functions:

• AuthenticateUser - Ensure it correctly authenticates users with valid credentials and rejects invalid ones.
• CreateAlbum - Test if albums are created with the correct name and linked to the user.
• UploadPhoto - Verify that photos are correctly added to albums.

Lesson 22: Debugging Techniques

Objective: Learn debugging techniques to identify and fix issues in your code.

Common Debugging Techniques:

Debugging is the process of identifying and fixing bugs or errors in your code. Here are some common debugging techniques:

• Print Statements: Use writeln statements to print variable values and program flow at different points in your code. This helps you understand what your code is doing.
• Step-by-Step Execution: Use a debugger tool (if available) to step through your code line by line, inspecting the state of variables at each step.
• Code Reviews: Review your code or have someone else review it to catch mistakes or logic errors.

Using Print Statements:

Here’s how you can use print statements to debug the AuthenticateUser function:

function AuthenticateUser(Head: PUser; Name, Password: String): PUser;
begin
  while Head <> nil do
  begin
    writeln('Checking user: ', Head^.Name);  // Debug statement
    if (Head^.Name = Name) and (Head^.Password = Password) then
    begin
      writeln('User authenticated: ', Head^.Name);  // Debug statement
      AuthenticateUser := Head;
      Exit;
    end;
    Head := Head^.Next;
  end;
  writeln('User not found or incorrect password.');  // Debug statement
  AuthenticateUser := nil;
end;

Explanation:

• writeln('Checking user: ', Head^.Name); prints the name of the user being checked during authentication.
• writeln('User authenticated: ', Head^.Name); confirms when a user is successfully authenticated.
• writeln('User not found or incorrect password.'); alerts if the authentication fails.

Exercise - Debugging Practice:

Add print statements to other parts of your code where you suspect bugs might be occurring. Run the code and observe the output to identify and fix any issues.

Lesson 23: Refining the App

Objective: Refine the app by addressing any issues found during testing and debugging.

Iterative Testing and Refinement:

After running your unit tests and debugging the code, you may need to refine the app to ensure it runs smoothly. This might involve:

• Fixing Bugs: Address any issues identified during debugging.
• Optimizing Code: Review your code for efficiency and readability. Consider refactoring complex sections to make them simpler.
• Enhancing Features: Based on your tests, you might find opportunities to enhance existing features or add new ones.

Final Testing:

Once all refinements are made, conduct a final round of testing to ensure that the app is stable and all features work as intended. Create a checklist of all the features and test each one thoroughly.

Exercise - Refinement Checklist:

Create a checklist of all the app’s features and systematically test each one. Document any issues and fix them, then test again until everything works perfectly.

Next Steps:

In the next module, we’ll focus on polishing the user interface and preparing the app for deployment.