/ 
Assert-Refute-0.13
River stage one • 5 direct dependents • 5 total dependents
/ Assert::Refute::T::Array

NAME

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

SYNOPSIS

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";

EXPORTS

All of the below functions are exported by default:

array_of

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

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.

LICENSE AND COPYRIGHT

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:

http://www.perlfoundation.org/artistic_license_2_0