Test-Version-2.09/000755 000766 000024 00000000000 13270102501 014432 5ustar00ollisgstaff000000 000000 Test-Version-2.09/LICENSE000644 000766 000024 00000021522 13270102501 015441 0ustar00ollisgstaff000000 000000 This software is Copyright (c) 2018 by Caleb Cushing. This is free software, licensed under: The Artistic License 2.0 (GPL Compatible) The Artistic License 2.0 Copyright (c) 2000-2006, The Perl Foundation. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble This license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software. You are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement. Definitions "Copyright Holder" means the individual(s) or organization(s) named in the copyright notice for the entire Package. "Contributor" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures. "You" and "your" means any person who would like to copy, distribute, or modify the Package. "Package" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version. "Distribute" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization. "Distributor Fee" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees. "Standard Version" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder. "Modified Version" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder. "Original License" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future. "Source" form means the source code, documentation source, and configuration files for the Package. "Compiled" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form. Permission for Use and Modification Without Distribution (1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version. Permissions for Redistribution of the Standard Version (2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package. (3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License. Distribution of Modified Versions of the Package as Source (4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following: (a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version. (b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version. (c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under (i) the Original License or (ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed. Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source (5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license. (6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version. Aggregating or Linking the Package (7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation. (8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package. Items That are Not Considered Part of a Modified Version (9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license. General Provisions (10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license. (11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license. (12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder. (13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed. (14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Test-Version-2.09/corpus2/000755 000766 000024 00000000000 13270102501 016027 5ustar00ollisgstaff000000 000000 Test-Version-2.09/CONTRIBUTING000644 000766 000024 00000022202 13270102501 016262 0ustar00ollisgstaff000000 000000 Checklist (and a short version for the impatient): Commits: * make sure your work applies cleanly to branch master, it is not the default branch. `git checkout * master`, you are welcome to run tests from build/master to avoid needing Dist::Zilla * make commits of logical units * check for unnecessary whitespace with "git diff --check" before committing * do not check in commented out code or unneeded files * the first line of the commit message should be a short description and should skip the full stop * the body should provide a meaningful commit message, which: * uses the imperative, present tense: "change", not "changed" or "changes". * includes motivation for the change, and contrasts its implementation with previous behaviour * if you want your work included in the main repository, add a "Signed-off-by: Your Name " line to the commit message (or just use the option "-s" when committing) to confirm that you agree to the Developer's Certificate of Origin * make sure that you have tests for the bug you are fixing * make sure that the test suite passes after your commit. This distribution is built with Dist::Zilla ensure that running `dzil test` passes. You are responsible for ensuring that generated, hand written and author tests pass. Patch: * if you change, add, or remove any features or make some other user interface change, the associated documentation should be updated as well. * if your name is not writable in ASCII, make sure that you send the patch in the correct encoding. Long version: I started reading over the SubmittingPatches document for git, primarily because I wanted to have a document similar to it for my projects to make sure people understand what they are doing when they write "Signed-off-by" line. But the patch submission requirements are a lot more relaxed here on the technical/contents front, because my projects are thousand times smaller ;-). So here is only the relevant bits. (0) Decide what to base your work on. In general, always base your work on the oldest branch that your change is relevant to. * A bugfix should be based on 'maint' in general. If the bug is not present in 'maint', base it on 'master'. For a bug that's not yet in 'master', find the topic that introduces the regression, and base your work on the tip of the topic. If a 'maint' branch is not present base it on master. * A new feature should be based on 'master' in general. If the new feature depends on a topic that is in 'pu', but not in 'master', base your work on the tip of that topic. * Corrections and enhancements to a topic not yet in 'master' should be based on the tip of that topic. If the topic has not been merged to 'next', it's alright to add a note to squash minor corrections into the series. * In the exceptional case that a new feature depends on several topics not in 'master', start working on 'next' or 'pu' privately and send out patches for discussion. Before the final merge, you may have to wait until some of the dependent topics graduate to 'master', and rebase your work. To find the tip of a topic branch, run "git log --first-parent master..pu" and look for the merge commit. The second parent of this commit is the tip of the topic branch. (1) Make separate commits for logically separate changes. Unless your patch is really trivial, you should not be sending out a patch that was generated between your working tree and your commit head. Instead, always make a commit with complete commit message and generate a series of patches from your repository. It is a good discipline. Describe the technical detail of the change(s). If your description starts to get too long, that's a sign that you probably need to split up your commit to finer grained pieces. That being said, patches which plainly describe the things that help reviewers check the patch, and future maintainers understand the code, are the most beautiful patches. Descriptions that summarise the point in the subject well, and describe the motivation for the change, the approach taken by the change, and if relevant how this differs substantially from the prior version, can be found on Usenet archives back into the late 80's. Consider it like good Netiquette, but for code. Oh, another thing. I am picky about whitespaces. Make sure your changes do not trigger errors with the sample pre-commit hook shipped in templates/hooks--pre-commit. To help ensure this does not happen, run git diff --check on your changes before you commit. (2) Generate your patch using git tools out of your commits. git based diff tools (git, Cogito, and StGIT included) generate unidiff which is the preferred format. You do not have to be afraid to use -M option to "git diff" or "git format-patch", if your patch involves file renames. The receiving end can handle them just fine. Please make sure your patch does not include any extra files which do not belong in a patch submission. Make sure to review your patch after generating it, to ensure accuracy. Before sending out, please make sure it cleanly applies to the "master" branch head. If you are preparing a work based on "next" branch, that is fine, but please mark it as such. (4) Sign your work To improve tracking of who did what, we've borrowed the "sign-off" procedure from the Linux kernel project on patches that are being emailed around. Although this project is a lot smaller it is a good discipline to follow it. The sign-off is a simple line at the end of the explanation for the patch, which certifies that you wrote it or otherwise have the right to pass it on as a open-source patch. The rules are pretty simple: if you can certify the below: Developer's Certificate of Origin 1.1 By making a contribution to this project, I certify that: (a) The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or (b) The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or (c) The contribution was provided directly to me by some other person who certified (a), (b) or (c) and I have not modified it. (d) I understand and agree that this project and the contribution are public and that a record of the contribution (including all personal information I submit with it, including my sign-off) is maintained indefinitely and may be redistributed consistent with this project or the open source license(s) involved. then you just add a line saying Signed-off-by: Random J Developer This line can be automatically added by git if you run the git-commit command with the -s option. Notice that you can place your own Signed-off-by: line when forwarding somebody else's patch with the above rules for D-C-O. Indeed you are encouraged to do so. Also notice that a real name is used in the Signed-off-by: line. Please don't hide your real name. Some people also put extra tags at the end. "Acked-by:" says that the patch was reviewed by the person who is more familiar with the issues and the area the patch attempts to modify. "Tested-by:" says the patch was tested by the person and found to have the desired effect. An ideal patch flow Here is an ideal patch flow for this project the current maintainer suggests to the contributors: 0. You come up with an itch. You code it up. 1. Send it to the bug tracker and cc people who may need to know about the change. The people who may need to know are the ones whose code you are butchering. These people happen to be the ones who are most likely to be knowledgeable enough to help you, but they have no obligation to help you (i.e. you ask for help, don't demand). "git log -p -- $area_you_are_modifying" would help you find out who they are. 2. You get comments and suggestions for improvements. You may even get them in a "on top of your change" patch form. 3. Polish, refine, and re-send to the the people who spend their time to improve your patch. Go back to step (2). 4. A topic branch is created with the patch and is merged to 'next', and cooked further and eventually graduates to 'master'. In any time between the (2)-(3) cycle, the maintainer may pick it up from the list and queue it to 'pu', in order to make it easier for people play with it without having to pick up and apply the patch to their trees themselves. Know the status of your patch after submission * You can use Git itself to find out when your patch is merged in master. 'git pull --rebase' will automatically skip already-applied patches, and will let you know. This works only if you rebase on top of the branch in which your patch has been merged (i.e. it will not tell you if your patch is merged in pu if you rebase on top of master). Test-Version-2.09/Changes000644 000766 000024 00000010176 13270102501 015732 0ustar00ollisgstaff000000 000000 Revision history for Test-Version 2.09 2018-04-25 - Production release identical to 2.08_02 release 2.08_02 2018-04-24 - Handle common special characters on Windows in taint mode 2.08_01 2018-04-23 - Diagnostic release 2.07 2018-02-21 - Fix tests to work with -T on Strawberry / MSWin32 Perl 2.06_01 2017-11-12 - Support running in taint mode (Damyan Ivanov++) 2.05 2016-09-17 - Bump requirement for newer version of Module::Metadata (again) Required for ignore_unindexable 2.04 2016-06-22 - Bump requirement for a newer version of Module::Metadata (the version that comes with Perl 5.14 cannot handle package block syntax) 2.03 2015-06-29 - Remove annoying warnings when version_ok called by itself GH #5 (DROLSKY) 2.02 2015-06-17 - Production release identical to 2.01_01 release 2.01_01 2015-06-15 - Added 'multiple' option to check each version inside a .pm file with multiple packages. 2.01 2015-05-19 - Fix failing test in t/all-generated.t 2.00 2015-05-06 - Added filename_match setting 1.05 2015-05-05 - New maintainer (PLICEASE) updated meta 1.004001 2014-10-20 - improved consistent check diagnostics GH #11 (SZABGAB) 1.004000 2014-10-18 - add consistent check GH #10 (SZABGAB) 1.003001 2014-09-06 - remove inline and remove _get_version, trying to skip test there won't work GH #4 (ETHER) 1.003000 2014-09-05 - skip packages unindexable by pause GH #4 (ETHER) 1.002004 2013-11-21 - fix bugs in argument handling - fix whitespace 1.002003 2013-10-14 - fix misgithap - more dist.ini updates 1.002002 2013-10-14 - fix synopsis GH #6, #7 ( plicease ) - change Dist::Zilla Plugins - remove old documentation that no longer applies 1.002001 2012-03-14 - fix metadata caused by a bug in DZP::GitHub after asking repo to be unlinked from gitpan. 1.002000 2012-01-09 - use Module::Metadata - allow disabling of 'has_version' - require at least 1 version - allow for checking that a module is_strict 1.001003 2011-12-01 - use Module::Metadata apparently it's closer to how Perl works than Module::Extract::VERSION 1.001002 2011-11-02 - fix some issues in the pod 1.001001 2011-11-01 - provide is_strict setting to replace STRICTNESS - provide has_version setting to disable that a module must always have a version - use perl decimal style semantic versioning because of bugs in EUMM with vstring versions v1.1.0 2011-08-14 - check if versions are strict - provide STRICTNESS settings to decide what to do if they aren't strict 1.0.0 2011-07-01 - Change to Semantic Versioning - Consider API Stable - No real changes since version 0.11 0.11 2011-06-18 - correct the version of version.pm that we need to depend on. is_lax was not properly exported until version 0.86 0.10 2011-06-08 - fix warning on bad api call #1 - make diagnostics human readable #1 - remove diagnostics from pod #1 - change return values #1 - improve tests #1 0.09 2011-06-07 - Test for FILE_NOT_DEFINED was not actually included in the last release. Add it. 0.08 2011-06-04 - test NO_FILE and FILE_NOT_DEFINED - document only use 0.04 or later - fix 04-all.t test that compares the arrays 0.07 2011-05-29 - more documentation - don't use diag for VERSION_OK status 0.06 2011-05-28 - update diag messages - check that $file exists - switch to Test::Tester exclusively - fix 04-all.t from failing due to array order being random 0.05 2011-05-27 - switch to Test::Tester for some tests. - update changelog for 0.04 due to leaving featurelist out 0.04 2011-05-26 - Release new codebase as a trial version - Ability to iterate through a directory checking versions with version_all_ok() - validate versions with is_lax 0.03 2011-05-26 - Maintainership passed to Caleb Cushing - Deprecate "expected" parameter to version_ok - Switch to Dist::Zilla for release management 0.02 2002-11-18 - removed rogue 'plan' statement in Version.pm, which was causing test failure 0.01 2002-11-17 - original version; created by h2xs 1.21 with options -AX Test::Version Test-Version-2.09/corpus/000755 000766 000024 00000000000 13270102501 015745 5ustar00ollisgstaff000000 000000 Test-Version-2.09/MANIFEST000644 000766 000024 00000002533 13270102501 015566 0ustar00ollisgstaff000000 000000 # This file was automatically generated by Dist::Zilla::Plugin::Manifest v6.011. CONTRIBUTING Changes LICENSE MANIFEST META.json META.yml Makefile.PL README corpus/consistent/Bar.pm corpus/consistent/Foo.pm corpus/fail/FooBarBaz.pm corpus/generated/Foo.pm corpus/generated/Foo/ConfigData.pm corpus/generated/Foo/Install/Files.pm corpus/inconsistent/Bar.pm corpus/inconsistent/Foo.pm corpus/missing/Bar.pm corpus/missing/Baz.pm corpus/missing/Foo.pm corpus/multiple-inconsistent/Foo.pm corpus/multiple-missing/Foo.pm corpus/multiple/Foo.pm corpus/not_strict/NotStrict.pm corpus/noversion/FooBar.pm corpus/pass/Foo.pm corpus2/mswin32/(withparan)/lib/Foo.pm 'corpus2/mswin32/dir with space/lib/Foo.pm' corpus2/mswin32/veryveryveryveryveryveryverylongdirname/lib/Foo.pm lib/Test/Version.pm perlcritic.rc t/00-compile.t t/00-report-prereqs.dd t/00-report-prereqs.t t/all-generated.t t/all-has-version-false.t t/all.t t/at-least-one-version.t t/bare.t t/consistent.t t/fail.t t/file-not-defined.t t/inconsistent.t t/missing-has-version.t t/missing.t t/mswin32.t t/multiple-inconsistent.t t/multiple.t t/no-file.t t/noversion.t t/pass.t t/strict.t t/taint-workaround.t xt/author/critic.t xt/author/eol.t xt/author/minimum-version.t xt/author/pod-coverage.t xt/author/pod-syntax.t xt/author/portability.t xt/author/test-version.t xt/release/cpan-changes.t xt/release/meta-json.t Test-Version-2.09/perlcritic.rc000644 000766 000024 00000000122 13270102501 017113 0ustar00ollisgstaff000000 000000 severity = 3 verbose = 9 [Subroutines::ProhibitExcessComplexity] max_mccabe = 40 Test-Version-2.09/t/000755 000766 000024 00000000000 13270102501 014675 5ustar00ollisgstaff000000 000000 Test-Version-2.09/xt/000755 000766 000024 00000000000 13270102501 015065 5ustar00ollisgstaff000000 000000 Test-Version-2.09/README000644 000766 000024 00000010720 13270102501 015312 0ustar00ollisgstaff000000 000000 NAME Test::Version - Check to see that version's in modules are sane VERSION version 2.09 SYNOPSIS use Test::More; use Test::Version 1.001001 qw( version_all_ok ), { is_strict => 0, has_version => 1, consistent => 1, }; # test blib or lib by default version_all_ok(); done_testing; DESCRIPTION This module's goal is to be a one stop shop for checking to see that your versions across your dist are sane. Please ensure that you use version 0.04 or later only, as earlier versions are old code and may not work correctly. Current feature list: module has a version Tests to insure that all modules checked have a VERSION defined, Can replace Test::HasVersion module has a valid version Tests to insure that all versions are valid, according to the rules of version method is_lax. To quote: The lax criteria corresponds to what is currently allowed by the version parser. All of the following formats are acceptable for dotted-decimal formats strings: v1.2 1.2345.6 v1.23_4 1.2345 1.2345_01 If you want to limit yourself to a much more narrow definition of what a version string constitutes, is_strict() is limited to version strings like the following list: v1.234.5 2.3456 you can cause your tests to fail if not strict by setting is_strict to 1 FUNCTIONS version_ok version_ok( $filename, [ $name ] ); Test a single .pm file by passing a path to the function. Checks if the module has a version, and that it is valid with is_lax. version_all_ok version_all_ok( [ $directory, [ $name ]] ); Test all modules in a directory with version_ok. By default it will check blib or lib if you haven't passed it a directory. CONFIGURATION AND ENVIRONMENT has_version use Test::Version qw( version_all_ok ), { has_version => 0 }; Allows disabling whether a module has to have a version. If set to 0 version tests will be skipped in any module where no version is found. really doesn't make sense to use with just version_ok is_strict use Test::Version { is_strict => 1 }; this allows enabling of versions is_strict checks to ensure that your version is strict. consistent use Test::Version { consistent => 1 }; Check if every module has the same version number. ignore_unindexable use Test::Version { ignore_unindexable => 0}; if you have at least Module::Metadata v1.000020 Test::Version will by default skip any files not considered is_indexable filename_match use Test::Version 2.0 { filename_match => [qr{Foo/Bar.pm$}] }; Only test files that match the given pattern. Pattern may be a list of strings, regular expressions or code references. The filename will match if it matches one or more patterns. string The file matches if it matches the pattern string exactly. regular expression The file matches if it matches the regular expression. code reference The file matches if the code reference returns a true value. The filename is passed in as the only argument to the code reference. multiple use Test::Version 2.02 { multiple => 1 }; Test each version for each package if multiple packages are found in a file. SEE ALSO The goal is to have the functionality of all of these. Test::HasVersion Test::ConsistentVersion Test::GreaterVersion If you are using Dist::Zilla there is a plugin Dist::Zilla::Plugin::Test::Version BUGS Please report any bugs or feature requests on the bugtracker website https://github.com/plicease/test-version/issues When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature. CONTRIBUTORS * Damyan Ivanov * Dave Rolsky * Gabor Szabo * Karen Etheridge * Michael G. Schwern * Mike Doherty * particle AUTHORS * Graham Ollis * Caleb Cushing COPYRIGHT AND LICENSE This software is Copyright (c) 2018 by Caleb Cushing. This is free software, licensed under: The Artistic License 2.0 (GPL Compatible) Test-Version-2.09/META.yml000644 000766 000024 00000002663 13270102501 015712 0ustar00ollisgstaff000000 000000 --- abstract: "Check to see that version's in modules are sane" author: - 'Graham Ollis ' - 'Caleb Cushing ' build_requires: Cwd: '0' ExtUtils::MakeMaker: '0' File::Find: '0' File::Spec: '0' File::Temp: '0' IO::Handle: '0' IPC::Open3: '0' Test::Exception: '0' Test::More: '0.94' Test::Tester: '0' configure_requires: ExtUtils::MakeMaker: '0' dynamic_config: 0 generated_by: 'Dist::Zilla version 6.011, CPAN::Meta::Converter version 2.150010' license: artistic_2 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Test-Version no_index: directory: - corpus file: - perlcritic.rc requires: Carp: '0' Exporter: '0' File::Find::Rule::Perl: '0' Module::Metadata: '1.000020' Test::Builder: '0' Test::More: '0.94' parent: '0' perl: '5.006' strict: '0' version: '0.86' warnings: '0' resources: bugtracker: https://github.com/plicease/test-version/issues homepage: https://metacpan.org/dist/Test-Version repository: git://github.com/plicease/test-version.git version: '2.09' x_contributors: - 'Damyan Ivanov ' - 'Dave Rolsky ' - 'Gabor Szabo ' - 'Karen Etheridge ' - 'Michael G. Schwern ' - 'Mike Doherty ' - 'particle ' x_serialization_backend: 'YAML::Tiny version 1.73' Test-Version-2.09/lib/000755 000766 000024 00000000000 13270102501 015200 5ustar00ollisgstaff000000 000000 Test-Version-2.09/Makefile.PL000644 000766 000024 00000003610 13270102501 016404 0ustar00ollisgstaff000000 000000 # This file was automatically generated by Dist::Zilla::Plugin::MakeMaker v6.011. use strict; use warnings; use 5.006; use ExtUtils::MakeMaker; my %WriteMakefileArgs = ( "ABSTRACT" => "Check to see that version's in modules are sane", "AUTHOR" => "Graham Ollis , Caleb Cushing ", "CONFIGURE_REQUIRES" => { "ExtUtils::MakeMaker" => 0 }, "DISTNAME" => "Test-Version", "LICENSE" => "artistic_2", "MIN_PERL_VERSION" => "5.006", "NAME" => "Test::Version", "PREREQ_PM" => { "Carp" => 0, "Exporter" => 0, "File::Find::Rule::Perl" => 0, "Module::Metadata" => "1.000020", "Test::Builder" => 0, "Test::More" => "0.94", "parent" => 0, "strict" => 0, "version" => "0.86", "warnings" => 0 }, "TEST_REQUIRES" => { "Cwd" => 0, "ExtUtils::MakeMaker" => 0, "File::Find" => 0, "File::Spec" => 0, "File::Temp" => 0, "IO::Handle" => 0, "IPC::Open3" => 0, "Test::Exception" => 0, "Test::More" => "0.94", "Test::Tester" => 0 }, "VERSION" => "2.09", "test" => { "TESTS" => "t/*.t" } ); my %FallbackPrereqs = ( "Carp" => 0, "Cwd" => 0, "Exporter" => 0, "ExtUtils::MakeMaker" => 0, "File::Find" => 0, "File::Find::Rule::Perl" => 0, "File::Spec" => 0, "File::Temp" => 0, "IO::Handle" => 0, "IPC::Open3" => 0, "Module::Metadata" => "1.000020", "Test::Builder" => 0, "Test::Exception" => 0, "Test::More" => "0.94", "Test::Tester" => 0, "parent" => 0, "strict" => 0, "version" => "0.86", "warnings" => 0 ); unless ( eval { ExtUtils::MakeMaker->VERSION(6.63_03) } ) { delete $WriteMakefileArgs{TEST_REQUIRES}; delete $WriteMakefileArgs{BUILD_REQUIRES}; $WriteMakefileArgs{PREREQ_PM} = \%FallbackPrereqs; } delete $WriteMakefileArgs{CONFIGURE_REQUIRES} unless eval { ExtUtils::MakeMaker->VERSION(6.52) }; WriteMakefile(%WriteMakefileArgs); Test-Version-2.09/META.json000644 000766 000024 00000005563 13270102501 016064 0ustar00ollisgstaff000000 000000 { "abstract" : "Check to see that version's in modules are sane", "author" : [ "Graham Ollis ", "Caleb Cushing " ], "dynamic_config" : 0, "generated_by" : "Dist::Zilla version 6.011, CPAN::Meta::Converter version 2.150010", "license" : [ "artistic_2" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : 2 }, "name" : "Test-Version", "no_index" : { "directory" : [ "corpus" ], "file" : [ "perlcritic.rc" ] }, "prereqs" : { "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "develop" : { "requires" : { "Pod::Coverage::TrustPod" : "0", "Test::CPAN::Changes" : "0.19", "Test::CPAN::Meta::JSON" : "0.16", "Test::EOL" : "0", "Test::MinimumVersion" : "0", "Test::More" : "0.96", "Test::Perl::Critic" : "0", "Test::Pod" : "1.41", "Test::Pod::Coverage" : "1.08", "Test::Portability::Files" : "0", "Test::Version" : "1" } }, "runtime" : { "requires" : { "Carp" : "0", "Exporter" : "0", "File::Find::Rule::Perl" : "0", "Module::Metadata" : "1.000020", "Test::Builder" : "0", "Test::More" : "0.94", "parent" : "0", "perl" : "5.006", "strict" : "0", "version" : "0.86", "warnings" : "0" } }, "test" : { "recommends" : { "CPAN::Meta" : "2.120900" }, "requires" : { "Cwd" : "0", "ExtUtils::MakeMaker" : "0", "File::Find" : "0", "File::Spec" : "0", "File::Temp" : "0", "IO::Handle" : "0", "IPC::Open3" : "0", "Test::Exception" : "0", "Test::More" : "0.94", "Test::Tester" : "0" } } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "https://github.com/plicease/test-version/issues" }, "homepage" : "https://metacpan.org/dist/Test-Version", "repository" : { "type" : "git", "url" : "git://github.com/plicease/test-version.git", "web" : "https://github.com/plicease/test-version" } }, "version" : "2.09", "x_contributors" : [ "Damyan Ivanov ", "Dave Rolsky ", "Gabor Szabo ", "Karen Etheridge ", "Michael G. Schwern ", "Mike Doherty ", "particle " ], "x_serialization_backend" : "Cpanel::JSON::XS version 4.02" } Test-Version-2.09/lib/Test/000755 000766 000024 00000000000 13270102501 016117 5ustar00ollisgstaff000000 000000 Test-Version-2.09/lib/Test/Version.pm000644 000766 000024 00000026462 13270102501 020114 0ustar00ollisgstaff000000 000000 package Test::Version; use 5.006; use strict; use warnings; use Carp; our $VERSION = '2.09'; # VERSION use parent 'Exporter'; use Test::Builder; use version 0.86 qw( is_lax is_strict ); use File::Find::Rule::Perl; use Test::More; use Module::Metadata 1.000020; our @EXPORT = qw( version_all_ok ); ## no critic (Modules::ProhibitAutomaticExportation) our @EXPORT_OK = qw( version_ok ); my $cfg; sub import { ## no critic qw( Subroutines::RequireArgUnpacking Subroutines::RequireFinalReturn ) my @exports; foreach my $param ( @_ ) { unless ( ref( $param ) eq 'HASH' ) { push @exports, $param; } else { $cfg = $param } } $cfg->{is_strict} = defined $cfg->{is_strict} ? $cfg->{is_strict} : 0 ; $cfg->{has_version} = defined $cfg->{has_version} ? $cfg->{has_version} : 1 ; $cfg->{consistent} = defined $cfg->{consistent} ? $cfg->{consistent} : 0 ; $cfg->{filename_match} = defined $cfg->{filename_match} ? $cfg->{filename_match} : [] ; $cfg->{multiple} = defined $cfg->{multiple} ? $cfg->{multiple} : 0 ; unless(ref($cfg->{filename_match}) eq 'ARRAY') { $cfg->{filename_match} = [$cfg->{filename_match}]; } my $mmv = version->parse( $Module::Metadata::VERSION ); my $rec = version->parse( '1.000020' ); if ( $mmv >= $rec && ! defined $cfg->{ignore_unindexable} ) { $cfg->{ignore_unindexable} = 1; } __PACKAGE__->export_to_level( 1, @exports ); } my $version_counter = 0; my $version_number; my $consistent = 1; my %versions; my $test = Test::Builder->new; our $_IN_VERSION_ALL_OK = 0; our %FILE_FIND_RULE_EXTRAS = ( untaint => 1, # # the untainting pattern for Windows used by File::Find seems to be wrong. # # - cwd returns an absolute directory will usually return a volume (e.g. 'C:') # - windows file systems frequently include directorieswith parans and spaces in them # I am a little dubious that accepting them is safe. The alternative is that # this module would not be installable in a lot of environments, and I honestly # don't believe that many people are using Test::Version in taint mode on Windows # anyway, so I am weighing the risk as worth it. # - windows has short names with tildes in them (e.g. "FOO~1"). Tilde is not a # special character in windows shells anyway, so I think we should be safe there. # ($^O eq 'MSWin32' ? (untaint_pattern => qr|^(([a-zA-Z]:)?[-+@\w./\~\(\) ]+)$|x) : ()), ); sub version_ok { my ( $file, $name ) = @_; $file ||= ''; $name ||= "check version in '$file'"; croak 'No file passed to version_ok().' unless $file; croak "'$file' doesn't exist." unless -e $file; my $info = Module::Metadata->new_from_file( $file ); if ( $cfg->{ignore_unindexable} && ! $info->is_indexable) { $test->skip( "$file not indexable" ); return 0; } if(@{ $cfg->{filename_match} } > 0) { my $match = 0; foreach my $pattern (@{ $cfg->{filename_match} }) { if(ref($pattern) eq 'Regexp') { $match = 1 if $file =~ $pattern; } elsif(ref($pattern) eq 'CODE') { $match = 1 if $pattern->($file); } else { $match = 1 if $file eq $pattern; } last if $match; } unless ($match) { $test->skip( "$file does not match filename_match" ); return 0; } } my $ok = 1; my @diag; my @packages = $cfg->{multiple} ? $info->packages_inside : ($info->name); unless($_IN_VERSION_ALL_OK) { $consistent = 1; $version_number = undef; } unless($cfg->{has_version}) { @packages = grep { $info->version($_) } @packages; unless(@packages) { $test->skip(qq{No versions were found in "$file" and has_version is false}); $consistent = 0; $versions{$file}->{$info->name} = undef; return 1; } } unless(@packages) { $ok = 0; push @diag, "No packages found in '$file'"; } foreach my $package (@packages) { my $version = $info->version($package); $versions{$file}->{$package} = $version; if (not defined $version) { $consistent = 0; } $version_counter++; unless ( $version ) { $ok = 0; push @diag, "No version was found in '$file' ($package)."; next; } unless (defined $version_number) { $version_number = $version; } if ($version ne $version_number) { $consistent = 0; } unless ( is_lax( $version ) ) { $ok = 0; push @diag, "The version '$version' found in '$file' ($package) is invalid."; next; } if ( $cfg->{is_strict} ) { unless ( is_strict( $version ) ) { $ok = 0; push @diag, "The version '$version' found in '$file' ($package) is not strict."; next; } } } unless($_IN_VERSION_ALL_OK) { if($ok && ! $consistent && $cfg->{consistent}) { $ok = 0; push @diag, "The versions found in '$file' are inconsistent."; } } $test->ok( $ok, $name ); $test->diag($_) for @diag; return $ok; } sub version_all_ok { my ( $dir, $name ) = @_; $version_counter = 0; $version_number = undef; $consistent = 1; %versions = (); $dir = defined $dir ? $dir : -d 'blib' ? 'blib' : 'lib' ; croak $dir . ' does not exist, or is not a directory' unless -d $dir; # Report failure location correctly - GH #1 local $Test::Builder::Level = $Test::Builder::Level + 1; ## no critic (Variables::ProhibitPackageVars) $name ||= "all modules in $dir have valid versions"; my @files = File::Find::Rule->perl_module->extras(\%FILE_FIND_RULE_EXTRAS)->in($dir); { local $_IN_VERSION_ALL_OK = 1; foreach my $file ( @files ) { version_ok( $file ); } } if ($cfg->{consistent} and not $consistent) { $test->ok( 0, $name ); $test->diag('The version numbers in this distribution are not the same'); foreach my $file (sort keys %versions) { foreach my $package (sort keys %{ $versions{$file} }) { my $version = $versions{$file}->{$package}; $test->diag(sprintf "%10s %s (%s)", defined $version ? $version : 'undef', $file, $package); } } return; } # has at least 1 version in the dist if ( not $cfg->{has_version} and $version_counter < 1 ) { $test->ok( 0, $name ); $test->diag( 'Your dist has no valid versions defined. ' . 'Must have at least one version' ); } else { $test->ok( 1, $name ); } return; } 1; # ABSTRACT: Check to see that version's in modules are sane __END__ =pod =encoding UTF-8 =head1 NAME Test::Version - Check to see that version's in modules are sane =head1 VERSION version 2.09 =head1 SYNOPSIS use Test::More; use Test::Version 1.001001 qw( version_all_ok ), { is_strict => 0, has_version => 1, consistent => 1, }; # test blib or lib by default version_all_ok(); done_testing; =head1 DESCRIPTION This module's goal is to be a one stop shop for checking to see that your versions across your dist are sane. Please ensure that you use version C<0.04> or later only, as earlier versions are old code and may not work correctly. Current feature list: =over =item module has a version Tests to insure that all modules checked have a VERSION defined, Can replace L =item module has a valid version Tests to insure that all versions are valid, according to the rules of L method C. To quote: I v1.2 1.2345.6 v1.23_4 1.2345 1.2345_01 I v1.234.5 2.3456 you can cause your tests to fail if not strict by setting L to C<1> =back =head1 FUNCTIONS =head2 version_ok version_ok( $filename, [ $name ] ); Test a single C<.pm> file by passing a path to the function. Checks if the module has a version, and that it is valid with C. =head2 version_all_ok version_all_ok( [ $directory, [ $name ]] ); Test all modules in a directory with C. By default it will check C or C if you haven't passed it a directory. =head1 CONFIGURATION AND ENVIRONMENT =head2 has_version use Test::Version qw( version_all_ok ), { has_version => 0 }; Allows disabling whether a module has to have a version. If set to 0 version tests will be skipped in any module where no version is found. really doesn't make sense to use with just L =head2 is_strict use Test::Version { is_strict => 1 }; this allows enabling of Ls C checks to ensure that your version is strict. =head2 consistent use Test::Version { consistent => 1 }; Check if every module has the same version number. =head2 ignore_unindexable use Test::Version { ignore_unindexable => 0}; if you have at least L vC<1.000020> Test::Version will by default skip any files not considered L =head2 filename_match use Test::Version 2.0 { filename_match => [qr{Foo/Bar.pm$}] }; Only test files that match the given pattern. Pattern may be a list of strings, regular expressions or code references. The filename will match if it matches one or more patterns. =over 4 =item string The file matches if it matches the pattern string exactly. =item regular expression The file matches if it matches the regular expression. =item code reference The file matches if the code reference returns a true value. The filename is passed in as the only argument to the code reference. =back =head2 multiple use Test::Version 2.02 { multiple => 1 }; Test each version for each package if multiple packages are found in a file. =head1 SEE ALSO The goal is to have the functionality of all of these. =over =item L =item L =item L =back If you are using L there is a plugin =over =item L =back =head1 BUGS Please report any bugs or feature requests on the bugtracker website L When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature. =head1 CONTRIBUTORS =for stopwords Damyan Ivanov Dave Rolsky Gabor Szabo Karen Etheridge Michael G. Schwern Mike Doherty particle =over 4 =item * Damyan Ivanov =item * Dave Rolsky =item * Gabor Szabo =item * Karen Etheridge =item * Michael G. Schwern =item * Mike Doherty =item * particle =back =head1 AUTHORS =over 4 =item * Graham Ollis =item * Caleb Cushing =back =head1 COPYRIGHT AND LICENSE This software is Copyright (c) 2018 by Caleb Cushing. This is free software, licensed under: The Artistic License 2.0 (GPL Compatible) =cut Test-Version-2.09/xt/author/000755 000766 000024 00000000000 13270102501 016367 5ustar00ollisgstaff000000 000000 Test-Version-2.09/xt/release/000755 000766 000024 00000000000 13270102501 016505 5ustar00ollisgstaff000000 000000 Test-Version-2.09/xt/release/meta-json.t000644 000766 000024 00000000064 13270102501 020567 0ustar00ollisgstaff000000 000000 #!perl use Test::CPAN::Meta::JSON; meta_json_ok(); Test-Version-2.09/xt/release/cpan-changes.t000644 000766 000024 00000000344 13270102501 021222 0ustar00ollisgstaff000000 000000 use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::CPAN::Changes 0.012 use Test::More 0.96 tests => 1; use Test::CPAN::Changes; subtest 'changes_ok' => sub { changes_file_ok('Changes'); }; Test-Version-2.09/xt/author/critic.t000644 000766 000024 00000000201 13270102501 020022 0ustar00ollisgstaff000000 000000 #!perl use strict; use warnings; use Test::Perl::Critic (-profile => "perlcritic.rc") x!! -e "perlcritic.rc"; all_critic_ok(); Test-Version-2.09/xt/author/minimum-version.t000644 000766 000024 00000000132 13270102501 021706 0ustar00ollisgstaff000000 000000 #!perl use Test::More; use Test::MinimumVersion; all_minimum_version_from_metayml_ok(); Test-Version-2.09/xt/author/test-version.t000644 000766 000024 00000000637 13270102501 021224 0ustar00ollisgstaff000000 000000 use strict; use warnings; use Test::More; # generated by Dist::Zilla::Plugin::Test::Version 1.09 use Test::Version; my @imports = qw( version_all_ok ); my $params = { is_strict => 0, has_version => 1, multiple => 0, }; push @imports, $params if version->parse( $Test::Version::VERSION ) >= version->parse('1.002'); Test::Version->import(@imports); version_all_ok; done_testing; Test-Version-2.09/xt/author/eol.t000644 000766 000024 00000001400 13270102501 017326 0ustar00ollisgstaff000000 000000 use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::EOL 0.19 use Test::More 0.88; use Test::EOL; my @files = ( 'lib/Test/Version.pm', 't/00-compile.t', 't/00-report-prereqs.dd', 't/00-report-prereqs.t', 't/all-generated.t', 't/all-has-version-false.t', 't/all.t', 't/at-least-one-version.t', 't/bare.t', 't/consistent.t', 't/fail.t', 't/file-not-defined.t', 't/inconsistent.t', 't/missing-has-version.t', 't/missing.t', 't/mswin32.t', 't/multiple-inconsistent.t', 't/multiple.t', 't/no-file.t', 't/noversion.t', 't/pass.t', 't/strict.t', 't/taint-workaround.t' ); eol_unix_ok($_, { trailing_whitespace => 1 }) foreach @files; done_testing; Test-Version-2.09/xt/author/pod-syntax.t000644 000766 000024 00000000252 13270102501 020661 0ustar00ollisgstaff000000 000000 #!perl # This file was automatically generated by Dist::Zilla::Plugin::PodSyntaxTests. use strict; use warnings; use Test::More; use Test::Pod 1.41; all_pod_files_ok(); Test-Version-2.09/xt/author/portability.t000644 000766 000024 00000000267 13270102501 021123 0ustar00ollisgstaff000000 000000 use strict; use warnings; use Test::More; eval 'use Test::Portability::Files'; plan skip_all => 'Test::Portability::Files required for testing portability' if $@; run_tests(); Test-Version-2.09/xt/author/pod-coverage.t000644 000766 000024 00000000334 13270102501 021127 0ustar00ollisgstaff000000 000000 #!perl # This file was automatically generated by Dist::Zilla::Plugin::PodCoverageTests. use Test::Pod::Coverage 1.08; use Pod::Coverage::TrustPod; all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::TrustPod' }); Test-Version-2.09/t/noversion.t000644 000766 000024 00000000604 13270102501 017104 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester tests => 7; use Test::Version version_ok => { ignore_unindexable => 0 }; check_test( sub { version_ok( 'corpus/noversion/FooBar.pm' ); }, { ok => 0, name => q[check version in 'corpus/noversion/FooBar.pm'], diag => q[No version was found in 'corpus/noversion/FooBar.pm' (FooBar).], }, 'no version' ); Test-Version-2.09/t/missing-has-version.t000644 000766 000024 00000000763 13270102501 020775 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 1, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/missing'); } ); is( scalar(@results), 4, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [0, 0, 1, 1], 'oks are ok' ); done_testing; Test-Version-2.09/t/all.t000644 000766 000024 00000001074 13270102501 015634 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::Version version_all_ok => { ignore_unindexable => 0 }; use Test::More; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus'); } ); is( scalar(@results), 18, 'correct number of results' ); my @oks; foreach my $result ( @results ) { push @oks, $result->{ok}; } my $sorted = [ sort @oks ]; my $expected = [ ( 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) ]; note( 'unsorted oks: ', @oks ); is_deeply( $sorted, $expected, 'oks are ok' ); done_testing; Test-Version-2.09/t/all-generated.t000644 000766 000024 00000003225 13270102501 017570 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::Version qw( version_all_ok ); use Test::More tests => 5; subtest 'do not skip files by default' => sub { plan tests => 1; my(undef, @results) = run_tests( sub { version_all_ok 'corpus/generated'; }, ); #is scalar @results, 7, 'corect number of results'; my @fail = sort map { $_->{name} } grep { ! $_->{ok} } @results; is_deeply \@fail, ["check version in 'corpus/generated/Foo/ConfigData.pm'","check version in 'corpus/generated/Foo/Install/Files.pm'"], 'error in expected modules'; foreach my $result (@results) { my $name = $result->{name} || $result->{reason}; my $status = $result->{type} eq 'skip' ? 'SKIP' : $result->{ok} ? 'PASS' : 'FAIL'; note "$status $name"; } }; my %patterns = ( string => 'corpus/generated/Foo.pm', '[string]' => ['corpus/generated/Foo.pm'], regex => qr/generated\/Foo\.pm$/, sub => sub { $_[0] eq 'corpus/generated/Foo.pm' }, ); while(my($pattern_type, $pattern) = each %patterns) { subtest "match_filename $pattern_type" => sub { plan tests => 2; Test::Version->import({filename_match => $pattern}); my(undef, @results) = run_tests( sub { version_all_ok 'corpus/generated'; }, ); is scalar(grep { ! $_->{ok} } @results), 0, 'no failures'; is scalar(grep { $_->{ok} && $_->{type} eq '' } @results), 2, 'two passes'; foreach my $result (@results) { my $name = $result->{name} || $result->{reason}; my $status = $result->{type} eq 'skip' ? 'SKIP' : $result->{ok} ? 'PASS' : 'FAIL'; note "$status $name"; } } }; Test-Version-2.09/t/file-not-defined.t000644 000766 000024 00000000333 13270102501 020172 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::More; use Test::Exception; use Test::Version version_ok => { ignore_unindexable => 0 }; dies_ok { version_ok; } 'croak on bad api call'; done_testing; Test-Version-2.09/t/multiple.t000644 000766 000024 00000002333 13270102501 016716 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester tests => 3; use Test::More; use Test::Version version_ok => { multiple => 1, ignore_unindexable => 0, }; subtest 'multiple, good' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/multiple/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; }; subtest 'multiple, missing' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-missing/Foo.pm' ); }, { ok => 0, name => q[check version in 'corpus/multiple-missing/Foo.pm'], diag => 'No version was found in \'corpus/multiple-missing/Foo.pm\' (Foo::Bar).', }, 'version ok' ); ok !$ret, "version_ok() returned false on fail"; }; subtest 'multiple, inconsistent' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-inconsistent/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/multiple-inconsistent/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; }; Test-Version-2.09/t/all-has-version-false.t000644 000766 000024 00000001130 13270102501 021151 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus'); } ); is( scalar(@results), 18, 'correct number of results' ); my @oks; foreach my $result ( @results ) { push @oks, $result->{ok}; } my $sorted = [ sort @oks ]; my $expected = [ ( 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ) ]; note( 'unsorted oks: ', @oks ); is_deeply( $sorted, $expected, 'oks are ok' ); done_testing; Test-Version-2.09/t/at-least-one-version.t000644 000766 000024 00000001061 13270102501 021034 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/noversion'); } ); is( scalar(@results), 2, 'correct number of results' ); my @oks; foreach my $result ( @results ) { push @oks, $result->{ok}; } my $sorted = [ sort @oks ]; my $expected = [ ( 0, 1 ) ]; note( 'unsorted oks: ', @oks ); is_deeply( $sorted, $expected, 'oks are ok' ); done_testing; Test-Version-2.09/t/no-file.t000644 000766 000024 00000000423 13270102501 016412 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::More; use Test::Exception; use Test::Version version_ok => { ignore_unindexable => 0 }; dies_ok { version_ok( 'corpus/nofile/nofile.pm' ) } 'file "corpus/nofile/nofile.pm" does not exist' ; done_testing; Test-Version-2.09/t/missing.t000644 000766 000024 00000000763 13270102501 016541 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/missing'); } ); is( scalar(@results), 4, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [0, 1, 1, 1], 'oks are ok' ); done_testing; Test-Version-2.09/t/multiple-inconsistent.t000644 000766 000024 00000002477 13270102501 021445 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester tests => 3; use Test::More; use Test::Version version_ok => { multiple => 1, consistent => 1, ignore_unindexable => 0, }; subtest 'multiple, good' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/multiple/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; }; subtest 'multiple, missing' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-missing/Foo.pm' ); }, { ok => 0, name => q[check version in 'corpus/multiple-missing/Foo.pm'], diag => 'No version was found in \'corpus/multiple-missing/Foo.pm\' (Foo::Bar).', }, 'version ok' ); ok !$ret, "version_ok() returned false on fail"; }; subtest 'multiple, inconsistent' => sub { my $ret; check_test( sub { $ret = version_ok( 'corpus/multiple-inconsistent/Foo.pm' ); }, { ok => 0, name => q[check version in 'corpus/multiple-inconsistent/Foo.pm'], diag => 'The versions found in \'corpus/multiple-inconsistent/Foo.pm\' are inconsistent.', }, 'version ok' ); ok !$ret, "version_ok() returned false on fail"; }; Test-Version-2.09/t/00-compile.t000644 000766 000024 00000002635 13270102501 016735 0ustar00ollisgstaff000000 000000 use 5.006; use strict; use warnings; # this test was generated with Dist::Zilla::Plugin::Test::Compile 2.058 use Test::More; plan tests => 1 + ($ENV{AUTHOR_TESTING} ? 1 : 0); my @module_files = ( 'Test/Version.pm' ); # no fake home requested my @switches = ( -d 'blib' ? '-Mblib' : '-Ilib', ); use File::Spec; use IPC::Open3; use IO::Handle; open my $stdin, '<', File::Spec->devnull or die "can't open devnull: $!"; my @warnings; for my $lib (@module_files) { # see L my $stderr = IO::Handle->new; diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} } $^X, @switches, '-e', "require q[$lib]")) if $ENV{PERL_COMPILE_TEST_DEBUG}; my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]"); binmode $stderr, ':crlf' if $^O eq 'MSWin32'; my @_warnings = <$stderr>; waitpid($pid, 0); is($?, 0, "$lib loaded ok"); shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/ and not eval { +require blib; blib->VERSION('1.01') }; if (@_warnings) { warn @_warnings; push @warnings, @_warnings; } } is(scalar(@warnings), 0, 'no warnings found') or diag 'got warnings: ', ( Test::More->can('explain') ? Test::More::explain(\@warnings) : join("\n", '', @warnings) ) if $ENV{AUTHOR_TESTING}; Test-Version-2.09/t/pass.t000644 000766 000024 00000000605 13270102501 016031 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester tests => 8; use Test::More; use Test::Version version_ok => { ignore_unindexable => 0 }; my $ret; check_test( sub { $ret = version_ok( 'corpus/pass/Foo.pm' ); }, { ok => 1, name => q[check version in 'corpus/pass/Foo.pm'], diag => '', }, 'version ok' ); ok $ret, "version_ok() returned true on pass"; Test-Version-2.09/t/strict.t000644 000766 000024 00000001022 13270102501 016365 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_ok => { is_strict => 1, ignore_unindexable => 0, }; my $ret; check_test( sub { $ret = version_ok( 'corpus/not_strict/NotStrict.pm' ); }, { ok => 0, name => q[check version in 'corpus/not_strict/NotStrict.pm'], diag => qq[The version '0.1.0' found in 'corpus/not_strict/NotStrict.pm' (NotStrict) is not strict.], }, ); is $ret, 0, "version_ok() returns false unless strict"; done_testing; Test-Version-2.09/t/00-report-prereqs.t000644 000766 000024 00000013426 13270102501 020277 0ustar00ollisgstaff000000 000000 #!perl use strict; use warnings; # This test was generated by Dist::Zilla::Plugin::Test::ReportPrereqs 0.027 use Test::More tests => 1; use ExtUtils::MakeMaker; use File::Spec; # from $version::LAX my $lax_version_re = qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )? | (?:\.[0-9]+) (?:_[0-9]+)? ) | (?: v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )? | (?:[0-9]+)? (?:\.[0-9]+){2,} (?:_[0-9]+)? ) )/x; # hide optional CPAN::Meta modules from prereq scanner # and check if they are available my $cpan_meta = "CPAN::Meta"; my $cpan_meta_pre = "CPAN::Meta::Prereqs"; my $HAS_CPAN_META = eval "require $cpan_meta; $cpan_meta->VERSION('2.120900')" && eval "require $cpan_meta_pre"; ## no critic # Verify requirements? my $DO_VERIFY_PREREQS = 1; sub _max { my $max = shift; $max = ( $_ > $max ) ? $_ : $max for @_; return $max; } sub _merge_prereqs { my ($collector, $prereqs) = @_; # CPAN::Meta::Prereqs object if (ref $collector eq $cpan_meta_pre) { return $collector->with_merged_prereqs( CPAN::Meta::Prereqs->new( $prereqs ) ); } # Raw hashrefs for my $phase ( keys %$prereqs ) { for my $type ( keys %{ $prereqs->{$phase} } ) { for my $module ( keys %{ $prereqs->{$phase}{$type} } ) { $collector->{$phase}{$type}{$module} = $prereqs->{$phase}{$type}{$module}; } } } return $collector; } my @include = qw( ); my @exclude = qw( ); # Add static prereqs to the included modules list my $static_prereqs = do './t/00-report-prereqs.dd'; # Merge all prereqs (either with ::Prereqs or a hashref) my $full_prereqs = _merge_prereqs( ( $HAS_CPAN_META ? $cpan_meta_pre->new : {} ), $static_prereqs ); # Add dynamic prereqs to the included modules list (if we can) my ($source) = grep { -f } 'MYMETA.json', 'MYMETA.yml'; my $cpan_meta_error; if ( $source && $HAS_CPAN_META && (my $meta = eval { CPAN::Meta->load_file($source) } ) ) { $full_prereqs = _merge_prereqs($full_prereqs, $meta->prereqs); } else { $cpan_meta_error = $@; # capture error from CPAN::Meta->load_file($source) $source = 'static metadata'; } my @full_reports; my @dep_errors; my $req_hash = $HAS_CPAN_META ? $full_prereqs->as_string_hash : $full_prereqs; # Add static includes into a fake section for my $mod (@include) { $req_hash->{other}{modules}{$mod} = 0; } for my $phase ( qw(configure build test runtime develop other) ) { next unless $req_hash->{$phase}; next if ($phase eq 'develop' and not $ENV{AUTHOR_TESTING}); for my $type ( qw(requires recommends suggests conflicts modules) ) { next unless $req_hash->{$phase}{$type}; my $title = ucfirst($phase).' '.ucfirst($type); my @reports = [qw/Module Want Have/]; for my $mod ( sort keys %{ $req_hash->{$phase}{$type} } ) { next if $mod eq 'perl'; next if grep { $_ eq $mod } @exclude; my $file = $mod; $file =~ s{::}{/}g; $file .= ".pm"; my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC; my $want = $req_hash->{$phase}{$type}{$mod}; $want = "undef" unless defined $want; $want = "any" if !$want && $want == 0; my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required"; if ($prefix) { my $have = MM->parse_version( File::Spec->catfile($prefix, $file) ); $have = "undef" unless defined $have; push @reports, [$mod, $want, $have]; if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) { if ( $have !~ /\A$lax_version_re\z/ ) { push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)"; } elsif ( ! $full_prereqs->requirements_for( $phase, $type )->accepts_module( $mod => $have ) ) { push @dep_errors, "$mod version '$have' is not in required range '$want'"; } } } else { push @reports, [$mod, $want, "missing"]; if ( $DO_VERIFY_PREREQS && $type eq 'requires' ) { push @dep_errors, "$mod is not installed ($req_string)"; } } } if ( @reports ) { push @full_reports, "=== $title ===\n\n"; my $ml = _max( map { length $_->[0] } @reports ); my $wl = _max( map { length $_->[1] } @reports ); my $hl = _max( map { length $_->[2] } @reports ); if ($type eq 'modules') { splice @reports, 1, 0, ["-" x $ml, "", "-" x $hl]; push @full_reports, map { sprintf(" %*s %*s\n", -$ml, $_->[0], $hl, $_->[2]) } @reports; } else { splice @reports, 1, 0, ["-" x $ml, "-" x $wl, "-" x $hl]; push @full_reports, map { sprintf(" %*s %*s %*s\n", -$ml, $_->[0], $wl, $_->[1], $hl, $_->[2]) } @reports; } push @full_reports, "\n"; } } } if ( @full_reports ) { diag "\nVersions for all modules listed in $source (including optional ones):\n\n", @full_reports; } if ( $cpan_meta_error || @dep_errors ) { diag "\n*** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ***\n"; } if ( $cpan_meta_error ) { my ($orig_source) = grep { -f } 'MYMETA.json', 'MYMETA.yml'; diag "\nCPAN::Meta->load_file('$orig_source') failed with: $cpan_meta_error\n"; } if ( @dep_errors ) { diag join("\n", "\nThe following REQUIRED prerequisites were not satisfied:\n", @dep_errors, "\n" ); } pass; # vim: ts=4 sts=4 sw=4 et: Test-Version-2.09/t/inconsistent.t000644 000766 000024 00000000765 13270102501 017612 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/inconsistent'); } ); is( scalar(@results), 3, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [0, 1, 1], 'oks are ok' ); done_testing; Test-Version-2.09/t/consistent.t000644 000766 000024 00000000763 13270102501 017261 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester; use Test::More; use Test::Version version_all_ok => { has_version => 0, ignore_unindexable => 0, consistent => 1, }; my ( $premature, @results ) = run_tests( sub { version_all_ok('corpus/consistent'); } ); is( scalar(@results), 3, 'correct number of results' ); my @oks = map { $_->{ok} } @results; note( 'unsorted oks: ', @oks ); is_deeply( [sort @oks], [1, 1, 1], 'oks are ok' ); done_testing; Test-Version-2.09/t/bare.t000644 000766 000024 00000000477 13270102501 016003 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use strict; use warnings; use Test::More tests => 1; use Test::Version 'version_ok'; # if there are warnings emitted from calling # version_ok without version_all_ok then # they should be visible when testing. # a la https://github.com/plicease/Test-Version/pull/5 version_ok 'corpus/pass/Foo.pm'; Test-Version-2.09/t/00-report-prereqs.dd000644 000766 000024 00000005177 13270102501 020427 0ustar00ollisgstaff000000 000000 do { my $x = { 'configure' => { 'requires' => { 'ExtUtils::MakeMaker' => '0' } }, 'develop' => { 'requires' => { 'Pod::Coverage::TrustPod' => '0', 'Test::CPAN::Changes' => '0.19', 'Test::CPAN::Meta::JSON' => '0.16', 'Test::EOL' => '0', 'Test::MinimumVersion' => '0', 'Test::More' => '0.96', 'Test::Perl::Critic' => '0', 'Test::Pod' => '1.41', 'Test::Pod::Coverage' => '1.08', 'Test::Portability::Files' => '0', 'Test::Version' => '1' } }, 'runtime' => { 'requires' => { 'Carp' => '0', 'Exporter' => '0', 'File::Find::Rule::Perl' => '0', 'Module::Metadata' => '1.000020', 'Test::Builder' => '0', 'Test::More' => '0.94', 'parent' => '0', 'perl' => '5.006', 'strict' => '0', 'version' => '0.86', 'warnings' => '0' } }, 'test' => { 'recommends' => { 'CPAN::Meta' => '2.120900' }, 'requires' => { 'Cwd' => '0', 'ExtUtils::MakeMaker' => '0', 'File::Find' => '0', 'File::Spec' => '0', 'File::Temp' => '0', 'IO::Handle' => '0', 'IPC::Open3' => '0', 'Test::Exception' => '0', 'Test::More' => '0.94', 'Test::Tester' => '0' } } }; $x; }Test-Version-2.09/t/mswin32.t000644 000766 000024 00000002000 13270102501 016354 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::More; use Test::Version; use File::Temp qw( tempdir ); use File::Spec; use Cwd; plan skip_all => 'only on MSWin32' unless $^O eq 'MSWin32'; # # these characters are (unfortunately) rather common in # a MSWin32 file system, so we need to beable to handle # them under taint mode, since the test suite runs under # taint mode now: # # parens: ( and ) # spaces: ' ' # short names with tilde: C:/STRAWB~1/cpan/build/Test-Version-2.08_01-0 # my %tests = ( 'with parentheticals' => 'corpus2/mswin32/(withparan)', 'with space' => 'corpus2/mswin32/dir with space', 'long as short' => Win32::GetShortPathName('corpus2/mswin32/veryveryveryveryveryveryverylongdirname'), ); foreach my $name (sort keys %tests) { subtest $name => sub { my $dir = $tests{$name}; my($save) = Cwd::getcwd =~ /^(.*)$/; chdir $dir; note "dir = $dir"; eval { version_all_ok('lib') }; is $@, ''; chdir $save; }; } done_testing; Test-Version-2.09/t/taint-workaround.t000644 000766 000024 00000001351 13270102501 020372 0ustar00ollisgstaff000000 000000 use strict; use warnings; use Test::More; use File::Find; use Test::Version; use Cwd (); my $untaint_pattern = $Test::Version::FILE_FIND_RULE_EXTRAS{untaint_pattern} || $File::Find::untaint_pattern; note "untaint_pattern = $untaint_pattern"; my $cwd = Cwd::getcwd; note "Cwd::getcwd = $cwd"; diag ''; if(defined $untaint_pattern) { if($cwd =~ m|$untaint_pattern|) { note 'Looks good $cwd =~ $untaint_pattern'; } else { diag "current working directory does not match untaint pattern:"; diag "Cwd::getcwd = $cwd"; diag "untaint_pattern = $untaint_pattern"; } } else { diag "unable to determine untaint pattern."; } # make sure this test passes. Intent is only to collect diagnostics atm. ok 1; done_testing; Test-Version-2.09/t/fail.t000644 000766 000024 00000000751 13270102501 016000 0ustar00ollisgstaff000000 000000 #!/usr/bin/perl -T use 5.006; use strict; use warnings; use Test::Tester tests => 8; use Test::More; use Test::Version version_ok => { ignore_unindexable => 0 }; my $ret; check_test( sub { $ret = version_ok( 'corpus/fail/FooBarBaz.pm' ); }, { ok => 0, name => q[check version in 'corpus/fail/FooBarBaz.pm'], diag => qq[The version 'v.Inf' found in 'corpus/fail/FooBarBaz.pm' (FooBarBaz) is invalid.], }, 'version invalid' ); ok !$ret, "version_ok() returned false on fail"; Test-Version-2.09/corpus/generated/000755 000766 000024 00000000000 13270102501 017703 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/not_strict/000755 000766 000024 00000000000 13270102501 020135 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/multiple/000755 000766 000024 00000000000 13270102501 017600 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/fail/000755 000766 000024 00000000000 13270102501 016660 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/multiple-missing/000755 000766 000024 00000000000 13270102501 021247 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/noversion/000755 000766 000024 00000000000 13270102501 017767 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/multiple-inconsistent/000755 000766 000024 00000000000 13270102501 022316 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/pass/000755 000766 000024 00000000000 13270102501 016713 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/consistent/000755 000766 000024 00000000000 13270102501 020136 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/missing/000755 000766 000024 00000000000 13270102501 017416 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/inconsistent/000755 000766 000024 00000000000 13270102501 020465 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/inconsistent/Bar.pm000644 000766 000024 00000000062 13270102501 021525 0ustar00ollisgstaff000000 000000 package Bar; BEGIN { our $VERSION = '1.23'; } 1; Test-Version-2.09/corpus/inconsistent/Foo.pm000644 000766 000024 00000000062 13270102501 021544 0ustar00ollisgstaff000000 000000 package Foo; BEGIN { our $VERSION = '1.24'; } 1; Test-Version-2.09/corpus/missing/Baz.pm000644 000766 000024 00000000020 13270102501 020460 0ustar00ollisgstaff000000 000000 package Baz; 1; Test-Version-2.09/corpus/missing/Bar.pm000644 000766 000024 00000000062 13270102501 020456 0ustar00ollisgstaff000000 000000 package Bar; BEGIN { our $VERSION = '1.23'; } 1; Test-Version-2.09/corpus/missing/Foo.pm000644 000766 000024 00000000062 13270102501 020475 0ustar00ollisgstaff000000 000000 package Foo; BEGIN { our $VERSION = '1.23'; } 1; Test-Version-2.09/corpus/consistent/Bar.pm000644 000766 000024 00000000062 13270102501 021176 0ustar00ollisgstaff000000 000000 package Bar; BEGIN { our $VERSION = '1.23'; } 1; Test-Version-2.09/corpus/consistent/Foo.pm000644 000766 000024 00000000062 13270102501 021215 0ustar00ollisgstaff000000 000000 package Foo; BEGIN { our $VERSION = '1.23'; } 1; Test-Version-2.09/corpus/pass/Foo.pm000644 000766 000024 00000000061 13270102501 017771 0ustar00ollisgstaff000000 000000 package Foo; BEGIN { our $VERSION = '1.0'; } 1; Test-Version-2.09/corpus/multiple-inconsistent/Foo.pm000644 000766 000024 00000000122 13270102501 023372 0ustar00ollisgstaff000000 000000 package Foo; our $VERSION = '1.0'; package Foo::Bar; our $VERSION = '2.0'; 1; Test-Version-2.09/corpus/noversion/FooBar.pm000644 000766 000024 00000000023 13270102501 021470 0ustar00ollisgstaff000000 000000 package FooBar; 1; Test-Version-2.09/corpus/multiple-missing/Foo.pm000644 000766 000024 00000000073 13270102501 022330 0ustar00ollisgstaff000000 000000 package Foo; our $VERSION = '1.0'; package Foo::Bar; 1; Test-Version-2.09/corpus/fail/FooBarBaz.pm000644 000766 000024 00000000110 13270102501 021013 0ustar00ollisgstaff000000 000000 package FooBarBaz; BEGIN { our $VERSION = 'v9223372036854775807'; } 1; Test-Version-2.09/corpus/multiple/Foo.pm000644 000766 000024 00000000122 13270102501 020654 0ustar00ollisgstaff000000 000000 package Foo; our $VERSION = '1.0'; package Foo::Bar; our $VERSION = '1.0'; 1; Test-Version-2.09/corpus/not_strict/NotStrict.pm000644 000766 000024 00000000074 13270102501 022425 0ustar00ollisgstaff000000 000000 package NotStrict; BEGIN { our $VERSION = '0.1.0'; } 1; Test-Version-2.09/corpus/generated/Foo/000755 000766 000024 00000000000 13270102501 020426 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/generated/Foo.pm000644 000766 000024 00000000061 13270102501 020761 0ustar00ollisgstaff000000 000000 package Foo; BEGIN { our $VERSION = '1.0'; } 1; Test-Version-2.09/corpus/generated/Foo/Install/000755 000766 000024 00000000000 13270102501 022034 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus/generated/Foo/ConfigData.pm000644 000766 000024 00000000035 13270102501 022761 0ustar00ollisgstaff000000 000000 package Foo::ConfigData; 1; Test-Version-2.09/corpus/generated/Foo/Install/Files.pm000644 000766 000024 00000000041 13270102501 023427 0ustar00ollisgstaff000000 000000 package Foo::Install::Files; 1; Test-Version-2.09/corpus2/mswin32/000755 000766 000024 00000000000 13270102501 017331 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/(withparan)/000755 000766 000024 00000000000 13270102501 021447 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/dir with space/000755 000766 000024 00000000000 13270102501 022117 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/veryveryveryveryveryveryverylongdirname/000755 000766 000024 00000000000 13270102501 030002 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/veryveryveryveryveryveryverylongdirname/lib/000755 000766 000024 00000000000 13270102501 030550 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/veryveryveryveryveryveryverylongdirname/lib/Foo.pm000644 000766 000024 00000000051 13270102501 031625 0ustar00ollisgstaff000000 000000 package Foo; our $VERSION = '1.00'; 1; Test-Version-2.09/corpus2/mswin32/dir with space/lib/000755 000766 000024 00000000000 13270102501 022665 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/dir with space/lib/Foo.pm000644 000766 000024 00000000051 13270102501 023742 0ustar00ollisgstaff000000 000000 package Foo; our $VERSION = '1.00'; 1; Test-Version-2.09/corpus2/mswin32/(withparan)/lib/000755 000766 000024 00000000000 13270102501 022215 5ustar00ollisgstaff000000 000000 Test-Version-2.09/corpus2/mswin32/(withparan)/lib/Foo.pm000644 000766 000024 00000000051 13270102501 023272 0ustar00ollisgstaff000000 000000 package Foo; our $VERSION = '1.00'; 1;