Symbol::Table allows the user to manipulate Perl's symbol table

The Template Toolkit is a fast, powerful, and easily extensible
template processing system written in Perl with certain key elements
coded in C for maximum speed. It is ideally suited (but not limited) to
the creation of static and dynamic web content, and incorporates
various modules and tools to simplify this process.

This module lets you ask the user for a password in the traditional
way, from the keyboard, without echoing.

This is not intended for use over the web; user authentication over the
web is another matter entirely. Also, this module should generally be
used in conjunction with Perl's crypt() function, sold separately.

ReadKey provides ioctl control for terminals and Win32 consoles so the
input modes can be changed (thus allowing reads of a single character
at a time), and also provides non-blocking reads of stdin as well as
several other terminal related features, including retrieval and
modification of the screen size and retrieval and modification of the
control characters.

For many APIs with large numbers of classes, it can be very useful to be
able to do a quick once-over to make sure that classes, methods, and
inheritance is correct, before doing more comprehensive testing. This
module aims to provide such a capability.

This module provides a few convenience methods for testing exception
based code. It is built with Test::Builder and plays happily with
Test::More and friends.

This is another framework for writing test scripts. It is loosely inspired
by Test::More, and has most of it's functionality, but it is not a drop-in
replacement.

Perl's garbage collection has one big problem: Circular references can't
get cleaned up. A circular reference can be as simple as two reference
that refer to each other.

Test::Memory::Cycle is built on top of Devel::Cycle to give you an easy
way to check for these circular references.

In situations where you have deep trees of classes, there is a common
situation in which you test a module 4 or 5 subclasses down, which should
follow the correct behaviour of not just the subclass, but of all the
parent classes.

This should be done to ensure that the implementation of a subclass has not
somehow "broken" the object's behaviour in a more general sense.

'Test::Object' is a testing package designed to allow you to easily test
what you believe is a valid object against the expected behaviour of *all*
of the classes in its inheritance tree in one single call.

To do this, you "register" tests (in the form of CODE or function
references) with 'Test::Object', with each test associated with a
particular class.

When you call 'object_ok' in your test script, 'Test::Object' will check
the object against all registered tests. For each class that your object
responds to '$object->isa($class)' for, the appropriate testing function
will be called.

Doing it this way allows adapter objects and other things that respond to
'isa' differently that the default to still be tested against the classes
that it is advertising itself as correctly.

This also means that more than one test might be "counted" for each call to
'object_ok'. You should account for this correctly in your expected test
count.

Test::Output provides a simple interface for testing output sent to STDOUT
or STDERR. A number of different utilities are included to try and be as
flexible as possible to the tester.

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.

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

This module provides a few convenience methods for testing warning
based code.

This module implements a least recently used (LRU) cache in memory
through a tie interface.

If you have been led to believe that associative arrays in Perl do not
preserve order, and if you have ever craved that feature, this module
is for you.

This module provides functions for expressing durations in rounded or
exact terms.

Perl modules providing various time functions.

Period.pm is a Perl module that contains code for dealing with time
periods. Currently, there is only one function in this module. That
function is called inPeriod().

Date::Parse provides two routines for parsing date strings into time values.

str2time(DATE [, ZONE])

str2time parses DATE and returns a unix time value, or undef upon failure.
ZONE, if given, specifies the timezone to assume when parsing if the date
string does not specify a timezome.

strptime(DATE [, ZONE])

strptime takes the same arguments as str2time but returns an array of values
($ss,$mm,$hh,$day,$month,$year,$zone). Elements are only defined if they
could be extracted from the date string. The $zone element is the timezone
offset in seconds from GMT. An empty array is returned upon failure.

Perl Tk is an enhancement for Perl. It combines the well structured
graphical library Tk with the powerful scripting language Perl.

This class encapsulates/makes/manipulates objects that represent nodes
in a tree structure. The tree structure is not an object itself, but is
emergent from the linkages you create between nodes. This class
provides the methods for making linkages that can be used to build up a
tree, while preventing you from ever making any kinds of linkages which
are not allowed in a tree (such as having a node be its own mother or
ancestor, or having a node have two mothers).

The Unicode::Map8 class implement efficient mapping tables between
8-bit character sets and 16-bit character sets like Unicode. The tables
are efficient both in terms of space allocated and translation speed.
The 16-bit strings is assumed to use network byte order.

A Unicode::String object represents a sequence of Unicode characters.
The Unicode Standard is a fixed-width, uniform encoding scheme for
written characters and text. This encoding treats alphabetic
characters, ideographic characters, and symbols identically, which
means that they can be used in any mixture and with equal facility.
Unicode is modeled on the ASCII character set, but uses a 16-bit
encoding to support full multilingual text.

This module implements the URI class. Objects of this class represent
"Uniform Resource Identifier references" as specified in RFC 2396 (and
updated by RFC 2732).

URI objects can be used to access and manipulate the various
components that make up these strings. There are also methods to
combine URIs in various ways.

A patch to Perl 5.005_55 by the author implements a core API for weak
references. This module is a Perl-level interface to that API, allowing
weak references to be created in Perl.

A weak reference is just like an ordinary Perl reference except that it
isn't included in the reference count of the thing referred to. This
means that once all references to a particular piece of data are weak,
the piece of data is freed and all the weak references are set to
undef. This is particularly useful for implementing circular data
structures without memory leaks or caches of objects.

WWW::Curl is a Perl extension interface for libcurl.