Debugging and Testing - potatoscript/csharp GitHub Wiki

🥔 Debugging and Testing in C# 🥔

🎯 What is Debugging?

Imagine you’re baking a potato casserole, but something went wrong, and it’s not turning out the way you expected. Maybe you added too much cheese 🧀, or you forgot to put it in the oven! 🥔💡

In programming, debugging is the process of finding and fixing errors (bugs) in your code, just like you would fix problems in your casserole recipe. When something doesn’t work the way you expect, debugging helps you identify the problem, understand why it happened, and fix it.

🎯 What is Testing?

Now, imagine you’ve baked your casserole and want to make sure it tastes perfect before serving it. You might taste test it first 🥔🍽️, and if it's too salty or needs more potatoes, you’ll adjust. This is similar to testing in programming!

Testing is the process of making sure your code behaves the way you want it to. You run tests on your application to check if everything works and to make sure there are no surprises (like a casserole that’s too salty).

🥔 Debugging Tools in C#

C# and Visual Studio provide powerful tools to help you find and fix bugs in your code. Let’s take a look at some of these tools.

🎯 Step 1: Breakpoints

Breakpoints are like pause buttons 🛑 in your code. You can set a breakpoint to stop the program at a specific line of code, so you can inspect what’s happening at that moment.

🧑‍💻 How to Set a Breakpoint:

  1. Open your C# code in Visual Studio.
  2. Click on the left margin next to the line of code where you want to pause.
  3. You’ll see a red dot appear, which means the breakpoint is set.

Now, when you run the program, it will pause at that line, and you can see what’s happening in your variables. For example, you might want to know the recipe name and details in your Potato Recipe Book app.

🧑‍💻 Example:

private void AddButton_Click(object sender, EventArgs e)
{
    string recipeName = recipeNameTextBox.Text;
    string recipeDetails = recipeDetailsRichTextBox.Text;
    
    // Breakpoint here to inspect the values
    Debug.WriteLine("Recipe Name: " + recipeName);
    Debug.WriteLine("Recipe Details: " + recipeDetails);

    if (!string.IsNullOrEmpty(recipeName) && !string.IsNullOrEmpty(recipeDetails))
    {
        PotatoRecipe newRecipe = new PotatoRecipe(recipeName, recipeDetails);
        potatoRecipes.Add(newRecipe);
        recipeListBox.Items.Add(newRecipe);
    }
    else
    {
        MessageBox.Show("Please enter a valid name and details.");
    }
}

When the program pauses at the breakpoint, you can inspect the values of recipeName and recipeDetails to see if they’re correct. If something’s wrong, you can fix it!

🎯 Step 2: Watch and Inspect Variables

You can use Watch to keep an eye on your variables while the program is paused. It’s like watching a potato boiling on the stove 🍲 – you want to make sure it’s cooking right.

🧑‍💻 How to Use Watch:

  1. After pausing the program at a breakpoint, go to the Watch window in Visual Studio.
  2. Type the name of the variable you want to inspect, like recipeName.
  3. It will show you the current value of that variable.

This helps you understand what’s going on inside your program, step by step, and helps you identify where things might be going wrong.

🎯 Step 3: Step Over, Step Into, and Step Out

When you’re debugging, you can move through your code line by line to see what happens at each step. It’s like peeling a potato one layer at a time. You can use the following commands:

  • Step Over (F10): Move to the next line of code, skipping over any function calls.
  • Step Into (F11): If you’re on a line that calls a method, step into the method to see what’s happening inside.
  • Step Out (Shift + F11): Exit the current method and go back to the previous one.

These commands help you carefully examine your code and understand how it works.

🥔 Testing Your Code

Just like you want to make sure your potato casserole tastes right before serving, you need to test your code to make sure it works as expected. There are two main types of tests:

  1. Unit Tests: These test individual parts of your code, like testing a single potato 🥔. It checks if one thing works perfectly.
  2. Integration Tests: These test if different parts of your code work together, like checking if all the ingredients in your casserole blend together perfectly.

🎯 Step 4: Writing Unit Tests

In C#, you can write Unit Tests using the MSTest framework or NUnit. Let’s write a simple unit test to check if our PotatoRecipe class works.

🧑‍💻 How to Write a Unit Test:

  1. Create a new Unit Test Project in Visual Studio by clicking File → New → Project → MSTest.
  2. Write the test code to check if the PotatoRecipe constructor works correctly.
[TestClass]
public class PotatoRecipeTests
{
    [TestMethod]
    public void Test_PotatoRecipe_Creation()
    {
        // Arrange
        string name = "Baked Potato";
        string details = "Bake at 400°F for 45 minutes.";

        // Act
        PotatoRecipe recipe = new PotatoRecipe(name, details);

        // Assert
        Assert.AreEqual(name, recipe.Name);
        Assert.AreEqual(details, recipe.Details);
    }
}

🧑‍💻 Explanation:

  • Arrange: Set up the test (create the recipe name and details).
  • Act: Create the PotatoRecipe object.
  • Assert: Check if the name and details match the expected values.

🎯 Step 5: Running Tests

After writing your unit test, you can run it by pressing the Run button in Visual Studio. It will tell you if your test passed (everything works as expected) or failed (something went wrong).

🎯 Step 6: Handling Errors

Sometimes, even after debugging and testing, your app might throw an error. These errors are like burnt potatoes 🥔🔥—they happen, but you can fix them.

In C#, you can handle errors using try-catch blocks. If something goes wrong inside the try block, the catch block will handle the error gracefully.

🧑‍💻 Example of Try-Catch Block:

try
{
    // Code that might cause an error
    string recipeName = recipeNameTextBox.Text;
    PotatoRecipe newRecipe = new PotatoRecipe(recipeName, null);  // This might cause an error!
    potatoRecipes.Add(newRecipe);
}
catch (Exception ex)
{
    // Handle the error
    MessageBox.Show("An error occurred: " + ex.Message);
}

This prevents your app from crashing and lets you gracefully handle errors like a pro chef fixing a burnt potato 🥔.

🎯 Step 7: Using Logs for Debugging

You can also use logs to keep track of what’s happening in your program, like keeping a potato journal 🥔📓 to track your cooking steps.

Debug.WriteLine("Recipe Added: " + newRecipe.Name);

This writes information to the Output window in Visual Studio, where you can track the flow of your program.

🎉 Summary of Debugging and Testing

In this section, we:

  1. Debugged our code using breakpoints, watch windows, and step commands.
  2. Tested our code using unit tests to make sure everything works.
  3. Handled errors gracefully with try-catch blocks and logs to keep track of what’s happening.

Now, your app is like a perfectly baked potato casserole 🥔—tasty and error-free!