Free test reporter date format software for linux

Log::Log4perl::DateFormat is a Log4perl advanced date formatter helper class.

SYNOPSIS

use Log::Log4perl::DateFormat;

my $format = Log::Log4perl::DateFormat->new("HH:mm:ss,SSS");

# Simple time, resolution in seconds
my $time = time();
print $format->format($time), "n";
# => "17:02:39,000"

# Advanced time, resultion in milliseconds
use Time::HiRes;
my ($secs, $msecs) = Time::HiRes::gettimeofday();
print $format->format($secs, $msecs), "n";
# => "17:02:39,959"

Log::Log4perl::DateFormat is a low-level helper class for the advanced date formatting functions in Log::Log4perl::Layout::PatternLayout.

Unless youre writing your own Layout class like Log::Log4perl::Layout::PatternLayout, theres probably not much use for you to read this.

Log::Log4perl::DateFormat is a formatter which allows dates to be formatted according to the log4j spec on

http://java.sun.com/j2se/1.5.0/docs/api/java/text/SimpleDateFormat.html

which allows the following placeholders to be recognized and processed:

Symbol Meaning Presentation Example
------ ------- ------------ -------
G era designator (Text) AD
y year (Number) 1996
M month in year (Text & Number) July & 07
d day in month (Number) 10
h hour in am/pm (1~12) (Number) 12
H hour in day (0~23) (Number) 0
m minute in hour (Number) 30
s second in minute (Number) 55
S millisecond (Number) 978
E day in week (Text) Tuesday
D day in year (Number) 189
F day of week in month (Number) 2 (2nd Wed in July)
w week in year (Number) 27
W week in month (Number) 2
a am/pm marker (Text) PM
k hour in day (1~24) (Number) 24
K hour in am/pm (0~11) (Number) 0
z time zone (Text) Pacific Standard Time
Z RFC 822 time zone (Text) -0800
escape for text (Delimiter)
single quote (Literal)

For example, if you want to format the current Unix time in "MM/dd HH:mm" format, all you have to do is this:

use Log::Log4perl::DateFormat;

my $format = Log::Log4perl::DateFormat->new("MM/dd HH:mm");

my $time = time();
print $format->format($time), "n";

While the new() method is expensive, because it parses the format strings and sets up all kinds of structures behind the scenes, followup calls to format() are fast, because DateFormat will just call localtime() and sprintf() once to return the formatted date/time string.

So, typically, you would initialize the formatter once and then reuse it over and over again to display all kinds of time values.
Also, for your convenience, the following predefined formats are available, just as outlined in the log4j spec:

Format Equivalent Example
ABSOLUTE "HH:mm:ss,SSS" "15:49:37,459"
DATE "dd MMM yyyy HH:mm:ss,SSS" "06 Nov 1994 15:49:37,459"
ISO8601 "yyyy-MM-dd HH:mm:ss,SSS" "1999-11-27 15:49:37,459"
APACHE "[EEE MMM dd HH:mm:ss yyyy]" "[Wed Mar 16 15:49:37 2005]"

So, instead of passing

Log::Log4perl::DateFormat->new("HH:mm:ss,SSS");

you could just as well say

Log::Log4perl::DateFormat->new("ABSOLUTE");

and get the same result later on.

Test::Parser is a collection of parsers for different test output file formats. These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.

Test-Parser can also export tests in SpikeSources TRPI test description XML language.

Test::Parser is a collection of parsers for different test output file formats.
These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.
Test::Parser can also export tests in SpikeSources TRPI test description XML language.
Installation:
To install the script and man pages in the standard areas, give the sequence of commands
$ perl Makefile.PL
$ make
$ make test
$ make install # you probably need to do this step as superuser
If you want to install the script in your own private space, use
$ perl Makefile.PL PREFIX=/home/joeuser
INSTALLMAN1DIR=/home/joeuser/man/man1
INSTALLMAN3DIR=/home/joeuser/man/man3
$ make
$ make test
$ make install # can do this step as joeuser
Note that `make test` does nothing interesting.
Enhancements:
- This release improves the LTP parser and adds a parse_ltp script that prints a tabular summary of the PASS/FAILs of test cases.

CPAN::Reporter is a Perl module to provides Test::Reporter support for CPAN.pm.

SYNOPSIS

From the CPAN shell:

cpan> install CPAN::Reporter
cpan> reload cpan
cpan> o conf init test_report

CPAN::Reporter is an add-on for the CPAN.pm module that uses Test::Reporter to send the results of module tests to the CPAN Testers project. Support for CPAN::Reporter is available in CPAN.pm as of version 1.88.

The goal of the CPAN Testers project (http://testers.cpan.org/) is to test as many CPAN packages as possible on as many platforms as possible. This provides valuable feedback to module authors and potential users to identify bugs or platform compatibility issues and improves the overall quality and value of CPAN.

One way individuals can contribute is to send test results for each module that they test or install. Installing CPAN::Reporter gives the option of automatically generating and emailing test reports whenever tests are run via CPAN.pm.

GETTING STARTED

The first step in using CPAN::Reporter is to install it using whatever version of CPAN.pm is already installed. CPAN.pm will be upgraded as a dependency if necessary.

cpan> install CPAN::Reporter

If CPAN.pm was upgraded, it needs to be reloaded.

cpan> reload cpan

If upgrading from a very old version of CPAN.pm, users may be prompted to renew their configuration settings, including the test_report option to enable CPAN::Reporter.

If not prompted automatically, users should manually initialize CPAN::Reporter support. After enabling CPAN::Reporter, CPAN.pm will automatically continue with interactive configuration of CPAN::Reporter options. (Remember to commit the CPAN configuration changes.)

cpan> o conf init test_report
cpan> o conf commit

Once CPAN::Reporter is enabled and configured, test or install modules with CPAN.pm as usual.

For example, to force CPAN to repeat tests for CPAN::Reporter to see how it works:

cpan> force test CPAN::Reporter

DateTime::Format::Pg is a Perl module to parse and format PostgreSQL dates and times.

SYNOPSIS

use DateTime::Format::Pg;

my $dt = DateTime::Format::Pg->parse_datetime( 2003-01-16 23:12:01 );

# 2003-01-16T23:12:01+0200
DateTime::Format::Pg->format_datetime($dt);

This module understands the formats used by PostgreSQL for its DATE, TIME, TIMESTAMP, and INTERVAL data types. It can be used to parse these formats in order to create DateTime or DateTime::Duration objects, and it can take a DateTime or DateTime::Duration object and produce a string representing it in a format accepted by PostgreSQL.

CONSTRUCTORS

The following methods can be used to create DateTime::Format::Pg objects.
new( name => value, ... )

Creates a new DateTime::Format::Pg instance. This is generally not required for simple operations. If you wish to use a different parsing style from the default then it is more comfortable to create an object.

my $parser = DateTime::Format::Pg->new()
my $copy = $parser->new( european => 1 );

This method accepts the following options:

european

If european is set to non-zero, dates are assumed to be in european dd/mm/yyyy format. The default is to assume US mm/dd/yyyy format (because this is the default for PostgreSQL).

This option only has an effect if PostgreSQL is set to output dates in the PostgreSQL (DATE only) and SQL (DATE and TIMESTAMP) styles.
Note that you dont have to set this option if the PostgreSQL server has been set to use the ISO format, which is the default.

server_tz

This option can be set to a DateTime::TimeZone object or a string that contains a time zone name.

This value must be set to the same value as the PostgreSQL servers time zone in order to parse TIMESTAMP WITH TIMEZONE values in the PostgreSQL, SQL, and German formats correctly.

Note that you dont have to set this option if the PostgreSQL server has been set to use the ISO format, which is the default.

clone()

This method is provided for those who prefer to explicitly clone via a method called clone().

my $clone = $original->clone();

If called as a class method it will die.

Devel::Tinderbox::Reporter is a Perl module with client to send reports to Tinderbox.

SYNOPSIS

use Devel::Tinderbox::Reporter;

my $report = Devel::Tinderbox::Reporter->new;

$report->from(your@mail.address.com);
$report->to(tinderbox@their.address.com);
$report->project(the_project);
$report->boxname(your.machine.name);
$report->style(unix);
$report->start;

...go and test your project...

$report->log($build_log);
$report->end($status);

Tinderbox collects and summaries build and test reports from many developers on many machines. This is a simple client for testers to make reports to Tinderbox servers.

Time::Format is a Perl module for easy-to-use date/time formatting.

SYNOPSIS

use Time::Format qw(%time %strftime %manip);

$time{$format}
$time{$format, $unixtime}

print "Today is $time{yyyy/mm/dd}n";
print "Yesterday was $time{yyyy/mm/dd, time-24*60*60}n";
print "The time is $time{hh:mm:ss}n";
print "Another time is $time{H:mm am tz, $another_time}n";
print "Timestamp: $time{yyyymmdd.hhmmss.mmm}n";
%time also accepts Date::Manip strings and DateTime objects:
$dm = Date::Manip::ParseDate(last monday);
print "Last monday was $time{Month d, yyyy, $dm}";
$dt = DateTime->new (....);
print "Heres another date: $time{m/d/yy, $dt}";
It also accepts most ISO-8601 date/time strings:
$t = 2005/10/31T17:11:09; # date separator: / or - or .
$t = 2005-10-31 17.11.09; # in-between separator: T or _ or space
$t = 20051031_171109; # time separator: : or .
$t = 20051031171109; # separators may be omitted
$t = 2005/10/31; # date-only is okay
$t = 17:11:09; # time-only is okay
# But not:
$t = 20051031; # date-only without separators
$t = 171109; # time-only without separators
# ...because those look like epoch time numbers.
%strftime works like POSIXs strftime, if you like those %-formats.
$strftime{$format}
$strftime{$format, $unixtime}
$strftime{$format, $sec,$min,$hour, $mday,$mon,$year, $wday,$yday,$isdst}

print "POSIXish: $strftime{%A, %B %d, %Y, 0,0,0,12,11,95,2}n";
print "POSIXish: $strftime{%A, %B %d, %Y, 1054866251}n";
print "POSIXish: $strftime{%A, %B %d, %Y}n"; # current time
%manip works like Date::Manips UnixDate function.
$manip{$format};
$manip{$format, $when};

print "Date::Manip: $manip{%m/%d/%Y}n"; # current time
print "Date::Manip: $manip{%m/%d/%Y,last Tuesday}n";
These can also be used as standalone functions:
use Time::Format qw(time_format time_strftime time_manip);

print "Today is ", time_format(yyyy/mm/dd, $some_time), "n";
print "POSIXish: ", time_strftime(%A %B %d, %Y,$some_time), "n";
print "Date::Manip: ", time_manip(%m/%d/%Y,$some_time), "n";

This module creates global pseudovariables which format dates and times, according to formatting codes you pass to them in strings.

The %time formatting codes are designed to be easy to remember and use, and to take up just as many characters as the output time value whenever possible. For example, the four-digit year code is "yyyy", the three-letter month abbreviation is "Mon".

The nice thing about having a variable-like interface instead of function calls is that the values can be used inside of strings (as well as outside of strings in ordinary expressions). Dates are frequently used within strings (log messages, output, data records, etc.), so having the ability to interpolate them directly is handy.

Perl allows arbitrary expressions within curly braces of a hash, even when that hash is being interpolated into a string. This allows you to do computations on the fly while formatting times and inserting them into strings. See the "yesterday" example above.

The format strings are designed with programmers in mind. What do you need most frequently? 4-digit year, month, day, 24-based hour, minute, second -- usually with leading zeroes. These six are the easiest formats to use and remember in Time::Format: yyyy, mm, dd, hh, mm, ss. Variants on these formats follow a simple and consistent formula. This module is for everyone who is weary of trying to remember strftime(3)s arcane codes, or of endlessly writing $t[4]++; $t[5]+=1900 as you manually format times or dates.

Note that mm (and related codes) are used both for months and minutes. This is a feature. %time resolves the ambiguity by examining other nearby formatting codes. If its in the context of a year or a day, "month" is assumed. If in the context of an hour or a second, "minute" is assumed.

The format strings are not meant to encompass every date/time need ever conceived. But how often do you need the day of the year (strftimes %j) or the week number (strftimes %W)?

For capabilities that %time does not provide, %strftime provides an interface to POSIXs strftime, and %manip provides an interface to the Date::Manip modules UnixDate function.

If the companion module Time::Format_XS is also installed, Time::Format will detect and use it. This will result in a significant speed increase for %time and time_format.