TOBYINK / Type-Tiny-2.008000 / t / 20-modules / Types-Standard / mxtmlb-alike.t 

            

              
—
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

              
=pod
=encoding utf-8
=head1 PURPOSE
Test the following types from L<Types::Standard> which were inspired by
L<MooX::Types::MooseLike::Base>.
=over
=item C<< InstanceOf >>
=item C<< ConsumerOf >>
=item C<< HasMethods >>
=item C<< Enum >>
=back
Rather than checking they work directly, we check they are equivalent to
known (and well-tested) type constraints generated using L<Type::Utils>.
=head1 AUTHOR
Toby Inkster E<lt>tobyink@cpan.orgE<gt>.
=head1 COPYRIGHT AND LICENCE
This software is copyright (c) 2013-2014, 2017-2025 by Toby Inkster.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
use strict;
use warnings;
use Test::More;
use Types::Standard -types;
use Type::Utils;
sub same_type
{
        my ($a, $b, $msg) = @_;
        $msg ||= "$a == $b";
         
        @_ = ($a->inline_check('$x'), $b->inline_check('$x'), $msg);
        goto \&Test::More::is;
}
same_type(
        InstanceOf[],
        Object,
);
same_type(
        InstanceOf["Foo"],
        class_type(Foo => {class => "Foo"}),
);
same_type(
        InstanceOf["Foo", "Bar"],
        union [
                class_type(Foo => {class => "Foo"}),
                class_type(Bar => {class => "Bar"}),
        ],
);
same_type(
        ConsumerOf[],
        Object,
);
same_type(
        ConsumerOf["Foo"],
        role_type(Foo => {role => "Foo"}),
);
same_type(
        ConsumerOf["Foo", "Bar"],
        intersection [
                role_type(Foo => {role => "Foo"}),
                role_type(Bar => {role => "Bar"}),
        ],
);
same_type(
        HasMethods[],
        Object,
);
same_type(
        HasMethods["foo"],
        duck_type(CanFoo => [qw/foo/]),
);
same_type(
        HasMethods["foo", "bar"],
        duck_type(CanFooBar => [qw/foo bar/]),
);
same_type(
        Enum[],
        Str,
);
same_type(
        Enum["foo"],
        enum(Foo => [qw/foo/]),
);
same_type(
        Enum["foo", "bar"],
        enum(Foo => [qw/foo bar/]),
);
done_testing;