Data-Types-0.09000755000765000024 011577535512 13003 5ustar00davidstaff000000000000Data-Types-0.09/Build.PL000444000765000024 126511577535512 14440 0ustar00davidstaff000000000000use Module::Build; my $build = Module::Build->new( module_name => 'Data::Types', license => 'perl', create_makefile_pl => 'traditional', configure_requires => { 'Module::Build' => '0.2701' }, recommends => { 'Test::Pod' => '1.41' }, build_requires => { 'Module::Build' => '0.2701', 'Test::More' => '0.17', }, meta_merge => { resources => { homepage => 'http://search.cpan.org/dist/Data-Types/', bugtracker => 'http://github.com/theory/data-types/issues/', repository => 'http://github.com/theory/data-types/', } }, ); $build->create_build_script; Data-Types-0.09/Changes000444000765000024 433211577535512 14435 0ustar00davidstaff000000000000Revision history for Perl extension Data::Types. 0.09 2011-06-20T03:15:50 - Moved repostitory to [GitHub](https://github.com/theory/data-types/). - Switched to a "traditional" `Makefile.PL`. 0.08 2008-05-05T19:01:10 - Added Test::Pod to the "recommends" parameter in Build.PL. - Added Module::Build to the "build_requires" parameter in Build.PL. - Updated copyright. - Added a link to the Subversion repository. - Updated the POD test to take advantage of Test::Pod 1.20 or later. 0.07 2008-01-22T18:27:22 - Added Module::Build to the "configure_requires" parameter in Build.PL. This should help prevent failures on systems that don't already have Module::Build installed and run Makefile.PL. Reported by Slaven Rezic. - Added Test::Simple to the "build_requires" parameter in Build.PL. 0.06 2006-05-23T00:45:44 - Added POD tests. - Backwards compatibility change: Whole numbers now include 0. This is more inline with accepted mathmatical definitions. See, e.g., http://en.wikipedia.org/wiki/Whole_number http://mathforum.org/library/drmath/view/57052.html - Added is_count() and to_count() to match whole numbers exclusive of zero. These functions match the previous behavior of is_whole() and to_whole(). - Fixed a typo in my email address. 0.05 Tue Aug 26 01:21:03 2003 - Switched to Module::Build. 0.04 Thu Jul 25 05:09:13 2002 - Added reference to Arthur Bergman's new "types" pragma for Perl 5.8.0. Thought I'd done it in 0.03, but I guess not. 0.03 Mon Jul 22 21:05:26 2002 - Fixed to_float() tests so that comparison is more precise. Necessary for compatability with Perl 5.8.0 (and probably better, anyway). - Reorganized structure of distribution to reflect more modern standard for CPAN modules. 0.02 Thu Jan 3 22:06:42 PST 2002 - Added second argument to to_string() that will truncate the string. - Fixed Regular expression in is_int() so that it doesn't match '+' or '-'. Thanks to David Alban for the spot. 0.01 Wed Jan 2 12:13:19 PST 2002 - original version. Data-Types-0.09/Makefile.PL000444000765000024 60211577535512 15070 0ustar00davidstaff000000000000# Note: this file was auto-generated by Module::Build::Compat version 0.3800 use ExtUtils::MakeMaker; WriteMakefile ( 'NAME' => 'Data::Types', 'VERSION_FROM' => 'lib/Data/Types.pm', 'PREREQ_PM' => { 'Module::Build' => '0.2701', 'Test::More' => '0.17' }, 'INSTALLDIRS' => 'site', 'EXE_FILES' => [], 'PL_FILES' => {} ) ; Data-Types-0.09/MANIFEST000444000765000024 17511577535512 14254 0ustar00davidstaff000000000000Build.PL Changes lib/Data/Types.pm Makefile.PL MANIFEST This list of files META.json META.yml README.md t/types.t t/zpod.t Data-Types-0.09/META.json000444000765000024 242011577535512 14557 0ustar00davidstaff000000000000{ "abstract" : "Validate and convert data types.", "author" : [ "David E. Wheeler " ], "dynamic_config" : 1, "generated_by" : "Module::Build version 0.38, CPAN::Meta::Converter version 2.110440", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Data-Types", "prereqs" : { "build" : { "requires" : { "Module::Build" : "0.2701", "Test::More" : "0.17" } }, "configure" : { "requires" : { "Module::Build" : "0.2701" } }, "runtime" : { "recommends" : { "Test::Pod" : "1.41" } } }, "provides" : { "Data::Types" : { "file" : "lib/Data/Types.pm", "version" : "0.09" } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "http://github.com/theory/data-types/issues/" }, "homepage" : "http://search.cpan.org/dist/Data-Types/", "license" : [ "http://dev.perl.org/licenses/" ], "repository" : { "url" : "http://github.com/theory/data-types/" } }, "version" : "0.09" } Data-Types-0.09/META.yml000444000765000024 136411577535512 14415 0ustar00davidstaff000000000000--- abstract: 'Validate and convert data types.' author: - 'David E. Wheeler ' build_requires: Module::Build: 0.2701 Test::More: 0.17 configure_requires: Module::Build: 0.2701 dynamic_config: 1 generated_by: 'Module::Build version 0.38, CPAN::Meta::Converter version 2.110440' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Data-Types provides: Data::Types: file: lib/Data/Types.pm version: 0.09 recommends: Test::Pod: 1.41 resources: bugtracker: http://github.com/theory/data-types/issues/ homepage: http://search.cpan.org/dist/Data-Types/ license: http://dev.perl.org/licenses/ repository: http://github.com/theory/data-types/ version: 0.09 Data-Types-0.09/README.md000444000765000024 154111577535512 14420 0ustar00davidstaff000000000000Data/Types version 0.09 ======================= This module exports a number of functions that are useful for validating and converting data types. It is intended for use in applications where data types are more important than they typically are in Perl -- e.g., for database applications. Installation ------------ To install this module, type the following: perl Build.PL ./Build ./Build test ./Build install Or, if you don't have Module::Build installed, type the following: perl Makefile.PL make make test make install Dependencies ------------ This module requires no modules or libraries not already included with Perl. COPYRIGHT AND LICENCE Copyright (c) 2002-2011, David E. Wheeler. Some Rights Reserved. This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Data-Types-0.09/lib000755000765000024 011577535512 13551 5ustar00davidstaff000000000000Data-Types-0.09/lib/Data000755000765000024 011577535512 14422 5ustar00davidstaff000000000000Data-Types-0.09/lib/Data/Types.pm000444000765000024 3175111577535512 16250 0ustar00davidstaff000000000000package Data::Types; use strict; require Exporter; use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); $VERSION = '0.09'; @ISA = qw(Exporter); @EXPORT_OK = qw(is_whole to_whole is_count to_count is_int to_int is_real to_real is_decimal to_decimal is_float to_float is_string to_string ); @EXPORT = qw(); %EXPORT_TAGS = ( all => \@EXPORT_OK, whole => [qw(is_whole to_whole)], count => [qw(is_count to_count)], int => [qw(is_int to_int)], decimal => [qw(is_decimal to_decimal)], real => [qw(is_real to_real)], float => [qw(is_float to_float)], string => [qw(is_string to_string)], is => [qw(is_whole is_int is_real is_decimal is_float is_string)], to => [qw(to_whole to_int to_real to_decimal to_float to_string)], ); use constant DEF_PRECISION => 5; ################################################################################ # FUNCTIONS # ################################################################################ sub is_whole ($) { return unless defined $_[0]; return unless $_[0] =~ /^\d+$/; return 1; } sub to_whole ($) { return unless defined $_[0]; my ($num) = $_[0] =~ /([+-]?(?:\d+(?:\.\d*)?|\.\d+))/; return unless defined $num && $num >= 0; sprintf "%.0f", $num; } sub is_count ($) { return unless $_[0]; return unless $_[0] =~ /^\d+$/; return 1; } sub to_count ($) { return unless $_[0]; my ($num) = $_[0] =~ /([+-]?(?:\d+(?:\.\d*)?|\.\d+))/; return unless $num && $num > .5; sprintf "%.0f", $num; } sub is_int ($) { return unless defined $_[0] && $_[0] ne ''; return unless $_[0] =~ /^[+-]?\d+$/; return 1; } sub to_int ($) { return unless defined $_[0] && $_[0] ne ''; my ($num) = $_[0] =~ /([+-]?(?:\d+(?:\.\d*)?|\.\d+))/; return unless defined $num; sprintf "%.0f", $num; } sub is_decimal ($) { return unless defined $_[0] && $_[0] ne ''; return unless $_[0] =~ /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/; return 1; } sub to_decimal ($;$) { return unless defined $_[0] && $_[0] ne ''; my ($num) = $_[0] =~ /([+-]?(?:\d+(?:\.\d*)?|\.\d+))/; return unless defined $num; $_[1] ||= DEF_PRECISION; sprintf "%.$_[1]f", $num; } #sub is_real ($) { # return unless defined $_[0] && $_[0] ne ''; # return unless $_[0] =~ /^[+-]?\d*\.?\d*$/; # return 1; #} #sub to_real ($) { # return unless defined $_[0] && $_[0] ne ''; # sprintf "%f", $_[0] =~ /([+-]?\d*\.?\d*)/; #} # These may need to be separated in the future, in order to identify non-decimal # real numbers. *is_real = *is_decimal; *to_real = *to_decimal; sub is_float ($) { return unless defined $_[0] && $_[0] ne ''; return unless $_[0] =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/; return 1; } sub to_float ($;$) { return unless defined $_[0] && $_[0] ne ''; my ($num) = $_[0] =~ /(([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?)/; return unless defined $num; my $type = $num =~ /e|E/ ? 'e' : 'f'; $_[1] ||= DEF_PRECISION; sprintf "%.$_[1]$type", $num; # sprintf "%g", $_[0] =~ /(([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?)/; } sub is_string ($) { defined $_[0] && ! ref $_[0] } sub to_string ($;$) { return unless defined $_[0]; return $_[1] ? substr("$_[0]", 0, $_[1]) : "$_[0]"; } 1; __END__ =head1 NAME Data::Types - Validate and convert data types. =head1 SYNOPSIS use Data::Types qw(:all); my $whole = 4.5; $whole = to_whole($whole) unless is_whole($whole); my $int = 1.2; $int = to_int($int) unless is_int($int); my $decimal = '1.2foo'; $decimal = to_decimal($decimal) unless is_decimal($decimal); my $real = '1.2foo'; $real = to_real($real) unless is_real($real); my $float = '1.2foo'; $float = to_float($float) unless is_float($float); my $string = []; $string = to_string($string) unless is_string($string); =head1 DESCRIPTION This module exports a number of functions that are useful for validating and converting data types. It is intended for use in applications where data types are more important than they typically are in Perl -- e.g., database applications. =head1 EXPORT No functions are exported by default, though each function may be exported explicitly (see L<"Functions">, below, for a list of functions available for export). The following export tags are supported: =over 4 =item :whole Exports is_whole() and to_whole(). =item :count Exports is_count() and to_count(). =item :int Exports is_int() and to_int(). =item :decimal Exports is_decimal() and to_decimal(). =item :real Exports is_real() and to_real(). =item :float Exports is_float() and to_float(). =item :string Exports is_string() and to_string(). =item :is Exports all validation functions: is_whole(), is_int(), is_real(), is_decimal(), is_float(), and is_string(). =item :to Exports all conversion functions: to_whole(), to_int(), to_real(), to_decimal(), to_float(), and to_string(). =item :all Exports all functions. =back =head1 FUNCTIONS =head2 is_whole my $bool = is_whole($val); Returns true if $val is a whole number (including 0), and false if it is not. The regular expression used to test the wholeness of $val is C. my $bool = is_whole(1); # Returns true. $bool = is_whole(-1); # Returns false. $bool = is_whole(0); # Returns true. =head2 to_whole my $whole = to_whole($val); Converts $val to a whole number and returns it. Numbers will be rounded to the nearest whole. If $val is a mixture of numbers and letters, to_whole() will extract the first decimal number it finds and convert that number to a whole number. my $whole = to_whole(10); # Returns 10. $whole = to_whole(0); # Returns 0. $whole = to_whole(.22); # Returns 0. $whole = to_whole(-2); # Returns undef. $whole = to_whole('foo3.56'); # Returns 4. $whole = to_whole('foo'); # Returns undef. =head2 is_count my $bool = is_count($val); Returns true if $val is a counting number (1, 2, 3, ...), and false if it is not. The regular expression used to test whether $val is a counting number is C. my $bool = is_count(1); # Returns true. $bool = is_count(-1); # Returns false. $bool = is_count(0); # Returns false. =head2 to_count my $count = to_count($val); Converts $val to a counting number and returns it. Numbers will be rounded to the nearest counting number. Note that since 0 (zero) is not considered a counting number by this module, it will not be returned. If $val is a mixture of numbers and letters, to_count() will extract the first decimal number it finds and convert that number to a counting number. my $count = to_count(10); # Returns 10. $count = to_count(0); # Returns undef. $count = to_count(.22); # Returns undef (rounded down to 0). $count = to_count(-2); # Returns undef. $count = to_count('foo3.56'); # Returns 4. $count = to_count('foo'); # Returns undef. =head2 is_int my $bool = is_int($val); Returns true if $val is an integer, and false if it is not. Numbers may be preceded by a plus or minus sign. The regular expression used to test for an integer in $val is C. my $bool = is_int(0); # Returns true. $bool = is_int(22); # Returns true. $bool = is_int(-22); # Returns false. $bool = is_int(3.2); # Returns false. =head2 to_int my $int = to_int($val); Converts $val to an integer. If $val is a decimal number, it will be rounded to the nearest integer. If $val is a mixture of numbers and letters, to_int() will extract the first decimal number it finds and convert that number to an integer. my $int = to_int(10.5); # Returns 10. $int = to_int(10.51); # Returns 11. $int = to_int(-0.22); # Returns 0. $int = to_int(-6.51); # Returns 7. $int = to_int('foo'); # Returns undef. =head2 is_decimal my $bool = is_decimal($val); Returns true if $val is a decimal number, and false if it is not. Numbers may be preceded by a plus or minus sign. The regular expression used to test $val is C. my $bool = is_decimal(10) # Returns true. $bool = is_decimal(10.8) # Returns true. $bool = is_decimal(-33.48) # Returns true. $bool = is_decimal((1.23e99) # Returns false. =head2 to_decimal my $dec = to_decimal($val); $dec = to_decimal($val, $precision); Converts $val to a decimal number. The optional second argument sets the precision of the number. The default precision is 5. If $val is a mixture of numbers and letters, to_decimal() will extract the first decimal number it finds. my $dec = to_decimal(0); # Returns 0.00000. $dec = to_decimal(10.5); # Returns 10.5. $dec = to_decimal(10.500009); # Returns 10.50001. $dec = to_decimal(10.500009, 7); # Returns 10.5000090. $dec = to_decimal('foo10.3') # Returns 10.30000. $dec = to_decimal('foo-4.9') # Returns -4.90000. $dec = to_decimal('foo') # Returns undef. =head2 is_real my $bool = is_real($val); Returns true if $val is a real number, and false if it is not. B This function is currently equivalent to is_decimal(), since this module cannot identify non-decimal real numbers (e.g., irrational numbers). This implementation may change in the future. =head2 to_real my $real = to_real($val); $real = to_real($val, $precision); Converts $val to a real number. B Currently, this function is the equivalent of to_decimal(), since this module cannot identify non-decimal real numbers (e.g., irrational numbers). This implementation may change in the future. =head2 is_float my $bool = is_real($val); Returns true if $val is a float, and false if it is not. The regular expression used to test $val is C. my $bool = is_real(30); # Returns true. $bool = is_real(1.23e99); # Returns true. $bool = is_real('foo'); # Returns false. =head2 to_float my $dec = to_float($val); $dec = to_float($val, $precision); Converts $val to a float. The optional second argument sets the precision of the number. The default precision is 5. If $val is a mixture of numbers and letters, to_float() will extract the first float it finds. my $float = to_float(1.23); # Returns 1.23000. $float = to_float(1.23e99); # Returns 1.23000e+99. $float = to_float(1.23e99, 1); # Returns 1.2e+99. $float = to_float('foo-1.23'); # Returns -1.23000. $float = to_float('ick_1.23e99foo'); # Returns 1.23000e+99. =head2 is_string my $bool = is_string($val); Returns true if $val is a string, and false if it is not. All defined non-references are considered strings. my $bool = is_string('foo'); # Returns true. $bool = is_string(20001); # Returns true. $bool = is_string([]); # Returns false. $bool = is_string(undef); # Returns false. =head2 to_string my $string = to_string($val); $string = to_string($val, $length); Converts $val into a string. If $val is a reference, the string value of the reference will be returned. Such a value may be a memory address, or some other value, if the stringification operator has been overridden for the object stored in $val. If the optional second argument $length is passed, to_string() will truncate the string to that length. If $length is 0 (zero), it will not limit the length of the return string. If $val is undefined, to_string() will return undef. my $string = to_string('foo'); # Returns 'foo'. $string = to_string([]); # Returns 'ARRAY(0x101bec14)'. $string = to_string(undef); # Returns undef. $string = to_string('hello', 4); # Returns 'hell'. =head1 SUPPORT This module is stored in an open L. Feel free to fork and contribute! Please file bug reports via L or by sending mail to L. Patches against Class::Meta are welcome. Please send bug reports to . =head1 AUTHOR David E. Wheeler =head1 SEE ALSO L lists the most of the regular expressions used to identify the different numeric types used in this module. L also does some data type validation. L reimplements the C C function in perl, and also does data type validation and conversion. L contains many useful common regular expressions (surprise!), including some that can be used to identify data types. Arthur Bergman's L pragma, offers compile-time data types for Perl 5.8.0. The data types include int, float, and string. I highly recommend using this prgrma for fast, static data types. =head1 COPYRIGHT AND LICENSE Copyright (c) 2002-2011, David E. Wheeler. Some Rights Reserved. This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut Data-Types-0.09/t000755000765000024 011577535512 13246 5ustar00davidstaff000000000000Data-Types-0.09/t/types.t000444000765000024 1225311577535512 14757 0ustar00davidstaff000000000000#!/usr/bin/perl -w use strict; use Test; BEGIN { plan tests => 169 }; use Data::Types qw(:all); ok(1); # If we made it this far, we're ok. ######################### # Test is_whole. ok( is_whole(10) ); ok( is_whole(22) ); ok( is_whole(1) ); ok( is_whole(700) ); ok( is_whole(0) ); ok( ! is_whole(.22) ); ok( ! is_whole(-33) ); ok( ! is_whole(-0.1) ); # Test to_whole. ok( to_whole(10) == 10 ); ok( to_whole(1) == 1 ); ok( to_whole('foo33') == 33); ok( to_whole('ri+4') == 4 ); ok( to_whole('+45ts') == 45 ); ok( to_whole(1.23e99) == 1) ; # This should probably be changed somehow. ok( to_whole(0) eq '0' ); ok( ! defined to_whole('blech') ); ok( ! defined to_whole('') ); ok( ! defined to_whole(undef) ); ok( to_whole('foo00') eq '0' ); ok( to_whole(.44) eq '0' ); ok( ! defined to_whole('foo-33') ); ok( ! defined to_whole(-44) ); ok( ! defined to_whole(-0.33) ); ok( ! defined to_whole('sep-0.1') ); # Test is_count. ok( is_count(10) ); ok( is_count(22) ); ok( is_count(1) ); ok( is_count(700) ); ok( ! is_count(0) ); ok( ! is_count(.22) ); ok( ! is_count(-33) ); ok( ! is_count(-0.1) ); # Test to_count. ok( to_count(10) == 10 ); ok( to_count(1) == 1 ); ok( to_count('foo33') == 33); ok( to_count('ri+4') == 4 ); ok( to_count('+45ts') == 45 ); ok( to_count(1.23e99) == 1) ; # This should probably be changed somehow. ok( ! defined to_count(0) ); ok( ! defined to_count('blech') ); ok( ! defined to_count('') ); ok( ! defined to_count(undef) ); ok( ! defined to_count('foo00') ); ok( ! defined to_count(.44) ); ok( ! defined to_count('foo-33') ); ok( ! defined to_count(-44) ); ok( ! defined to_count(-0.33) ); ok( ! defined to_count('sep-0.1') ); # Test is_int. ok( is_int(10) ); ok( is_int(0) ); ok( is_int(-33) ); ok( is_int(+23) ); ok( ! is_int('+') ); ok( ! is_int('-') ); ok( ! is_int(22.2) ); ok( ! is_int(0.44) ); ok( ! is_int('foo') ); ok( ! is_int('33foo') ); ok( ! is_int(-33.2) ); ok( ! is_int(undef)); ok( ! is_int('')); # Test to_int. ok( to_int(10) == 10 ); ok( to_int(10.22) == 10 ); ok( to_int(0.44) == 0 ); ok( to_int(0.54) == 1 ); ok( to_int(10.468473895043) == 10 ); ok( to_int(+10.51) == 11); ok( to_int("10.44foo") == 10 ); ok( to_int(-22) == -22 ); ok( to_int(-22.6) == -23); ok( to_int(1.23e99) == 1) ; # This should probably be changed somehow. ok( ! defined to_int(undef) ); ok( ! defined to_int('') ); ok( ! defined to_int('foo') ); # Test is_decimal. ok( is_decimal(.22) ); ok( is_decimal(0.4) ); ok( is_decimal(22.44) ); ok( is_decimal(-0.44) ); ok( is_decimal(-100.45) ); ok( is_decimal(0) ); ok( is_decimal(22) ); ok( is_decimal(-33) ); ok( is_decimal(-33.0) ); ok( ! is_decimal('+') ); ok( ! is_decimal('-') ); ok( ! is_decimal(undef) ); ok( ! is_decimal('foo') ); ok( ! is_decimal('foo22') ); ok( ! is_decimal('22foo') ); ok( ! is_decimal(1.23e99) ); # Test to_decimal. ok( to_decimal(0) == 0 ); ok( to_decimal(100) == 100 ); ok( to_decimal(0.22) == 0.22 ); ok( to_decimal(-4) == -4 ); ok( to_decimal(-3.4) == -3.4 ); ok( to_decimal('foo3.5') == 3.5 ); ok( to_decimal('-35foo') == -35 ); ok( to_decimal('foo-3') == -3 ); ok( to_decimal('40foo') == 40 ); ok( to_decimal(1.23e99) == 1.23 ); # This should probably be changed somehow. ok( to_decimal(10.500009) == 10.50001 ); ok( to_decimal(10.500009, 10) == 10.500009 ); ok( ! defined to_decimal(undef) ); ok( ! defined to_decimal('') ); ok( ! defined to_decimal('foo')); # Test is_real. ok( is_real(0) ); ok( is_real(100) ); ok( is_real(0.22) ); ok( is_real(-4) ); ok( is_real(-4.9) ); ok( is_real(12043.3423) ); ok( ! is_real('foo') ); ok( ! is_real('+') ); ok( ! is_real('-') ); ok( ! is_real(undef) ); ok( ! is_real('foo34.33') ); ok( ! is_real(1.23e99) ); # Test to_real. ok( to_real(0) == 0 ); ok( to_real(100) == 100 ); ok( to_real(0.22) == 0.22 ); ok( to_real(-4) == -4 ); ok( to_real(-3.4) == -3.4 ); ok( to_real('foo3.5') == 3.5 ); ok( to_real('-35foo') == -35 ); ok( to_real('foo-3') == -3 ); ok( to_real('40foo') == 40 ); ok( to_real(1.23e99) == 1.23 ); # This should probably be changed somehow. ok( ! defined to_real(undef) ); ok( ! defined to_real('') ); ok( ! defined to_real('foo')); # Test is_float. ok( is_float(10) ); ok( is_float(11.2) ); ok( is_float(0.2) ); ok( is_float(345.96948383) ); ok( is_float(1.23e99) ); ok( is_float(-938.54) ); ok( is_float(+234.5) ); ok( !is_float('foo') ); ok( !is_float('22.34foo') ); ok( !is_float(undef) ); ok( !is_float('+') ); ok( !is_float('-') ); ok( !is_float('') ); # Test to_float. ok( to_float(10) == 10 ); ok( to_float(11.2) == 11.2 ); ok( to_float(456.98765) == 456.98765 ); ok( to_float(0) == 0 ); ok( to_float('44.334foo') == 44.334 ); ok( to_float(-34.3) == -34.3 ); ok( to_float(+456.04) == 456.04 ); ok( to_float(1.23e99) == 1.23000e99 ); ok( to_float(1.23e99, 1) == 1.2e99 ); ok( to_float('foo1.23e99') == 1.23000e99 ); ok( ! defined to_float(undef) ); ok( ! defined to_float('') ); ok( ! defined to_float('foo')); # Test is_string. ok( is_string('foo') ); ok( is_string(4) ); my $var = []; ok( is_string("$var") ); ok( ! is_string($var) ); ok( ! is_string(undef) ); # Test is_string. ok( to_string(44) eq '44' ); ok( to_string('foo') eq 'foo' ); ok( to_string('') eq '' ); ok( to_string(0) eq '0' ); ok( to_string($var) eq "$var" ); ok( ! defined to_string(undef) ); ok( to_string('hello', 4) eq 'hell' ); __END__ Data-Types-0.09/t/zpod.t000444000765000024 30411577535512 14521 0ustar00davidstaff000000000000#!/usr/bin/perl -w # $Id$ use strict; use Test::More; eval 'use Test::Pod 1.41'; plan skip_all => 'Test::Pod 1.41 required for testing POD' if $@; all_pod_files_ok(all_pod_files('bin', 'lib'));