7 package Test::MooseX::Types::Parameterizable::Synopsis;
10 use MooseX::Types::Parameterizable qw(Parameterizable);
11 use MooseX::Types::Moose qw(Str Int ArrayRef);
12 use MooseX::Types -declare=>[qw(Varchar)];
15 as Parameterizable[Str,Int],
17 my($string, $int) = @_;
18 $int >= length($string) ? 1:0;
20 message { "'$_' is too long" };
25 my ($arrayref, $int) = @_;
29 my $varchar_five = Varchar[5];
31 Test::More::ok $varchar_five->check('four');
32 Test::More::ok ! $varchar_five->check('verylongstrong');
34 my $varchar_ten = Varchar[10];
36 Test::More::ok $varchar_ten->check( 'X' x 9 );
37 Test::More::ok ! $varchar_ten->check( 'X' x 12 );
39 has varchar_five => (isa=>Varchar[5], is=>'ro', coerce=>1);
40 has varchar_ten => (isa=>Varchar[10], is=>'ro');
42 my $object1 = __PACKAGE__->new(
43 varchar_five => '1234',
44 varchar_ten => '123456789',
48 my $object2 = __PACKAGE__->new(
49 varchar_five => '12345678',
50 varchar_ten => '123456789',
54 Test::More::ok $@, 'There was an error';
55 Test::More::like $@, qr('12345678' is too long), 'Correct custom error';
57 my $object3 = __PACKAGE__->new(
58 varchar_five => [qw/aa bb/],
59 varchar_ten => '123456789',
62 Test::More::is $object3->varchar_five, 'aabb',
63 'coercion as expected';
67 package Test::MooseX::Types::Parameterizable::Description;
70 use MooseX::Types::Parameterizable qw(Parameterizable);
71 use MooseX::Types::Moose qw(HashRef Int);
72 use MooseX::Types -declare=>[qw(Range RangedInt)];
74 ## Minor change from docs to avoid additional test dependencies
79 return $range->{max} > $range->{min};
81 message { "Not a Valid range [ $_->{max} not > $_->{min} ] " };
84 as Parameterizable[Int, Range],
86 my ($value, $range) = @_;
87 return ($value >= $range->{min} &&
88 $value <= $range->{max});
91 Test::More::ok RangedInt([{min=>10,max=>100}])->check(50);
92 Test::More::ok !RangedInt([{min=>50, max=>75}])->check(99);
95 Test::More::ok !RangedInt([{min=>99, max=>10}])->check(10);
98 Test::More::ok $@, 'There was an error';
99 Test::More::like $@, qr(Not a Valid range), 'Correct custom error';
101 Test::More::ok RangedInt([min=>10,max=>100])->check(50);
102 Test::More::ok ! RangedInt([min=>50, max=>75])->check(99);
105 RangedInt([min=>99, max=>10])->check(10);
108 Test::More::ok $@, 'There was an error';
109 Test::More::like $@, qr(Not a Valid range), 'Correct custom error';
115 package Test::MooseX::Types::Parameterizable::Subtypes;
118 use MooseX::Types::Parameterizable qw(Parameterizable);
119 use MooseX::Types::Moose qw(HashRef Int);
120 use MooseX::Types -declare=>[qw(Range RangedInt PositiveRangedInt
121 PositiveInt PositiveRange PositiveRangedInt2 )];
123 ## Minor change from docs to avoid additional test dependencies
128 return $range->{max} > $range->{min};
130 message { "Not a Valid range [ $_->{max} not > $_->{min} ] " };
133 as Parameterizable[Int, Range],
135 my ($value, $range) = @_;
136 return ($value >= $range->{min} &&
137 $value <= $range->{max});
140 subtype PositiveRangedInt,
146 Test::More::ok PositiveRangedInt([{min=>10,max=>100}])->check(50);
147 Test::More::ok !PositiveRangedInt([{min=>50, max=>75}])->check(99);
150 Test::More::ok !PositiveRangedInt([{min=>99, max=>10}])->check(10);
153 Test::More::ok $@, 'There was an error';
154 Test::More::like $@, qr(Not a Valid range), 'Correct custom error';
156 Test::More::ok PositiveRangedInt([min=>10,max=>100])->check(50);
157 Test::More::ok ! PositiveRangedInt([min=>50, max=>75])->check(99);
160 PositiveRangedInt([min=>99, max=>10])->check(10);
163 Test::More::ok $@, 'There was an error';
164 Test::More::like $@, qr(Not a Valid range), 'Correct custom error';
166 Test::More::ok !PositiveRangedInt([{min=>-10, max=>75}])->check(-5);
168 ## Subtype of Int for positive numbers
172 my ($value, $range) = @_;
176 ## subtype Range to re-parameterize Range with subtypes. Minor change from
177 ## docs to reduce test dependencies
179 subtype PositiveRange,
180 as Range[PositiveInt],
181 message { "[ $_->{max} not > $_->{min} ] is not a positive range " };
183 ## create subtype via reparameterizing
184 subtype PositiveRangedInt2,
185 as RangedInt[PositiveRange];
187 Test::More::ok PositiveRangedInt2([{min=>10,max=>100}])->check(50);
188 Test::More::ok !PositiveRangedInt2([{min=>50, max=>75}])->check(99);
191 Test::More::ok !PositiveRangedInt2([{min=>99, max=>10}])->check(10);
194 Test::More::ok $@, 'There was an error';
195 Test::More::like $@, qr(not a positive range), 'Correct custom error';
197 Test::More::ok !PositiveRangedInt2([{min=>10, max=>75}])->check(-5);
199 ## See t/02-types-parameterizable-extended.t for remaining examples tests
208 use MooseX::Types -declare=>[qw(Set UniqueInt PositiveSet PositiveUniqueInt )];
211 as class_type("Set::Scalar");
214 as Parameterizable[Int, Set],
216 my ($int, $set) = @_;
224 ! grep { $_ < 0 } $set->members;
227 subtype PositiveUniqueInt,
228 as UniqueInt[PositiveSet];
230 my $set = Set::Scalar->new(-1,-2,1,2,3);
231 my $positive_set = Set::Scalar->new(1,2,3);
232 my $negative_set = Set::Scalar->new(-1,-2,-3);
237 ok Set->check($positive_set),
240 ok Set->check($negative_set),
243 ok !PositiveSet->check($set),
244 'Is Not a Positive Set';
246 ok PositiveSet->check($positive_set),
249 ok !PositiveSet->check($negative_set),
250 'Is Not a Positive Set';
252 ok UniqueInt([$set])->check(100),
255 ok UniqueInt([$positive_set])->check(100),
258 ok UniqueInt([$negative_set])->check(100),
261 ok UniqueInt([$set])->check(-99),
264 ok UniqueInt([$positive_set])->check(-99),
267 ok UniqueInt([$negative_set])->check(-99),
270 ok !UniqueInt([$set])->check(2),
273 ok !UniqueInt([$positive_set])->check(2),
276 ok UniqueInt([$negative_set])->check(2),
282 ok UniqueInt([$set])->check(100); ## Okay, 100 isn't in (1,2,3)
283 ok UniqueInt([$set])->check(-99); ## Okay, -99 isn't in (1,2,3)
284 ok !UniqueInt([$set])->check(2); ## Not OK, 2 is in (1,2,3)
286 ok PositiveUniqueInt([$set])->check(100); ## Okay, 100 isn't in (1,2,3)
287 ok !PositiveUniqueInt([$set])->check(-99); ## Not OK, -99 not Positive Int
288 ok !PositiveUniqueInt([$set])->check(2); ## Not OK, 2 is in (1,2,3)
290 my $negative_set = Set::Scalar->new(-1,-2,-3);
292 ok UniqueInt([$negative_set])->check(100); ## Throws exception