[gitmo/Mouse.git] / t-failing / 050_metaclasses / 052_metaclass_compat.t

#!/usr/bin/env perl
# This is automatically generated by author/import-moose-test.pl.
# DO NOT EDIT THIS FILE. ANY CHANGES WILL BE LOST!!!
use t::lib::MooseCompat;
use strict;
use warnings;
use lib 't/lib';
use Test::More;
$TODO = q{Mouse is not yet completed};
use Test::Exception;

our $called = 0;
{
    package Foo::Trait::Constructor;
    use Mouse::Role;

    around _generate_BUILDALL => sub {
        my $orig = shift;
        my $self = shift;
        return $self->$orig(@_) . '$::called++;';
    }
}

{
    package Foo;
    use Mouse;
    Mouse::Util::MetaRole::apply_metaroles(
        for => __PACKAGE__,
        class_metaroles => {
            constructor => ['Foo::Trait::Constructor'],
        }
    );
}

Foo->new;
is($called, 0, "no calls before inlining");
Foo->meta->make_immutable;

Foo->new;
is($called, 1, "inlined constructor has trait modifications");

ok(Foo->meta->constructor_class->meta->does_role('Foo::Trait::Constructor'),
   "class has correct constructor traits");

{
    package Foo::Sub;
    use Mouse;
    extends 'Foo';
}

$called = 0;

Foo::Sub->new;
is($called, 0, "no calls before inlining");

Foo::Sub->meta->make_immutable;

Foo::Sub->new;
is($called, 1, "inherits constructor trait properly");

ok(Foo::Sub->meta->constructor_class->meta->can('does_role')
&& Foo::Sub->meta->constructor_class->meta->does_role('Foo::Trait::Constructor'),
   "subclass inherits constructor traits");

{
    package Foo2::Role;
    use Mouse::Role;
}
{
    package Foo2;
    use Mouse -traits => ['Foo2::Role'];
}
{
    package Bar2;
    use Mouse;
}
{
    package Baz2;
    use Mouse;
    my $meta = __PACKAGE__->meta;
    ::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
    ::isa_ok($meta, Foo2->meta->meta->name);
    ::lives_ok { $meta->superclasses('Bar2') } "can still set superclasses";
    ::isa_ok($meta, Bar2->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo2::Role'],
                "still have the role attached");
    ::ok(!$meta->is_immutable,
       "immutable superclass doesn't make this class immutable");
    ::lives_ok { $meta->make_immutable } "can still make immutable";
}
{
    package Foo3::Role;
    use Mouse::Role;
}
{
    package Bar3;
    use Mouse -traits => ['Foo3::Role'];
}
{
    package Baz3;
    use Mouse -traits => ['Foo3::Role'];
    my $meta = __PACKAGE__->meta;
    ::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
    ::isa_ok($meta, Foo2->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo2::Role', 'Foo3::Role'],
                "reconciled roles correctly");
    ::lives_ok { $meta->superclasses('Bar3') } "can still set superclasses";
    ::isa_ok($meta, Bar3->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo2::Role', 'Foo3::Role'],
                "roles still the same");
    ::ok(!$meta->is_immutable,
       "immutable superclass doesn't make this class immutable");
    ::lives_ok { $meta->make_immutable } "can still make immutable";
}
{
    package Quux3;
    use Mouse;
}
{
    package Quuux3;
    use Mouse -traits => ['Foo3::Role'];
    my $meta = __PACKAGE__->meta;
    ::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
    ::isa_ok($meta, Foo2->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo2::Role', 'Foo3::Role'],
                "reconciled roles correctly");
    ::lives_ok { $meta->superclasses('Quux3') } "can still set superclasses";
    ::isa_ok($meta, Quux3->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo2::Role', 'Foo3::Role'],
                "roles still the same");
    ::ok(!$meta->is_immutable,
       "immutable superclass doesn't make this class immutable");
    ::lives_ok { $meta->make_immutable } "can still make immutable";
}

{
    package Foo4::Role;
    use Mouse::Role;
}
{
    package Foo4;
    use Mouse -traits => ['Foo4::Role'];
    __PACKAGE__->meta->make_immutable;
}
{
    package Bar4;
    use Mouse;
}
{
    package Baz4;
    use Mouse;
    my $meta = __PACKAGE__->meta;
    ::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
    ::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
    ::lives_ok { $meta->superclasses('Bar4') } "can still set superclasses";
    ::isa_ok($meta, Bar4->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo4::Role'],
                "still have the role attached");
    ::ok(!$meta->is_immutable,
       "immutable superclass doesn't make this class immutable");
    ::lives_ok { $meta->make_immutable } "can still make immutable";
}
{
    package Foo5::Role;
    use Mouse::Role;
}
{
    package Bar5;
    use Mouse -traits => ['Foo5::Role'];
}
{
    package Baz5;
    use Mouse -traits => ['Foo5::Role'];
    my $meta = __PACKAGE__->meta;
    ::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
    ::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo4::Role', 'Foo5::Role'],
                "reconciled roles correctly");
    ::lives_ok { $meta->superclasses('Bar5') } "can still set superclasses";
    ::isa_ok($meta, Bar5->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo4::Role', 'Foo5::Role'],
                "roles still the same");
    ::ok(!$meta->is_immutable,
       "immutable superclass doesn't make this class immutable");
    ::lives_ok { $meta->make_immutable } "can still make immutable";
}
{
    package Quux5;
    use Mouse;
}
{
    package Quuux5;
    use Mouse -traits => ['Foo5::Role'];
    my $meta = __PACKAGE__->meta;
    ::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
    ::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo4::Role', 'Foo5::Role'],
                "reconciled roles correctly");
    ::lives_ok { $meta->superclasses('Quux5') } "can still set superclasses";
    ::isa_ok($meta, Quux5->meta->meta->name);
    ::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
                ['Foo4::Role', 'Foo5::Role'],
                "roles still the same");
    ::ok(!$meta->is_immutable,
       "immutable superclass doesn't make this class immutable");
    ::lives_ok { $meta->make_immutable } "can still make immutable";
}

{
    package Foo5::Meta::Role;
    use Mouse::Role;
}
{
    package Foo5::SuperClass::WithMetaRole;
    use Mouse -traits =>'Foo5::Meta::Role';
}
{
    package Foo5::SuperClass::After::Attribute;
    use Mouse;
}
{
    package Foo5;
    use Mouse;
    my @superclasses = ('Foo5::SuperClass::WithMetaRole');
    extends @superclasses;

    has an_attribute_generating_methods => ( is => 'ro' );

    push(@superclasses, 'Foo5::SuperClass::After::Attribute');

    ::lives_ok {
        extends @superclasses;
    } 'MI extends after_generated_methods with metaclass roles';
    ::lives_ok {
        extends reverse @superclasses;
    }
    'MI extends after_generated_methods with metaclass roles (reverse)';
}

{
    package Foo6::Meta::Role;
    use Mouse::Role;
}
{
    package Foo6::SuperClass::WithMetaRole;
    use Mouse -traits =>'Foo6::Meta::Role';
}
{
    package Foo6::Meta::OtherRole;
    use Mouse::Role;
}
{
    package Foo6::SuperClass::After::Attribute;
    use Mouse -traits =>'Foo6::Meta::OtherRole';
}
{
    package Foo6;
    use Mouse;
    my @superclasses = ('Foo6::SuperClass::WithMetaRole');
    extends @superclasses;

    has an_attribute_generating_methods => ( is => 'ro' );

    push(@superclasses, 'Foo6::SuperClass::After::Attribute');

    ::throws_ok {
        extends @superclasses;
    } qr/compat.*pristine/,
    'unsafe MI extends after_generated_methods with metaclass roles';
    ::throws_ok {
        extends reverse @superclasses;
    } qr/compat.*pristine/,
    'unsafe MI extends after_generated_methods with metaclass roles (reverse)';
}

{
    package Foo7::Meta::Trait;
    use Mouse::Role;
}

{
    package Foo7;
    use Mouse -traits => ['Foo7::Meta::Trait'];
}

{
    package Bar7;
    # in an external file
    use Mouse -traits => ['Bar7::Meta::Trait'];
    ::lives_ok { extends 'Foo7' } "role reconciliation works";
}

{
    package Bar72;
    # in an external file
    use Mouse -traits => ['Bar7::Meta::Trait2'];
    ::lives_ok { extends 'Foo7' } "role reconciliation works";
}

done_testing;
Commit	Line	Data
fde8e43f	1	#!/usr/bin/env perl
	2	# This is automatically generated by author/import-moose-test.pl.
	3	# DO NOT EDIT THIS FILE. ANY CHANGES WILL BE LOST!!!
	4	use t::lib::MooseCompat;
	5	use strict;
	6	use warnings;
	7	use lib 't/lib';
	8	use Test::More;
	9	$TODO = q{Mouse is not yet completed};
	10	use Test::Exception;
	11
	12	our $called = 0;
	13	{
	14	package Foo::Trait::Constructor;
	15	use Mouse::Role;
	16
	17	around _generate_BUILDALL => sub {
	18	my $orig = shift;
	19	my $self = shift;
	20	return $self->$orig(@_) . '$::called++;';
	21	}
	22	}
	23
	24	{
	25	package Foo;
	26	use Mouse;
	27	Mouse::Util::MetaRole::apply_metaroles(
	28	for => __PACKAGE__,
	29	class_metaroles => {
	30	constructor => ['Foo::Trait::Constructor'],
	31	}
	32	);
	33	}
	34
	35	Foo->new;
	36	is($called, 0, "no calls before inlining");
	37	Foo->meta->make_immutable;
	38
	39	Foo->new;
	40	is($called, 1, "inlined constructor has trait modifications");
	41
	42	ok(Foo->meta->constructor_class->meta->does_role('Foo::Trait::Constructor'),
	43	"class has correct constructor traits");
	44
	45	{
	46	package Foo::Sub;
	47	use Mouse;
	48	extends 'Foo';
	49	}
	50
	51	$called = 0;
	52
	53	Foo::Sub->new;
	54	is($called, 0, "no calls before inlining");
	55
	56	Foo::Sub->meta->make_immutable;
	57
	58	Foo::Sub->new;
	59	is($called, 1, "inherits constructor trait properly");
	60
	61	ok(Foo::Sub->meta->constructor_class->meta->can('does_role')
	62	&& Foo::Sub->meta->constructor_class->meta->does_role('Foo::Trait::Constructor'),
	63	"subclass inherits constructor traits");
	64
65	{
66	package Foo2::Role;
67	use Mouse::Role;
68	}
69	{
70	package Foo2;
71	use Mouse -traits => ['Foo2::Role'];
72	}
73	{
74	package Bar2;
75	use Mouse;
76	}
77	{
78	package Baz2;
79	use Mouse;
80	my $meta = __PACKAGE__->meta;
81	::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
82	::isa_ok($meta, Foo2->meta->meta->name);
83	::lives_ok { $meta->superclasses('Bar2') } "can still set superclasses";
84	::isa_ok($meta, Bar2->meta->meta->name);
85	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
86	['Foo2::Role'],
87	"still have the role attached");
88	::ok(!$meta->is_immutable,
89	"immutable superclass doesn't make this class immutable");
90	::lives_ok { $meta->make_immutable } "can still make immutable";
91	}
92	{
93	package Foo3::Role;
94	use Mouse::Role;
95	}
96	{
97	package Bar3;
98	use Mouse -traits => ['Foo3::Role'];
99	}
100	{
101	package Baz3;
102	use Mouse -traits => ['Foo3::Role'];
103	my $meta = __PACKAGE__->meta;
104	::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
105	::isa_ok($meta, Foo2->meta->meta->name);
106	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
107	['Foo2::Role', 'Foo3::Role'],
108	"reconciled roles correctly");
109	::lives_ok { $meta->superclasses('Bar3') } "can still set superclasses";
110	::isa_ok($meta, Bar3->meta->meta->name);
111	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
112	['Foo2::Role', 'Foo3::Role'],
113	"roles still the same");
114	::ok(!$meta->is_immutable,
115	"immutable superclass doesn't make this class immutable");
116	::lives_ok { $meta->make_immutable } "can still make immutable";
117	}
118	{
119	package Quux3;
120	use Mouse;
121	}
122	{
123	package Quuux3;
124	use Mouse -traits => ['Foo3::Role'];
125	my $meta = __PACKAGE__->meta;
126	::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
127	::isa_ok($meta, Foo2->meta->meta->name);
128	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
129	['Foo2::Role', 'Foo3::Role'],
130	"reconciled roles correctly");
131	::lives_ok { $meta->superclasses('Quux3') } "can still set superclasses";
132	::isa_ok($meta, Quux3->meta->meta->name);
133	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
134	['Foo2::Role', 'Foo3::Role'],
135	"roles still the same");
136	::ok(!$meta->is_immutable,
137	"immutable superclass doesn't make this class immutable");
138	::lives_ok { $meta->make_immutable } "can still make immutable";
139	}
140
141	{
142	package Foo4::Role;
143	use Mouse::Role;
144	}
145	{
146	package Foo4;
147	use Mouse -traits => ['Foo4::Role'];
148	__PACKAGE__->meta->make_immutable;
149	}
150	{
151	package Bar4;
152	use Mouse;
153	}
154	{
155	package Baz4;
156	use Mouse;
157	my $meta = __PACKAGE__->meta;
158	::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
159	::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
160	::lives_ok { $meta->superclasses('Bar4') } "can still set superclasses";
161	::isa_ok($meta, Bar4->meta->meta->name);
162	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
163	['Foo4::Role'],
164	"still have the role attached");
165	::ok(!$meta->is_immutable,
166	"immutable superclass doesn't make this class immutable");
167	::lives_ok { $meta->make_immutable } "can still make immutable";
168	}
169	{
170	package Foo5::Role;
171	use Mouse::Role;
172	}
173	{
174	package Bar5;
175	use Mouse -traits => ['Foo5::Role'];
176	}
177	{
178	package Baz5;
179	use Mouse -traits => ['Foo5::Role'];
180	my $meta = __PACKAGE__->meta;
181	::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
182	::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
183	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
184	['Foo4::Role', 'Foo5::Role'],
185	"reconciled roles correctly");
186	::lives_ok { $meta->superclasses('Bar5') } "can still set superclasses";
187	::isa_ok($meta, Bar5->meta->meta->name);
188	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
189	['Foo4::Role', 'Foo5::Role'],
190	"roles still the same");
191	::ok(!$meta->is_immutable,
192	"immutable superclass doesn't make this class immutable");
193	::lives_ok { $meta->make_immutable } "can still make immutable";
194	}
195	{
196	package Quux5;
197	use Mouse;
198	}
199	{
200	package Quuux5;
201	use Mouse -traits => ['Foo5::Role'];
202	my $meta = __PACKAGE__->meta;
203	::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
204	::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
205	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
206	['Foo4::Role', 'Foo5::Role'],
207	"reconciled roles correctly");
208	::lives_ok { $meta->superclasses('Quux5') } "can still set superclasses";
209	::isa_ok($meta, Quux5->meta->meta->name);
210	::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
211	['Foo4::Role', 'Foo5::Role'],
212	"roles still the same");
213	::ok(!$meta->is_immutable,
214	"immutable superclass doesn't make this class immutable");
215	::lives_ok { $meta->make_immutable } "can still make immutable";
216	}
217
218	{
219	package Foo5::Meta::Role;
220	use Mouse::Role;
221	}
222	{
223	package Foo5::SuperClass::WithMetaRole;
224	use Mouse -traits =>'Foo5::Meta::Role';
225	}
226	{
227	package Foo5::SuperClass::After::Attribute;
228	use Mouse;
229	}
230	{
231	package Foo5;
232	use Mouse;
233	my @superclasses = ('Foo5::SuperClass::WithMetaRole');
234	extends @superclasses;
235
236	has an_attribute_generating_methods => ( is => 'ro' );
237
238	push(@superclasses, 'Foo5::SuperClass::After::Attribute');
239
240	::lives_ok {
241	extends @superclasses;
242	} 'MI extends after_generated_methods with metaclass roles';
243	::lives_ok {
244	extends reverse @superclasses;
245	}
246	'MI extends after_generated_methods with metaclass roles (reverse)';
247	}
248
249	{
250	package Foo6::Meta::Role;
251	use Mouse::Role;
252	}
253	{
254	package Foo6::SuperClass::WithMetaRole;
255	use Mouse -traits =>'Foo6::Meta::Role';
256	}
257	{
258	package Foo6::Meta::OtherRole;
259	use Mouse::Role;
260	}
261	{
262	package Foo6::SuperClass::After::Attribute;
263	use Mouse -traits =>'Foo6::Meta::OtherRole';
264	}
265	{
266	package Foo6;
267	use Mouse;
268	my @superclasses = ('Foo6::SuperClass::WithMetaRole');
269	extends @superclasses;
270
271	has an_attribute_generating_methods => ( is => 'ro' );
272
273	push(@superclasses, 'Foo6::SuperClass::After::Attribute');
274
275	::throws_ok {
276	extends @superclasses;
277	} qr/compat.*pristine/,
278	'unsafe MI extends after_generated_methods with metaclass roles';
279	::throws_ok {
280	extends reverse @superclasses;
281	} qr/compat.*pristine/,
282	'unsafe MI extends after_generated_methods with metaclass roles (reverse)';
283	}
284
285	{
286	package Foo7::Meta::Trait;
287	use Mouse::Role;
288	}
289
290	{
291	package Foo7;
292	use Mouse -traits => ['Foo7::Meta::Trait'];
293	}
294
295	{
296	package Bar7;
297	# in an external file
298	use Mouse -traits => ['Bar7::Meta::Trait'];
299	::lives_ok { extends 'Foo7' } "role reconciliation works";
300	}
301
302	{
303	package Bar72;
304	# in an external file
305	use Mouse -traits => ['Bar7::Meta::Trait2'];
306	::lives_ok { extends 'Foo7' } "role reconciliation works";
307	}
308
309	done_testing;