MATLAB Test Generator

This skill provides comprehensive guidelines for creating robust unit tests using the MATLAB Testing Framework. Generate test classes, test methods, and test suites following MATLAB best practices.

When to Use This Skill

• Creating unit tests for MATLAB functions or classes
• Generating test suites for existing code
• Writing test cases with assertions and fixtures
• Creating parameterized tests
• Setting up test environments with setup/teardown methods
• When user requests testing, test coverage, or mentions unit tests

MATLAB Testing Framework Overview

MATLAB supports multiple testing approaches:

1. Script-Based Tests - Simple test scripts with assertions
2. Function-Based Tests - Test functions with local functions for each test
3. Class-Based Tests - Full-featured test classes (recommended for complex testing)

Test Class Structure

Basic Test Class Template

classdef MyFunctionTest < matlab.unittest.TestCase
    % Tests for myFunction

    properties (TestParameter)
        % Define parameters for parameterized tests
    end

    properties
        % Test fixtures and shared data
    end

    methods (TestClassSetup)
        % Runs once before all tests
    end

    methods (TestClassTeardown)
        % Runs once after all tests
    end

    methods (TestMethodSetup)
        % Runs before each test method
    end

    methods (TestMethodTeardown)
        % Runs after each test method
    end

    methods (Test)
        % Individual test methods
    end
end

Critical Rules

File Naming

• Test files MUST end with

  Test.m

  (e.g.,

  myFunctionTest.m

  )
• Class name must match filename
• Follow PascalCase naming convention
• Place in

  tests/

  directory or alongside source with

  Test

  suffix

Test Method Naming

• Use descriptive, readable names
• Start with lowercase letter
• Use camelCase
• Describe what is being tested
• Example:

  testAdditionWithPositiveNumbers

Assertions

Always use the appropriate assertion method:

• verifyEqual(actual, expected)

  - Continues testing on failure

• assertEqual(actual, expected)

  - Stops testing on failure (legacy)

• verifyTrue(condition)

  - Verify boolean condition

• verifyError(f, errorID)

  - Verify function throws error

• verifyWarning(f, warningID)

  - Verify function issues warning

• verifyInstanceOf(actual, expectedClass)

  - Verify object type

• verifySize(actual, expectedSize)

  - Verify array size

• verifyEmpty(actual)

  - Verify empty array

Complete Test Examples

Example 1: Testing a Simple Function

Function to test (

add.m

):

function result = add(a, b)
    % ADD Add two numbers
    result = a + b;
end

Test class (

addTest.m

):

classdef addTest < matlab.unittest.TestCase
    % Tests for add function

    methods (Test)
        function testAddPositiveNumbers(testCase)
            % Test addition of positive numbers
            result = add(2, 3);
            testCase.verifyEqual(result, 5);
        end

        function testAddNegativeNumbers(testCase)
            % Test addition of negative numbers
            result = add(-2, -3);
            testCase.verifyEqual(result, -5);
        end

        function testAddMixedNumbers(testCase)
            % Test addition of positive and negative
            result = add(5, -3);
            testCase.verifyEqual(result, 2);
        end

        function testAddZero(testCase)
            % Test addition with zero
            result = add(5, 0);
            testCase.verifyEqual(result, 5);
        end

        function testAddArrays(testCase)
            % Test element-wise addition of arrays
            result = add([1 2 3], [4 5 6]);
            testCase.verifyEqual(result, [5 7 9]);
        end
    end
end

Example 2: Parameterized Tests

classdef calculateAreaTest < matlab.unittest.TestCase
    % Tests for calculateArea function with parameters

    properties (TestParameter)
        rectangleDims = struct(...
            'small', struct('width', 2, 'height', 3, 'expected', 6), ...
            'large', struct('width', 10, 'height', 20, 'expected', 200), ...
            'unit', struct('width', 1, 'height', 1, 'expected', 1));
    end

    methods (Test)
        function testRectangleArea(testCase, rectangleDims)
            % Test rectangle area calculation
            area = calculateArea(rectangleDims.width, rectangleDims.height);
            testCase.verifyEqual(area, rectangleDims.expected);
        end
    end
end

Example 3: Tests with Fixtures

classdef DataProcessorTest < matlab.unittest.TestCase
    % Tests for DataProcessor class with setup/teardown

    properties
        TestData
        TempFile
    end

    methods (TestMethodSetup)
        function createTestData(testCase)
            % Create test data before each test
            testCase.TestData = rand(100, 5);
            testCase.TempFile = tempname;
        end
    end

    methods (TestMethodTeardown)
        function deleteTestData(testCase)
            % Clean up after each test
            if isfile(testCase.TempFile)
                delete(testCase.TempFile);
            end
        end
    end

    methods (Test)
        function testDataLoading(testCase)
            % Test data loading functionality
            save(testCase.TempFile, 'data', testCase.TestData);
            processor = DataProcessor(testCase.TempFile);
            testCase.verifyEqual(processor.data, testCase.TestData);
        end

        function testDataNormalization(testCase)
            % Test data normalization
            processor = DataProcessor();
            processor.data = testCase.TestData;
            normalized = processor.normalize();
            testCase.verifyLessThanOrEqual(max(normalized(:)), 1);
            testCase.verifyGreaterThanOrEqual(min(normalized(:)), 0);
        end
    end
end

Example 4: Error Testing

classdef validateInputTest < matlab.unittest.TestCase
    % Tests for validateInput function

    methods (Test)
        function testValidInput(testCase)
            % Test valid input passes
            testCase.verifyWarningFree(@() validateInput(5));
        end

        function testNegativeInputError(testCase)
            % Test negative input throws error
            testCase.verifyError(@() validateInput(-5), 'MATLAB:validators:mustBePositive');
        end

        function testNonNumericInputError(testCase)
            % Test non-numeric input throws error
            testCase.verifyError(@() validateInput('text'), 'MATLAB:validators:mustBeNumeric');
        end

        function testEmptyInputError(testCase)
            % Test empty input throws error
            testCase.verifyError(@() validateInput([]), 'MATLAB:validators:mustBeNonempty');
        end
    end
end

Test Organization Best Practices

Directory Structure

project/
├── src/
│   ├── myFunction.m
│   └── MyClass.m
└── tests/
    ├── myFunctionTest.m
    └── MyClassTest.m

Running Tests

Run all tests in directory:

results = runtests('tests')

Run specific test class:

results = runtests('myFunctionTest')

Run specific test method:

results = runtests('myFunctionTest/testAddPositiveNumbers')

Generate test suite:

suite = testsuite('tests');
results = run(suite);

With coverage report:

import matlab.unittest.TestRunner
import matlab.unittest.plugins.CodeCoveragePlugin

runner = TestRunner.withTextOutput;
runner.addPlugin(CodeCoveragePlugin.forFolder('src'));
results = runner.run(testsuite('tests'));

Assertion Tolerance

For floating-point comparisons, use tolerance:

% Absolute tolerance
testCase.verifyEqual(actual, expected, 'AbsTol', 1e-10);

% Relative tolerance
testCase.verifyEqual(actual, expected, 'RelTol', 1e-6);

% Both
testCase.verifyEqual(actual, expected, 'AbsTol', 1e-10, 'RelTol', 1e-6);

Test Assumptions

Use assumptions to skip tests when prerequisites aren't met:

function testPlotting(testCase)
    % Skip test if not running in graphical environment
    testCase.assumeTrue(usejava('desktop'), 'Requires desktop environment');

    % Test code here
    fig = figure;
    plot(1:10);
    testCase.verifyInstanceOf(fig, 'matlab.ui.Figure');
    close(fig);
end

Test Tagging

Tag tests for selective execution:

methods (Test, TestTags = {'Unit'})
    function testBasicOperation(testCase)
        % Fast unit test
    end
end

methods (Test, TestTags = {'Integration', 'Slow'})
    function testDatabaseConnection(testCase)
        % Slower integration test
    end
end

Run tagged tests:

% Run only Unit tests
suite = testsuite('tests', 'Tag', 'Unit');
results = run(suite);

Mock Objects and Stubs

For testing code with dependencies:

function testWithMock(testCase)
    % Create mock object
    import matlab.mock.TestCase
    [mock, behavior] = testCase.createMock(?MyInterface);

    % Define behavior
    testCase.assignOutputsWhen(withAnyInputs(behavior.methodName), expectedOutput);

    % Use mock in test
    result = functionUnderTest(mock);
    testCase.verifyEqual(result, expectedValue);
end

Performance Testing

Test execution time:

function testPerformance(testCase)
    % Test function executes within time limit
    tic;
    result = expensiveFunction(largeData);
    elapsedTime = toc;

    testCase.verifyLessThan(elapsedTime, 1.0, ...
        'Function should complete within 1 second');
end

Checklist for Test Creation

Before finalizing tests, verify:

• Test file ends with

  Test.m

• Class inherits from

  matlab.unittest.TestCase

• Test methods use descriptive names
• Appropriate assertions used (verify vs assert)
• Edge cases covered (empty, zero, negative, large values)
• Error cases tested with

  verifyError

• Floating-point comparisons use tolerance
• Setup/teardown methods clean up resources
• Tests are independent (can run in any order)
• Tests follow Arrange-Act-Assert pattern
• Parameterized tests used for similar test cases
• Comments explain what is being tested

Common Patterns

Arrange-Act-Assert Pattern

function testCalculation(testCase)
    % Arrange - Set up test data
    input1 = 5;
    input2 = 3;
    expected = 8;

    % Act - Execute the code under test
    actual = myFunction(input1, input2);

    % Assert - Verify the result
    testCase.verifyEqual(actual, expected);
end

Testing Private Methods

% Use access to test private methods
classdef MyClassTest < matlab.unittest.TestCase
    methods (Test)
        function testPrivateMethod(testCase)
            obj = MyClass();
            % Access private method
            result = obj.privateMethod(testCase);
            testCase.verifyEqual(result, expectedValue);
        end
    end
end

Testing Static Methods

function testStaticMethod(testCase)
    % Test static method without instantiation
    result = MyClass.staticMethod(input);
    testCase.verifyEqual(result, expected);
end

Troubleshooting

Issue: Tests not discovered

• Solution: Ensure filename ends with

  Test.m

  and class inherits from

  matlab.unittest.TestCase

Issue: Floating-point comparison failures

• Solution: Use

  'AbsTol'

  or

  'RelTol'

  parameters with

  verifyEqual

Issue: Tests affecting each other

• Solution: Ensure proper cleanup in teardown methods and test independence

Issue: Slow test execution

• Solution: Use tags to separate fast unit tests from slow integration tests

Additional Resources

• Use

  doc matlab.unittest.TestCase

  for complete assertion reference
• Use

  doc matlab.unittest.fixtures

  for advanced fixture usage
• Use

  doc matlab.mock

  for mocking framework documentation