Improving Code Coverage and Understanding Uncovered Lines

Question:

Code coverage measures how many lines of your code are executed during unit tests. While I write unit tests, some lines of code remain uncovered, such as parts of control structures, loops, exception handlers, or other logic blocks. How can I improve my code coverage, and why might certain lines remain uncovered despite my testing efforts?

CRS Info Solutions offers industry-leading Salesforce training with real-time projects, certification guidance, interview coaching, and a practical approach to make you job-ready.

Answer:

Code coverage is the percentage of executable lines of code that are executed during unit testing. The formula for calculating code coverage is

Only executable lines are counted, which means comments, blank lines, System.debug() statements, and lone curly braces are excluded. Code coverage should not be the sole focus of unit testing. Instead, prioritize thoroughly testing the logic and behavior of your code using assertions to validate the correctness of outcomes. Code coverage is a side effect of well-written, functional unit tests.

Common Scenarios and Solutions

1. Control Structures:

When testing control structures like if/else or switch, each branch of the logic must be exercised. Consider the following example:

Main Class:

public class SFSEExample {
    public static void updateAccountDetails(Account a) {
        if (a.Industry == 'Finance') {
            a.Description = 'NOTE: Finance Industry. ' + a.Description;
        } else {
            a.Description = 'Non-finance industry. ' + a.Description;
        }
    }
}

Test Class:

@isTest
public class SFSEExample_TEST {
    @isTest
    public static void runTest() {
        Account a = new Account(Name = 'Test', Industry = 'Finance', Description = 'Desc');
        Test.startTest();
        SFSEExample.updateAccountDetails(a);
        Test.stopTest();
        System.assertEquals('NOTE: Finance Industry. Desc', a.Description);
    }
}

This test covers only the if branch of the statement. To cover the else branch, you need another test with Industry set to a value other than 'Finance'.

2. Loops:

If a loop isn’t covered, it’s often because the test data doesn’t meet the conditions for iteration.

For example:

for (Account a : [SELECT Id, Name FROM Account WHERE Name LIKE 'ACME%']) {
    a.Description = 'Here are some more details.';
}

If no records match the query, the loop’s body will not execute. You must create test data that satisfies the query conditions.

3. Batch Apex:

If the execute() method of a Batch Apex class isn’t covered, it likely means the start() method’s query returns no records. Ensure that your test class inserts the necessary test data before running the batch.

Test.startTest();
Database.executeBatch(new MyBatchClass());
Test.stopTest();

4. Exception Handlers:

To cover exception handlers, you must design test cases that trigger exceptions. For example:

• Insert invalid data.
• Use dependency injection or the @TestVisible annotation to manipulate internal states.
• Remove unused exception handlers that don’t handle real errors.

Example:

public class MyClass {
    public void myMethod() {
        try {
            Integer i = 10 / 0; // This will cause an exception
        } catch (ArithmeticException ex) {
            System.debug('Caught exception: ' + ex.getMessage());
        }
    }
}

Test:

@isTest
public class MyClassTest {
    @isTest
    public static void testExceptionHandler() {
        MyClass myClass = new MyClass();
        myClass.myMethod();
    }
}

5. Rollbacks and .addError():

Code that intentionally causes rollbacks or uses .addError() requires targeted test cases.

For example:

public class MyClass {
    public static void addErrorToAccount(Account a) {
        a.addError('Simulated error');
    }
}

Test:

@isTest
public class MyClassTest {
    @isTest
    public static void testAddError() {
        Account a = new Account(Name = 'Test Account');
        Test.startTest();
        try {
            MyClass.addErrorToAccount(a);
        } catch (Exception e) {
            System.assertEquals('Simulated error', e.getMessage());
        }
        Test.stopTest();
    }
}

6. Properties:

Apex properties with getter and setter methods are executable lines and must be covered.

public class MyClass {
    public Integer index { get; set; }
}

Test:

@isTest
public class MyClassTest {
    @isTest
    public static void testProperty() {
        MyClass obj = new MyClass();
        obj.index = 5;
        System.assertEquals(5, obj.index);
    }
}

Resources

For more information on how code coverage is calculated and strategies to increase it, consult the official Salesforce documentation or community-driven canonical guides. High-quality unit tests are a critical component of maintaining robust, reliable code.

Our program includes expert certification guidance, in-depth interview preparation, and comprehensive modules covering Admin, Developer, and AI. Salesforce training in Chennai With detailed class notes and practical learning, we ensure you are industry-ready and stand out in the job market. Join our free demo class today and experience the difference in quality training.

Summing Up

Improving code coverage is essential for ensuring robust and reliable software. It highlights the areas of your application that are not executed during testing, allowing you to identify weaknesses in your test suite. To increase coverage, focus on designing functional unit tests that accurately reflect real-world scenarios. By addressing uncovered lines, such as conditional branches, loops, or exception handlers, you ensure that all logical paths are tested thoroughly.

Understanding why certain lines remain uncovered requires analyzing the specific code paths and their dependencies. Missing test data, incorrect setup, or unhandled scenarios often cause gaps in coverage. Addressing these issues not only improves coverage percentages but also enhances the overall quality and maintainability of your codebase. Through diligent testing and thoughtful test case design, you can achieve comprehensive coverage and build more reliable software.