1Fennec(3) User Contributed Perl Documentation Fennec(3)
2
6 Fennec - A testers toolbox, and best friend
7
9 Fennec ties together several testing related modules and enhances their
10 functionality in ways you don't get loading them individually. Fennec
11 makes testing easier, and more useful.
12 CAVEAT EMPTOR
14 This module is deprecated in favor of Test2::Suite, specifically
15 Test2::Tools::Spec and Test2::Bundle::SpecDeclare.
16
18 There are 2 ways to use Fennec. You can use Fennec directly, or you can
19 use the shiny sugar-coated interface provided by the add-on module
20 Fennec::Declare.
21 VANILLA SYNTAX
23 If Devel::Declare and its awesome power of syntax specification scares
24 you, you can always write your Fennec tests in the stone age like
25 this... just don't miss any semicolons.
26 t/some_test.t:
28 package TEST::SomeTest;
30 use strict;
31 use warnings;
32 use Fennec(
34 parallel => 3,
35 test_sort => 'random',
36 );
37 # This is optional, there is a default 'new' if you do not override it.
39 sub new { ... }
40 # Test blocks are called as methods on an instance of your test package.
42 tests group_1 => sub {
43 my $self = shift;
44 ok( 1, "1 is true" );
45 };
46 test group_2 => (
48 todo => 'This is not ready yet',
49 code => sub {
50 my $self = shift;
51 ok( 0, "Not ready" );
52 }
53 );
54 # It is important to always end a Fennec test with this function call.
56 done_testing();
57 DECLARE SYNTAX
59 Note: In order to use this you MUST install Fennec::Declare which is a
60 separate distribution on cpan. This module is separate because it uses
61 the controversial Devel::Declare module.
62 t/some_test.t:
64 package TEST::SomeTest;
66 use strict;
67 use warnings;
68 use Fennec::Declare(
70 parallel => 3,
71 test_sort => 'random',
72 );
73 # This is optional, there is a default 'new' if you do not override it.
75 sub new { ... }
76 # Test blocks are called as methods on an instance of your test package.
78 tests group_1 {
79 # Note: $self is automatically shifted for you.
80 ok( $self, "Got self automatically" );
81 };
82 test group_2 ( todo => 'This is not ready yet' ) {
84 # Note: $self is automatically shifted for you.
85 ok( 0, "Not ready" );
86 }
87 # It is important to always end a Fennec test with this function call.
89 done_testing;
90
92 PROVIDED DIRECTLY BY FENNEC
93 Forking just works
94 Forking in perl tests that use Test::Builder is perilous at best.
95 Fennec initiates an Fennec::Collector class which sets up
96 Test::Builder to funnel all test results to the main thread for
97 rendering. A result of this is that forking just works.
98 Concurrency, test blocks can run in parallel
100 By default all "test" blocks are run in parallel with a cap of 3
101 concurrent processes. The process cap can be set with the
102 "parallel" import argument.
103 No need to maintain a test count
105 The test count traditionally was used to ensure your file finished
106 running instead of exiting silently too early. With Test::Builder
107 and friends this has largely been replaced with the
108 "done_testing()" function typically called at the end of tests.
109 Fennec shares this concept, but takes it further, you MUST call
110 "done_testing()" at the end of your test files. This is safer
111 because it can be used to ensure your test script ran completely.
112 Can be decoupled from Test::Builder
114 Fennec is built with the assumption that Test::Builder and tools
115 built from it will be used. However custom Fennec::Collector and
116 Fennec::Runner classes can replace this assumption with any testing
117 framework you want to use.
118 Can run specific test blocks, excluding others
120 Have you ever had a huge test that took a long time to run? Have
121 you ever needed to debug a failing test at the end of the file? How
122 many times did you need to sit through tests that didn't matter?
123 With Fennec you can specify the "FENNEC_TEST" environment variable
125 with either a line number or test block name. Only tests defined on
126 that line, or with that name will be run.
127 Predictability: Rand is always seeded with the date
129 Randomizing the order in which test blocks are run can help find
130 subtle interaction bugs. At the same time if tests are always in
131 random order you cannot reliably reproduce a failure.
132 Fennec always seeds rand with the current date. This means that on
134 any given date the test run order will always be the same. However
135 different days test different orders. You can always specify the
136 "FENNEC_SEED" environment variable to override the value used to
137 seed rand.
138 Diag output is coupled with test output
140 When you run a Fennec test with a verbose harness (prove -v) the
141 diagnostic output will be coupled with the TAP output. This is done
142 by sending both output to STDOUT. In a non-verbose harness the
143 diagnostics will be sent to STDERR per usual.
144 Works with Moose
146 All your test classes are instantiated objects. You can use Moose
147 to define these test classes. But you do not have to, you are not
148 forced to use OOP in your tests.
149 PROVIDED BY MODULES LOADED BY FENNEC
151 The 3 most common and useful Test::* modules
152 Test::More, Test::Warn, Test::Exception
153 RSPEC support
155 Those familiar with Ruby may already know about the RSPEC testing
156 process. In general you "describe" something that is to be tested,
157 then you define setup and teardown methods ("before_all",
158 "before_each", "after_all", "after_each") and then finally you test
159 "it". See the "EXAMPLES" section or Test::Workflow for more
160 details.
161 Test re-ordering, tests can run in random, sorted, or defined order.
163 When you load Fennec you can specify a test order. The default is
164 random. You can also use the order in which they are defined, or
165 sorted (alphabetically) order. If necessary you can pass in a
166 sorting function that takes a list of all test-objects as
167 arguments.
168 Provided by Test::Workflow
170 Reusable test modules
172 You can write tests in modules using Test::Workflow and then import
173 those tests into Fennec tests. This is useful if you have tests
174 that you want run in several, or even all test files.
175 Provided by Test::Workflow
177 Incredibly powerful mocking with a simple API
179 You can create classless object instances from a specification on
180 the fly, define new packages, or override existing packages.
181 Provided by Mock::Quick
183
185 Note: These can be overridden either on import, or by subclassing
186 Fennec.
187 Child - Forking for dummies
189 Child is an OO interface to forking that removes all the
190 boilderplate such as checking if the pid changed, and making sure
191 you exit the child process.
192 Mock::Quick - Mocking without the eye gouging
194 Mock::Quick is a mocking library that makes mocking easy. In
195 addition it uses a declarative style interface. Unlike most other
196 mocking libraries on CPAN, it does not make people want to gouge
197 their eyes out and curl up in the fetal position.
198 Test::Workflow - RSPEC for perl.
200 Test::Workflow is a testing library written specifically for
201 Fennec. This library provides RSPEC workflow functions and
202 structure. It can be useful on its own, but combined with Fennec it
203 gets concurrency.
204 Test::More
206 Tried and True testing module that everyone uses.
207 Test::Warn
209 Test::Warn - Test code that issues warnings.
210 Test::Exception
212 Test::Exception - Test code that throws exceptions
213
215 base => 'Some::Base'
216 Load the specified module and make it the base class for your test
217 class.
218 class => 'What::To::Test'
220 Used to specify the name of the package your test file is
221 validating. When this parameter is specified 3 things are done for
222 you: The class is automatically loaded, the $CLASS variable is
223 imported and contains the module name, and the class() subroutine
224 is defined and returns the name.
225 use Fennec class => 'Foo::Bar';
227 ok( $INC{'Foo/Bar.pm'}, "Loaded 'Foo::Bar'" );
229 is( $CLASS, 'Foo::Bar', "We have \$CLASS" );
230 is( class(), 'Foo::Bar', "We have class()" );
231 tests method => sub {
233 my $self = shift;
234 is( $self->class(), 'Foo::Bar', "We have class() method" );
235 };
236 done_testing;
238 parallel => $PROC_LIMIT
240 How many test blocks can be run in parallel. Default is 3. Set to 1
241 to fork for each test, but only run one at a time. Set to 0 to
242 prevent forking.
243 You can also set this using the $FENNEC_PARALLEL environment
245 variable.
246 debug => 1
248 Enable tracking debugging information. At the end of the Fennec run
249 it will present you with a CSV temp file. This file lists all
250 blocks that are run, and mocks that are made in sequence from top
251 to bottom. The actions are split into columns by PID. This is
252 usedul when debugging potential race-conditions when using parallel
253 testing.
254 Example:
256 26150,26151,26152,26153,26154
258 0 26150 BLOCK 54->78 child: outer_wrap, , , , ,
259 ,1 26151 BLOCK 47->52 test: class_store, , , ,
260 0 26150 MOCK Foo => (outer), , , , ,
261 0 26150 BLOCK 58->61 before_all: ba, , , , ,
262 , ,2 26152 MOCK Foo => (outer), , ,
263 , ,2 26152 BLOCK 63->66 before_each: be, , ,
264 , ,2 26152 BLOCK 68->72 test: the_check, , ,
265 , , ,3 26153 BLOCK 16->31 test: object, ,
266 , , , ,4 26154 BLOCK 33->45 test: class,
267 You can use this in a spreadsheet program, or use this command to
269 look at it in a more friendly way.
270 column -s, -t < '/path/to/tempfile' | less -#2 -S
272 collector_class => 'Fennec::Collector::TB::TempFiles'
274 Specify which collector to use. Defaults to a Test::Builder based
275 collector that uses temp files to funnel tests from child procs to
276 the parent.
277 You generally won't need to specify this, unless you use a test
279 infrastructure that is neither TAP nore Test::Builder based.
280 runner_class => 'Fennec::Runner'
282 Specify the runner class. You probably don't need this.
283 runner_params => { ... }
285 Lets you specify arguments used when Fennec::Runner is initialized.
286 skip_without => [ 'Need::This', 'And::This' ]
288 Tell Fennec to skip the test file if any of the specified modules
289 are missing.
290 test_sort => $SORT
292 Options: 'random', 'sorted', 'ordered', or a code block.
293 Code block accepts a list of Test::Workflow::Test objects.
295 utils => [ 'Test::Foo', ... ]
297 Load these modules instead of the default list.
298 If you need to specify import arguments for any specific util
300 class, you can use the class name as the key with an arrayref
301 containing the arguments.
302 use Fennec(
304 utils => [ 'Some::Module' ],
305 'Some::Module' => [ arg => $val, ... ],
306 );
307 with_tests => [ 'Reusable::Tests', 'Common::Tests' ]
309 Load these modules that have reusable tests. Reusable tests are
310 tests that are common to multiple test files.
311 seed => '...'
313 Set the random seed to be used. Defaults to current date, can be
314 overridden by the FENNEC_SEED environment variable.
315
317 FENNEC_SEED
318 Can be used to set a specific random seed
319 FENNEC_TEST
321 Can be used to tell Fennec to only run specific tests (can be given
322 a line number or a block name).
323 FENNEC_DEBUG
325 When true internal debugging is turned on.
326
328 FROM FENNEC
329 done_testing()
330 done_testing(sub { ... })
331 Should be called at the end of your test file to kick off the RSPEC
332 tests. Always returns 1, so you can use it as the last statement
333 of your module. You must only ever call this once per test file.
334 Never put tests below the done_testing call. If you want tests to
336 run AFTER the RSPEC workflow completes, you can pass done_testing a
337 coderef with the tests.
338 done_testing( sub {
340 ok( 1, "This runs after the RSPEC workflow" );
341 });
342 FROM Test::Workflow
344 See Test::Workflow or "EXAMPLES" for more details.
345 with_tests 'Module::Name';
347 Import tests from a module
348 tests $name => sub { ... };
350 tests $name => ( %params );
351 it $name => sub { ... };
352 it $name => ( %params );
353 Define a test block
354 describe $name => sub { ... };
356 Describe a set of tests (group tests and setup/teardown functions)
357 case $name => sub { ... };
359 Used to run a set of tests against multiple conditions
360 before_all $name => sub { ... };
362 Setup, run once before any tests in the describe scope run.
363 before_case $name => sub { ... };
365 Setup, run before any case blocks are run.
366 before_each $name => sub { ... };
368 after_case $name => sub { ... };
369 Setup, run once per test, just before it runs. Both run after the
370 case block (if there is one).
371 around_each $name => sub { ... };
373 Setup and/or teardown.
374 after_each $name => sub { ... };
376 Teardown, run once per test, after it finishes.
377 after_all $name => sub { ... };
379 Teardown, run once, after all tests in the describe scope complete.
380 FROM Mock::Quick
382 See Mock::Quick or "EXAMPLES" for more details.
383 my $control = qclass $CLASS => ( %PARAMS, %OVERRIDES );
385 my $control = qtakeover $CLASS => ( %PARAMS, %OVERRIDES );
386 my $control = qimplement $CLASS => ( %PARAMS, %OVERRIDES );
387 my $control = qcontrol $CLASS => ( %PARAMS, %OVERRIDES );
388 Used to define, takeover, or override parts of other packages.
389 my $obj = qobj( %PARAMS );
391 my ( $obj, $control ) = qobjc( %PARAMS );
392 my $obj = qstrict( %PARAMS );
393 my ( $obj, $control ) = qstrictc( %PARAMS );
394 Define an object specification, quickly.
395 my $clear = qclear();
397 Used to clear a field in a quick object.
398 my $meth = qmeth { ... };
400 my $meth = qmeth( sub { ... } );
401 Used to define a method for a quick object.
402 OTHER
404 See Test::More, Test::Warn, and Test::Exception
405
407 Examples can be the best form of documentation.
408 SIMPLE
410 VANILLA SYNTAX
411 t/simple.t
413 use strict;
415 use warnings;
416 use Fennec;
418 use_ok 'Data::Dumper';
420 tests dumper => sub {
422 my $VAR1;
423 is_deeply(
424 eval Dumper({ a => 1 }),
425 { a => 1 },
426 "Serialize and De-Serialize"
427 );
428 };
429 tests future => (
431 todo => "Not ready yet",
432 code => sub {
433 ok( 0, "I still have to write these" );
434 },
435 );
436 done_testing;
438 DECLARE SYNTAX
440 t/simple.t
442 use strict;
444 use warnings;
445 use Fennec::Declare;
447 use_ok 'Data::Dumper';
449 tests dumper {
451 my $VAR1;
452 is_deeply(
453 eval Dumper({ a => 1 }),
454 { a => 1 },
455 "Serialize and De-Serialize"
456 );
457 is(
459 eval { no strict; Dumper( { a => 1 } ) },
460 { a => 1 },
461 "Serialize and De-Serialize"
462 );
463 }
464 tests future( todo => "Not ready yet" ) {
466 ok( 0, "I still have to write these" );
467 }
468 done_testing;
470 RUN TESTS UNDER DIFFERENT CONDITIONS
472 This example shows 4 conditions ($letter as 'a', 'b', 'c', and 'd'). It
473 also has 2 test blocks, one that verifies $letter is a letter, the
474 other verifies it is lowercase. Each test block will be run once for
475 each condition, 2*4=8, so in total 8 tests will be run.
476 VANILLA
478 sample.t:
480 use strict;
482 use warnings;
483 use Fennec;
485 my $letter;
487 case a => sub { $letter = 'a' };
488 case b => sub { $letter = 'b' };
489 case c => sub { $letter = 'c' };
490 case d => sub { $letter = 'd' };
491 tests is_letter => sub {
493 like( $letter, qr/^[a-z]$/i, "Got a letter" );
494 };
495 tests is_lowercase => sub {
497 is( $letter, lc( $letter ), "Letter is lowercase" );
498 };
499 done_testing;
501 OBJECT ORIENTED
503 sample.t
505 use strict;
507 use warnings;
508 use Fennec;
510 sub letter {
512 my $self = shift;
513 ( $self->{letter} ) = @_ if @_;
514 return $self->{letter};
515 }
516 describe letters => sub {
518 case a => sub { shift->letter('a') };
519 case b => sub { shift->letter('b') };
520 case c => sub { shift->letter('c') };
521 case d => sub { shift->letter('d') };
522 tests is_letter => sub {
524 my $self = shift;
525 like( $self->letter, qr/^[a-z]$/i, "Got a letter" );
526 };
527 tests is_lowercase => sub {
529 my $self = shift;
530 is( $self->letter, lc( $self->letter ), "Letter is lowercase" );
531 };
532 };
533 done_testing;
535 DECLARE
537 Note: no need to shift $self, it is done for you!
539 sample.t
541 use strict;
543 use warnings;
544 use Fennec::Declare;
546 sub letter {
548 my $self = shift;
549 ( $self->{letter} ) = @_ if @_;
550 return $self->{letter};
551 }
552 describe letters {
554 case a { $self->letter('a') }
555 case b { $self->letter('b') }
557 case c { $self->letter('c') }
559 case d { $self->letter('d') }
561 tests is_letter {
563 like( $self->letter, qr/^[a-z]$/i, "Got a letter" );
564 }
565 tests is_lowercase {
567 is( $self->letter, lc( $self->letter ), "Letter is lowercase" );
568 }
569 }
570 done_testing;
572 MOCKING
574 See Mock::Quick for more details
575 OBJECT ON THE FLY
577 my $obj = qobj(
579 foo => 'foo',
580 bar => qmeth { 'bar' },
581 baz => sub { 'baz' },
582 );
583 is( $obj->foo, 'foo' );
585 is( $obj->bar, 'bar' );
586 is( ref $obj->baz, 'CODE', "baz is a method that returns a coderef" );
587 # All methods autovivify as read/write accessors:
589 lives_ok { $obj->blah( 'x' ) };
590 # use qstrict() to make an object that does not autovivify accessors.
592 SCOPE OF MOCKS IN FENNEC
594 With vanilla Mock::Quick a mock is destroyed when the control object is
596 destroyed.
597 my $control = qtakeover Foo => (blah => 'blah');
599 is( Foo->blah, 'blah', "got mock" );
600 $control = undef;
601 ok( !Foo->can('blah'), "Mock destroyed" );
602 # WITHOUT FENNEC This issues a warning, the $control object is ignored so
604 # the mock is destroyed before it can be used.
605 qtakover Foo => (blah => 'blah');
606 ok( !Foo->can('blah'), "Mock destroyed before it could be used" );
607 With the workflow support provided by Fennec, you can omit the control
609 object and let the mock be scoped implicitly.
610 tests implicit_mock_scope => sub {
612 my $self = shift;
613 can_ok( $self, 'QINTERCEPT' );
614 qtakeover Foo => (blah => sub { 'blah' });
615 is( Foo->blah, 'blah', "Mock not auto-destroyed" );
616 };
617 describe detailed_implicit_mock_scope => sub {
619 qtakeover Foo => ( outer => 'outer' );
620 ok( !Foo->can( 'outer' ), "No Leak" );
621 before_all ba => sub {
623 qtakeover Foo => ( ba => 'ba' );
624 can_ok( 'Foo', qw/outer ba/ );
625 };
626 before_each be => sub {
628 qtakeover Foo => ( be => 'be' );
629 can_ok( 'Foo', qw/outer ba be/ );
630 };
631 tests the_check => sub {
633 qtakeover Foo => ( inner => 'inner' );
634 can_ok( 'Foo', qw/outer ba be inner/ );
636 };
637 ok( !Foo->can( 'outer' ), "No Leak" );
639 ok( !Foo->can( 'ba' ), "No Leak" );
640 ok( !Foo->can( 'be' ), "No Leak" );
641 ok( !Foo->can( 'inner' ), "No Leak" );
642 };
643 TAKEOVER AN EXISTING CLASS
645 require Some::Class;
647 my $control = qtakeover 'Some::Class' => (
648 # Override some methods:
649 foo => sub { 'foo' },
650 bar => sub { 'bar' },
651 # For methods that return a simple value you don't actually need to
653 # wrap them in a sub.
654 baz => 'bat',
655 );
656 is( Some::Class->foo, 'foo' );
658 is( Some::Class->bar, 'bar' );
659 # Use the control object to make another override
661 $control->override( foo => 'FOO' );
662 is( Some::Class->foo, 'FOO' );
663 # Original class is restored when $control falls out of scope.
665 $control = undef;
666 MOCK A CLASS INSTEAD OF LOADING THE REAL ONE
668 This will prevent the real class from loading if code tries to
670 "require" or "use" it. However when the control object falls out of
671 scope you will be able to load the real one again.
672 my $control = qimplement 'Some::Class' => (
674 my_method => sub { ... }
675 simple => 'foo',
676 );
677 MOCK AN ANONYMOUS CLASS
679 my $control = qclass(
681 -with_new => 1, # Make a constructor for us
682 method => sub { ... },
683 simple => 'foo',
684 );
685 my $obj = $control->package->new;
687 REUSABLE TEST LIBRARIES
689 This is a test library that verifies your test file uses strict in the
690 first 3 lines. You can also pass "with_tests => [ 'Some::Test::Lib' ]"
691 as an import argument to Fennec. This matters because you can subclass
692 Fennec to always include this library.
693 t/test.t
695 use strict;
697 use warnings;
698 use Fennec;
699 with_tests 'Some::Test::Lib';
701 done_testing;
703 lib/Some/Test/Lib.pm
705 package Some::Test::Lib;
707 use Test::Workflow;
708 use Test::More;
709 use Scalar::Util qw/blessed/;
710 tests check_use_strict => sub {
712 my $self = shift;
713 my $class = blessed $self;
714 my $file = $class;
716 $file =~ s{::}{/}g;
717 $file .= '.pm';
718 my $full = $INC{$file};
720 ok( -e $full, "Found path and filename for $class" );
721 open( my $fh, '<', $full ) || die $!;
722 my $found = 0;
723 for ( 1 .. 3 ) {
725 $found = <$fh> =~ m/^\s*use strict;\s*$/;
726 last if $found;
727 }
728 close($fh);
729 ok( $found, "'use strict;' is in the first 3 lines of the test file" );
730 }
731 1;
733 POST TESTS
735 You cannot put any tests under "done_testing()" Doing so will cause
736 problems. However you can put tests IN done_testing.
737 use strict;
739 use warnings;
740 use Fennec;
742 my $foo = 1;
744 is( $foo, 1, "foo is 1" );
746 done_testing(
748 sub {
749 is( $foo, 1, "foo is still 1" );
750 }
751 );
752 RSPEC
754 The following test will produce output similar to the following. Keep
755 in mind that the concurrent nature of Fennec means that the lines for
756 each process may appear out of order relative to lines from other
757 processes. Lines for any given process will always be in the correct
758 order though.
759 Spacing has been added, and process output has been grouped together,
761 except for the main process to demonstrate that after_all really does
762 come last.
763 # PID OUTPUT
765 #---------------------------------------------
766 7253 describe runs long before everything else
767 7253 before_all runs first
768 7254 case runs between before_all and before_each
770 7254 before_each runs just before tests
771 7254 tests run in the middle
772 7254 after_each runs just after tests
773 7255 before_each runs just before tests
775 7255 This test inherits the before and after blocks from the parent describe.
776 7255 after_each runs just after tests
777 7253 after_all runs last.
779 sample.t
781 use strict;
783 use warnings;
784 use Fennec;
786 describe order => sub {
788 print "$$ describe runs long before everything else\n";
789 before_all setup_a => sub {
791 print "$$ before_all runs first\n";
792 };
793 case a_case => sub {
795 print "$$ case runs between before_all and before_each\n";
796 };
797 before_each setup_b => sub {
799 print "$$ before_each runs just before tests\n";
800 };
801 tests a_test => sub {
803 print "$$ tests run in the middle\n";
804 };
805 after_each teardown_b => sub {
807 print "$$ after_each runs just after tests\n";
808 };
809 after_all teardown_a => sub {
811 print "$$ after_all runs last.\n";
812 };
813 describe nested => sub {
815 tests b_test => sub {
816 print "$$ This test inherits the before/after/case blocks from the parent describe.\n";
817 };
818 };
819 };
820 done_testing;
822
824 The manual can be found here: Fennec::Manual it is a sort of Nexus for
825 documentation, including this document.
826
828 Insert this into your .vimrc file to bind the F8 key to running the
829 test block directly under your cursor. You can be on any line of the
830 test block (except in some cases the first or last line.
831 function! RunFennecLine()
833 let cur_line = line(".")
834 exe "!FENNEC_TEST='" . cur_line . "' prove -v -I lib %"
835 endfunction
836 " Go to command mode, save the file, run the current test
838 :map <F8> <ESC>:w<cr>:call RunFennecLine()<cr>
839 :imap <F8> <ESC>:w<cr>:call RunFennecLine()<cr>
840
842 The best option is to use prove with the -j flag.
843 Note: The following is no longer a recommended practice, it is however
845 still supported
846 You can also create a custom runner using a single .t file to run all
848 your Fennec tests. This has caveats though, such as not knowing which
849 test file had problems without checking the failure messages.
850 This will find all *.ft and/or *.pm modules under the t/ directory. It
852 will load and run any found. These will be run in parallel
853 t/runner.t
855 #!/usr/bin/perl
856 use strict;
857 use warnings;
858 # Paths are optional, if none are specified it defaults to 't/'
860 use Fennec::Finder( 't/' );
861 # The next lines are optional, if you have no custom configuration to apply
863 # you can jump right to 'done_testing'.
864 # Get the runner (singleton)
866 my $runner = Fennec::Finder->new;
867 $runner->parallel( 3 );
868 # You must call this.
870 run();
871
873 Chad Granum exodist7@gmail.com
874
876 Copyright (C) 2013 Chad Granum
877 Fennec is free software; Standard perl license (GPL and Artistic).
879 Fennec is distributed in the hope that it will be useful, but WITHOUT
881 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
882 FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
883perl v5.34.0 2021-07-22 Fennec(3)