++ed by:

1 non-PAUSE user.

Konstantin S. Uvarin
and 2 contributors


Assert::Refute::T::Array - Assertions about arrays for Assert::Refute suite


Add array_of and is_sorted checks to both runtime checks and unit test scripts.

    use Test::More;
    use Assert::Refute qw(:core);
    use Assert::Refute::T::Array;

Testing that array consists of given values:

    array_of [ "foo", "bar", "baz" ], qr/ba/, "This fails because of foo";

    array_of [
        { id => 42, name => "Answer to life" },
        { id => 137 },
    ], contract {
        package T;
        use Assert::Refute::T::Basic;
        like $_[0]->{name}, qr/^\w+$/;
        like $_[0]->{id}, qr/^\d+$/;
    }, "This also fails";

Testing that array is ordered:

    is_sorted { $a lt $b } [sort qw(foo bar bar baz)],
        "This fails because of repetition";
    is_sorted { $a le $b } [sort qw(foo bar bar baz)],
        "This passes though";

Not only sorting, but other types of partial order can be tested:

    is_sorted { $b->{start_date} eq $a->{end_date} }, \@reservations,
        "Next reservation aligned with the previous one";


All of the below functions are exported by default:


    array_of \@list, $criteria, [ "message" ]

Check that every item in the list matches criteria, which may be one of:

  • regex - just match against regular expression;

  • a functions - execute that function inside a single subcontract;

  • Assert::Refute::Contract - pass each element as argument to a separate subcontract.


    is_sorted { $a ... $b } \@list, "message";

Check that condition about ($a, $b) holds for every two subsequent items in array.

Consider using reduce_subtest{ $a ... $b } instead if there's a complex condition inside.

map_subtest { ok $_ } \@list, "message";

Execute a subcontract that applies checks in { ... } to every element of an array.

Return value of code block is ignored.

Automatically succeeds if there are no elements.

[EXPERIMENTAL] Name and meaning may change in the future.

reduce_subtest { $a ... $b } \@list, "message";

Applies checks in { ... } to every pair of subsequent elements in list. The element with lower number is $a, and with higher number is $b.

    reduce_subtest { ... } [1,2,3,4];

would induce pairs:

    ($a = 1, $b = 2), ($a = 2, $b = 3), ($a = 3, $b = 4)

Return value of code block is ignored.

Automatically succeeds if list has less than 2 elements.

[EXPERIMENTAL] Name and meaning may change in the future.


This module is part of Assert::Refute suite.

Copyright 2017-2018 Konstantin S. Uvarin. <khedin at cpan.org>

This program is free software; you can redistribute it and/or modify it under the terms of the the Artistic License (2.0). You may obtain a copy of the full license at: