Test::Class::Most provides some more convenience when using Test::Class.

This module causes any warnings during testing to be captured and stored. It automatically adds an extra test that will run when your script ends to check that there were no warnings. If there were any warnings, the test will fail and output diagnostics of where, when and what the warning was, including a stack trace of what was going on when it occurred.

This module contains a collection of acceptance tests for implementations of Future::IO.

This module is a collection of tests useful for dealing with UTF-8 strings in Perl. This module has two types of tests: The validity tests check if a string is valid and not corrupt, whereas the characteristics tests will check that string has a given set of characteristics.

Test::SharedFork is a utility module for Test::Builder. It makes fork(2) safe to use in test cases.

This module provides the most commonly used testing functions, along with automatically turning on strict and warning and gives a bit more fine-grained control over test suites.

Test::File provides a collection of test utilities for file attributes.

The intent of the Test::Script module is to provide a series of basic tests for 80% of the testing you will need to do for scripts in the script (or bin as is also commonly used) paths of your Perl distribution.

Test::Class provides a simple way of creating classes and objects to test your code in an xUnit style.

Built using Test::Builder, it was designed to work with other Test::Builder based modules (Test::More, Test::Differences, Test::Exception, etc.).

This module is intended to be used as a drop-in replacement for Test::NoWarnings. It also adds an extra test, but runs this test before done_testing calculates the test count, rather than after. It does this by hooking into done_testing as well as via an END block. You can declare a plan, or not, and things will still Just Work.

Test::FailWarnings adds test failures if warnings are caught.

Test::DistManifest provides a simple method of testing that a MANIFEST file matches its distribution.

There are a number of different situations (like testing caching code) where you want to want to do a number of tests, and then verify that some underlying subroutine deep within the code was called a specific number of times.

Test::SubCalls module provides a number of functions for doing testing in this way in association with your normal Test::More (or similar) test scripts.

Test::Tester allows testing of test modules based on Test::Builder with a minimum of effort.

At some point or another, most programmers find they need to compare floating-point numbers for equality. The typical idiom is to test if the absolute value of the difference of the numbers is within a desired tolerance, usually called epsilon. This module provides such a function for use with Test::More.

Testing code which forks is problematic because each test has a number associated with it. Coordinating the test number amongst the parent and child processes is complicated. Test::Fork provides a function to smooth over the complications.

This module was written to ensure that a META.yml file meets the specification.

Test::Deep compares two structures by going through each level, ensuring that the values match, that arrays and hashes have the same elements and that references are blessed into the correct class. It also handles circular data structures without getting caught in an infinite loop.

Test::Fatal is an alternative to the popular Test::Exception. It does much less, but should allow greater flexibility in testing exception-throwing code with about the same amount of typing.

This module exports three test functions and four diff-style functions.

The Test::WriteVariants module provides for the dynamic generation of tests in nested combinations of contexts.

This module lets you check your module's namespaces for imported functions you might have forgotten to remove with namespace::autoclean or namespace::clean and are therefore available to be called as methods, which usually isn't want you want.

Check POD files for errors or warnings in a test file, using Pod::Simple to do the heavy lifting.

Test::MockModule lets you temporarily redefine subroutines in other packages for the purposes of unit testing. A Test::MockModule object is set up to mock subroutines for a given module. The mocked object remembers the original subroutine so it can be easily restored. This happens automatically when all MockModule objects for the given module go out of scope, or when you unmock() the subroutine.