TAP::Pa...heduler(3pm)

🌸 NAME 🌸

TAP::Parser::Scheduler — Schedule tests during parallel testing 💅

💖 VERSION 💖

Version 3.50 ✨

🎀 SYNOPSIS 🎀

use TAP::Parser::Scheduler;

🫶 DESCRIPTION 🫶

Okay bestie, this page doesn’t have a big standalone description block — it rolls straight into the methods after the heading. The scheduler is the main character here, and all the tea is below. 💖

🛠 METHODS 🛠

🌟 Class Methods 🌟

new

my $sched = TAP::Parser::Scheduler->new(tests => \@tests);
my $sched = TAP::Parser::Scheduler->new(
    tests => [ ['t/test_name.t','Test Description'], ... ],
    rules => \%rules,
);

Given tests and optional rules as input, this returns a new TAP::Parser::Scheduler object. Every member of @tests should be either a test file name, or a two-element arrayref where the first element is a test file name and the second element is a test description. By default, we’ll use the test name as the description. 🫶

The optional rules attribute gives direction on which tests should run in parallel and which should run sequentially. If no rule data structure is provided, a default data structure is used that makes every test eligible to be run in parallel:

{ par => '**' },

The rules data structure is documented more in the next section. 👑

📜 Rules data structure 📜

The rules data structure is literally the heart of the scheduler. It lets you express simple rules like “run all tests in sequence” or “run all tests in parallel except these five tests.” But the rules structure also supports glob-style pattern matching and recursive definitions, so you can also express arbitrarily complicated patterns. No cap. ✨

The rule must only have one top-level key: either 'par' for parallel or 'seq' for sequence.

Values must be either strings with possible glob-style matching, or arrayrefs of strings or hashrefs which follow this pattern recursively.

Every element in an arrayref directly below a 'par' key is eligible to be run in parallel, while values directly below a 'seq' key must be run in sequence. 💅

🧪 Rules examples 🧪

Here are some examples:

# All tests be run in parallel (the default rule)
{ par => '**' },

# Run all tests in sequence, except those starting with "p"
{ par => 't/p*.t' },

# Run all tests in parallel, except those starting with "p"
{
    seq => [
              { seq => 't/p*.t' },
              { par => '**'     },
           ],
}

# Run some  startup tests in sequence, then some parallel tests then some
# teardown tests in sequence.
{
    seq => [
        { seq => 't/startup/*.t' },
        { par => ['t/a/*.t','t/b/*.t','t/c/*.t'], }
        { seq => 't/shutdown/*.t' },
    ],
},

✅ Rules resolution ✅

• By default, all tests are eligible to be run in parallel. Specifying any of your own rules removes this one.
• “First match wins.” The first rule that matches a test will be the one that applies.
• Any test which does not match a rule will be run in sequence at the end of the run.
• The existence of a rule does not imply selecting a test. You must still specify the tests to run.
• Specifying a rule that allows tests to run in parallel does not make the run parallel. You still need to specify the number of parallel "jobs" in your Harness object. 💀

🌈 Glob-style pattern matching for rules 🌈

We implement our own glob-style pattern matching. Here are the patterns it supports:

** is any number of characters, including /, within a pathname
* is zero or more characters within a filename/directory name
? is exactly one character within a filename/directory name
{foo,bar,baz} is any of foo, bar or baz.
\ is an escape character

🚀 Instance Methods 🚀

get_all

Get a list of all remaining tests. That’s it, that’s the whole vibe. 💅

get_job

Return the next available job as a TAP::Parser::Scheduler::Job object or undef if none are available. Returns a TAP::Parser::Scheduler::Spinner if the scheduler still has pending jobs but none are available to run right now. 🌀

as_string

Return a human readable representation of the scheduling tree. For example:

my @tests = (qw{
    t/startup/foo.t
    t/shutdown/foo.t

    t/a/foo.t t/b/foo.t t/c/foo.t t/d/foo.t
});
my $sched = TAP::Parser::Scheduler->new(
    tests => \@tests,
    rules => {
        seq => [
            { seq => 't/startup/*.t' },
            { par => ['t/a/*.t','t/b/*.t','t/c/*.t'] },
            { seq => 't/shutdown/*.t' },
        ],
    },
);

Produces:

par:
  seq:
    par:
      seq:
        par:
          seq:
            't/startup/foo.t'
        par:
          seq:
            't/a/foo.t'
          seq:
            't/b/foo.t'
          seq:
            't/c/foo.t'
        par:
          seq:
            't/shutdown/foo.t'
    't/d/foo.t'

---

xoxo, bestie 💖 — this tea is from the Perl Programmers Reference Guide, source/version perl v5.42.3, dated 2026-11-03. Slay. ✨👑